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

turbodesign/loss/fixedpolytropic.py

@@ -0,0 +1,27 @@
+from turbodesign.arrayfuncs import convert_to_ndarray
+from .losstype import LossBaseClass
+from ..enums import LossType
+import numpy.typing as npt
+import numpy as np
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ..bladerow import BladeRow  # for type hints only
+
+
+class FixedPolytropicEfficiency(LossBaseClass):
+    """Return a fixed polytropic efficiency target for a row (η_poly)."""
+
+    eta_poly: npt.NDArray
+
+    def __init__(self, eta_poly: float | npt.ArrayLike):
+        super().__init__(LossType.Polytropic)
+        self.eta_poly = convert_to_ndarray(eta_poly)
+
+    def __call__(self, row: "BladeRow", upstream: "BladeRow") -> npt.NDArray:  # noqa: ARG002
+        eta = self.eta_poly
+        if eta.size == 1:
+            eta = eta * np.ones_like(row.r)  # type: ignore[arg-type]
+        elif eta.shape != row.r.shape:
+            eta = np.asarray(eta).reshape(row.r.shape)  # type: ignore[attr-defined]
+        return eta

turbodesign/loss/fixedpressureloss.py

@@ -0,0 +1,30 @@
+from turbodesign.arrayfuncs import convert_to_ndarray
+from .losstype import LossBaseClass
+from ..enums import LossType
+import numpy.typing as npt 
+import numpy as np
+from scipy.interpolate import interp1d
+from typing import TYPE_CHECKING
+if TYPE_CHECKING:
+    from ..bladerow import BladeRow  # for type hints only
+
+class FixedPressureLoss(LossBaseClass):
+    """Fixed pressure loss coefficient (scalar or spanwise array)."""
+
+    pressure_loss: npt.NDArray
+    
+    def __init__(self, pressure_loss: float | npt.ArrayLike):
+        super().__init__(LossType.Pressure)
+        self.pressure_loss = convert_to_ndarray(pressure_loss)
+    
+    def __call__(self, row: "BladeRow", upstream: "BladeRow") -> npt.NDArray:
+        """Outputs the fixed pressure loss."""
+        loss = self.pressure_loss
+        if loss.size == 1:
+            loss = loss * np.ones_like(row.r) # type: ignore
+        elif loss.shape != row.r.shape:
+            if len(row.r) == 1:
+                return loss.mean()
+            else:
+                return interp1d(np.linspace(0,1,len(loss)),loss)(row.percent_hub_shroud)
+        return loss

turbodesign/loss/losstype.py

@@ -1,6 +1,7 @@
 from abc import ABC, abstractmethod
 from typing import Any, Dict, Iterable, Tuple
 from ..lossinterp import LossInterp
+import numpy.typing as npt
 import os 
 from ..enums import LossType
 
@@ -17,39 +18,10 @@ class LossBaseClass(ABC):
         self._loss_type = lossType
 
     @abstractmethod
-    def __call__(self, row:Any, upstream:Any) -> float:
+    def __call__(self, row:Any, upstream:Any) -> npt.NDArray:
         """Evaluate the loss for the supplied blade row."""
         raise NotImplementedError
-
-    
     
     @property
     def loss_type(self):
         return self._loss_type
-
-
-class CompositeLossModel(LossBaseClass):
-    """Combines multiple loss models of the same type."""
-
-    def __init__(self, models: Iterable[LossBaseClass]):
-        models_tuple: Tuple[LossBaseClass, ...] = tuple(models)
-        if not models_tuple:
-            raise ValueError("CompositeLossModel requires at least one loss model.")
-
-        loss_type = models_tuple[0].loss_type
-        for model in models_tuple[1:]:
-            if model.loss_type != loss_type:
-                raise ValueError("All loss models must share the same LossType.")
-
-        super().__init__(loss_type)
-        self._models: Tuple[LossBaseClass, ...] = models_tuple
-
-    def __call__(self, row: Any, upstream: Any) -> float:
-        total_loss = 0.0
-        for model in self._models:
-            total_loss += float(model(row, upstream))
-        return total_loss
-
-    @property
-    def models(self) -> Tuple[LossBaseClass, ...]:
-        return self._models

turbodesign/loss/turbine/TD2.py

@@ -4,7 +4,8 @@ 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 
+import numpy as np
+import numpy.typing as npt
 from ..losstype import LossBaseClass
 
 
@@ -19,44 +20,40 @@ class TD2(LossBaseClass):
     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. 
+    def __call__(self,row:BladeRow, upstream:BladeRow) -> npt.NDArray:
+        """TD2-2 manual equations 12a/12b for total pressure loss coefficient.
+
+        The implementation mirrors the original TD2 code path, which differs from
+        the textbook definition but preserves legacy behavior. Use primarily for
+        initial estimates.
 
         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 
+            1. Rotor and stator loss coefficients are equal when design requirements match.
+            2. Stage reaction at meanline is 50%.
+            3. Axial velocity is 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
+            row (BladeRow): Blade row being evaluated.
+            upstream (BladeRow): Upstream blade row supplying inlet conditions.
 
         Returns:
-            float: Total Pressure loss coefficient
+            numpy.ndarray: Total pressure loss coefficient repeated across ``row.r``.
         """
-        beta_in = row.beta1.mean() # absolute flow angle entering the blade row
-        beta_ex = row.beta2.mean()  # flow angle leaving the blade row
+        beta_in = row.beta1.mean()  # Inlet flow angle at the mean radius
+        beta_ex = row.beta2.mean()  # Exit flow angle at the mean radius
         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
+        return Y+row.r*0
     
 class TD2_Reynolds_Correction(LossBaseClass):
     
@@ -69,19 +66,18 @@ class TD2_Reynolds_Correction(LossBaseClass):
     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)
+    def __call__(self,upstream:BladeRow, row:BladeRow) -> npt.NDArray:
+        """Apply TD2 Reynolds correction (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. 
+        The correction follows td2-2.f line 2771:
+        WYECOR = WYECOR*(0.35+0.65*18.21)/(0.35+0.65*(FLWP/VISC/RST(MEAN))**0.2)
 
         Args:
-            row (BladeRow): Current Blade Row
+            upstream (BladeRow): Upstream blade row supplying inlet conditions.
+            row (BladeRow): Blade row receiving the correction.
         
         Returns:
-            float: Total Pressure loss coefficient
+            numpy.ndarray: Reynolds-corrected total pressure loss coefficient.
         """
         Y = self.TD2(upstream,row)
         A = 0.35

turbodesign/loss/turbine/__init__.py

@@ -3,6 +3,5 @@ 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 KackerOkapuu
 from .traupel import Traupel 

turbodesign/loss/turbine/ainleymathieson.py

@@ -1,5 +1,6 @@
 import pickle, os
 from typing import Dict
+import numpy.typing as npt
 from ...bladerow import BladeRow, sutherland
 from ...lossinterp import LossInterp
 from ...enums import RowType, LossType
@@ -37,7 +38,7 @@ class AinleyMathieson(LossBaseClass):
         with open(path.absolute(),'rb') as f:
             self.data = pickle.load(f) # type: ignore
             
-    def __call__(self,row:BladeRow, upstream:BladeRow) -> float:
+    def __call__(self,row:BladeRow, upstream:BladeRow) -> npt.NDArray:
         """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.
@@ -47,11 +48,11 @@ class AinleyMathieson(LossBaseClass):
             beta: blade angle relative to axial direction 
             
         Args:
-            upstream (BladeRow): Upstream blade row
-            row (BladeRow): downstream blade row
+            row (BladeRow): Blade row being evaluated.
+            upstream (BladeRow): Upstream blade row providing inlet conditions.
 
         Returns:
-            float: Pressure Loss at zero incidence 
+            numpy.ndarray: Pressure loss at zero incidence matching ``row.r``.
         """
         Kp = 12300 # Ft / (pdl C); 1 pdl = 0.138254954376 N :(
         At = row.throat
@@ -119,5 +120,5 @@ class AinleyMathieson(LossBaseClass):
         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 
+        return Yt+row.r*0   # Profile loss at zero incidence 
         

turbodesign/loss/turbine/craigcox.py

@@ -1,5 +1,6 @@
 import pickle, os
 from typing import Dict
+import numpy.typing as npt
 from ...bladerow import BladeRow, sutherland
 from ...lossinterp import LossInterp
 from ...enums import RowType, LossType
@@ -34,7 +35,7 @@ class CraigCox(LossBaseClass):
         self.C = 1/(200*32.2*778.16) # https://www.sciencedirect.com/science/article/pii/S2666202721000574 
     
     
-    def __call__(self,row:BladeRow, upstream:BladeRow) -> float:
+    def __call__(self,row:BladeRow, upstream:BladeRow) -> npt.NDArray:
         """Craig and Cox uses the enthalpy definition of loss to calculate the loss of a turbine stage. 
         
         Note: 
@@ -67,11 +68,11 @@ class CraigCox(LossBaseClass):
             - (\delta x_p)_m from Figure 8
 
         Args:
-            upstream (BladeRow): Upstream blade row
-            row (BladeRow): downstream blade row
+            row (BladeRow): Downstream blade row being evaluated.
+            upstream (BladeRow): Upstream blade row providing inlet conditions.
 
         Returns:
-            float: Stage Efficiency
+            numpy.ndarray | int: Stage efficiency; returns 0 for stators, spanwise array for rotors.
         """
         if row.row_type == RowType.Stator:
             return 0
@@ -191,5 +192,5 @@ class CraigCox(LossBaseClass):
         
         # According to Equation 3, Group 1 loss is an enthalpy loss Cp*T0. Need to convert to Pressure Loss
         eta_total = (upstream.T0.mean() - row.T0.mean())/(upstream.T0.mean()-(row.T0.mean()-T0_Loss))
-        return eta_total
+        return eta_total + row.r*0
         

turbodesign/loss/turbine/fixedefficiency.py

@@ -1,6 +1,7 @@
 from ...bladerow import BladeRow, sutherland
 from ...enums import RowType, LossType
 from ..losstype import LossBaseClass
+import numpy.typing as npt 
 
 class FixedEfficiency(LossBaseClass):
     efficiency:float
@@ -12,18 +13,18 @@ class FixedEfficiency(LossBaseClass):
         self.efficiency = efficiency
     
     
-    def __call__(self,row:BladeRow, upstream:BladeRow) -> float:
+    def __call__(self,row:BladeRow, upstream:BladeRow) -> npt.NDArray:
         """Fixed efficiency loss 
         
         Args:
-            upstream (BladeRow): Upstream blade row
-            row (BladeRow): downstream blade row
+            row (BladeRow): Blade row being evaluated.
+            upstream (BladeRow): Upstream blade row (unused, kept for API parity).
 
         Returns:
-            float: Stage Efficiency
+            numpy.ndarray: Spanwise efficiency array; zeros for stators, fixed value for rotors.
         """
         if row.row_type == RowType.Stator:
-            return 0
+            return row.r*0 
         else:
-            return self.efficiency
-        
+            return self.efficiency + row.r*0
+        

turbodesign/loss/turbine/kackerokapuu.py

@@ -4,6 +4,7 @@ from ...bladerow import BladeRow, sutherland
 from ...lossinterp import LossInterp
 from ...enums import RowType, LossType
 import numpy as np
+import numpy.typing as npt
 import pathlib
 from ..losstype import LossBaseClass
 import requests
@@ -15,6 +16,7 @@ def _mean_value(value):
 
 class KackerOkapuu(LossBaseClass):
     UseCFM:bool = False
+    
     def __init__(self,UseCFM:bool=False):
         """KackerOkapuu model is an improvement to the Ainley Mathieson model. 
         
@@ -44,7 +46,7 @@ class KackerOkapuu(LossBaseClass):
         self.UseCFM = UseCFM
         
     
-    def __call__(self,row:BladeRow, upstream:BladeRow) -> float:
+    def __call__(self,row:BladeRow, upstream:BladeRow) -> npt.NDArray:
         """Kacker Okapuu is an updated version of Ainley Mathieson and Dunham Came. This tool uses the pressure loss definition. 
 
         Note: 
@@ -54,11 +56,11 @@ class KackerOkapuu(LossBaseClass):
             Kacker, S. C., and U. Okapuu. "A mean line prediction method for axial flow turbine efficiency." (1982): 111-119.
         
         Args:
-            upstream (BladeRow): Upstream blade row
-            row (BladeRow): downstream blade row
+            row (BladeRow): Blade row being evaluated.
+            upstream (BladeRow): Upstream blade row providing inlet conditions.
 
         Returns:
-            float: Pressure Loss 
+            numpy.ndarray: Pressure loss coefficient array matching ``row.r``.
         """
         # Get the Inlet incoming mach number relative to the blade
         c = row.chord
@@ -162,5 +164,5 @@ class KackerOkapuu(LossBaseClass):
             f_re = (Rec/1E6)**-0.2
         
         Yt = Yp*f_re + Ys + Ytet + Ytc 
-        return Yt
+        return Yt+row.r*0
         

turbodesign/loss/turbine/traupel.py

@@ -4,6 +4,7 @@ from ...bladerow import BladeRow, sutherland
 from ...lossinterp import LossInterp
 from ...enums import RowType, LossType
 import numpy as np
+import numpy.typing as npt
 import pathlib
 from ..losstype import LossBaseClass
 import requests
@@ -23,15 +24,15 @@ class Traupel(LossBaseClass):
         with open(path.absolute(),'rb') as f:
             self.data = pickle.load(f) # type: ignore
         
-    def __call__(self,row:BladeRow, upstream:BladeRow) -> float:
-        """Enthalpy loss is computed for the entire stage. 
+    def __call__(self,row:BladeRow, upstream:BladeRow) -> npt.NDArray:
+        """Compute Traupel stage enthalpy efficiency from an upstream/downstream pair.
 
         Args:
-            upstream (BladeRow): Stator Row
-            row (BladeRow): Rotor Row
+            row (BladeRow): Blade row being evaluated (stator or rotor).
+            upstream (BladeRow): Upstream blade row supplying inlet conditions.
 
         Returns:
-            float: Efficiency
+            numpy.ndarray: Spanwise efficiency array matching ``row.r``.
         """
         
         alpha1 = 90-np.degrees(upstream.alpha1.mean())
@@ -52,10 +53,10 @@ class Traupel(LossBaseClass):
 
         H = self.data['Fig07'](float(alpha1-beta2), float(alpha2-beta3))
         
-        zeta_s = F*g/h_stator  # (h1-h1s)/(0.5*c1s**2) # no idea what h1s or h2s is
-        zeta_r = F*g/h_rotor # (h2-h2s)/(0.5*w2s**2)
-        x_p_stator = self.data['Fig01'](float(alpha1), float(alpha2)) # not sure if this is the right figure
-        x_p_rotor = self.data['Fig01'](float(beta2), float(beta3)) # not sure if this is the right figure
+        zeta_s = F*g/h_stator  # Stator loss factor scaled by pitch-to-span
+        zeta_r = F*g/h_rotor   # Rotor loss factor scaled by pitch-to-span
+        x_p_stator = self.data['Fig01'](float(alpha1), float(alpha2))
+        x_p_rotor = self.data['Fig01'](float(beta2), float(beta3))
         zeta_p_stator = self.data['Fig02'](float(alpha1), float(alpha2))
         x_m_stator = self.data['Fig03_0'](float(np.mean(upstream.M)))
         zeta_p_rotor = self.data['Fig02'](float(beta2), float(beta3))
@@ -72,12 +73,12 @@ class Traupel(LossBaseClass):
         x_delta_rotor = self.data['Fig05'](float(ssen_beta2), float(beta3))
         zeta_delta_rotor = self.data['Fig04'](float(ssen_beta2), float(beta3))
         
-        Dm = 2* (upstream.r[-1] + upstream.r[0])/2 # Is this the mean diameter? I dont know
+        Dm = 2* (upstream.r[-1] + upstream.r[0])/2  # Mean diameter used for annulus friction
         zeta_f = 0.5 * (h_stator/Dm)**2
         
         zeta_pr_stator = zeta_p_stator * x_p_stator * x_m_stator * x_delta_stator + zeta_delta_stator + zeta_f
         
-        Dm = 2* (row.r[-1] + row.r[0])/2 # Is this the mean diameter? I dont know
+        Dm = 2* (row.r[-1] + row.r[0])/2  # Mean diameter used for annulus friction
         zeta_f = 0.5 * (h_rotor/Dm)**2
         
         zeta_pr_rotor = zeta_p_rotor * x_p_rotor * x_m_rotor * x_delta_rotor + zeta_delta_rotor + zeta_f
@@ -85,15 +86,15 @@ class Traupel(LossBaseClass):
         if row.row_type == RowType.Stator:
             zeta_cl = 0 
         else:
-            zeta_cl = self.data['Fig08'](float(row.tip_clearance)) # For simplicity assume unshrouded blade 
+            zeta_cl = self.data['Fig08'](float(row.tip_clearance))  # Clearance loss for unshrouded blades
             
-        zeta_z = 0 # Do not factor this in, a bit complicated
-        # 1 - (internal) - (external) 
+        zeta_z = 0  # Disk friction loss not modeled
+        # 1 - (internal) - (external)
         zeta_v = 0 
         zeta_off = 0 
-        eta_stator = 1- (zeta_pr_stator + zeta_s + 0 + zeta_z) - (zeta_r+zeta_v) - zeta_off # Presentation slide 9
+        eta_stator = 1- (zeta_pr_stator + zeta_s + 0 + zeta_z) - (zeta_r+zeta_v) - zeta_off  # Per Traupel formulation
         eta_rotor = 1 - (zeta_pr_rotor + zeta_r + zeta_cl + zeta_z) - (zeta_r+zeta_v) - zeta_off
-        return eta_stator+eta_rotor
+        return (eta_stator+eta_rotor) + row.r*0
         
         
         

turbodesign/outlet.py

@@ -1,43 +1,89 @@
 from dataclasses import dataclass, field
-from typing import List, Union
+from enum import Enum
+from typing import List, Optional, Union
+
 from .enums import RowType
-from .bladerow import BladeRow, compute_gas_constants, interpolate_quantities
+from .bladerow import BladeRow
 from .arrayfuncs import convert_to_ndarray
 import numpy as np
 import numpy.typing as npt 
-import copy 
 from scipy.interpolate import interp1d
 
+class OutletType(Enum):
+    static_pressure = 1
+    total_pressure = 2
+    massflow_static_pressure = 3 
 
 class Outlet(BladeRow):
     P_fun:interp1d
-    
-    def __init__(self,P:Union[float,List[float]],percent_radii:Union[List[float],float],num_streamlines:int=3,location:float=1):
-        """Initialize the outlet
+    P0_fun:interp1d
+    num_streamlines:int
+    outlet_type: OutletType = OutletType.static_pressure
+    percent_hub_shroud:npt.NDArray
+
+    def __init__(self,num_streamlines:int=3,location:float=1):
+        """Initialize the outlet with streamlines and a location as a percentage along the hub
 
         Args:
-            P (Union[float,List[float]]): List of static pressure profile at outlet
-            percent_radii (List[float]): Percent Radius from 0 to 1 or just put 0.5 and it uses all of it 
+            num_streamlines (int, optional): _description_. Defaults to 3.
+            location (float, optional): Location as percentage along hub curve. Defaults to 1.
+        """
+        super().__init__(hub_location=location, row_type=RowType.Outlet, stage_id=-1)
+        self.loss_function = None
+        self.location = location
+        self.num_streamlines = num_streamlines
+        # Evenly spaced from hub (0) to shroud (1)
+        self.percent_hub_shroud = np.linspace(0, 1, self.num_streamlines)
+        
+    def init_static(self,P:Union[List[float],float],percent_radii:Union[List[float],float],massflow:float | None = None):
+        """Initialize turbine inputs
+
+        Args:
+            P (float): Exit static pressure [Pa]
+            percent_radii (Union[List[float],float]): percent radii where the exit static pressure is defined.
+            massflow (float | None): initialize with a massflow. Note this is only valid if you set the solver to solve to MassflowConstraint.AngleMatch
         """
-        self.P = convert_to_ndarray(P)
         self.percent_hub_shroud = convert_to_ndarray(percent_radii)
         if len(self.percent_hub_shroud)==1:
-            self.percent_hub_shroud = np.arange(0,1,num_streamlines)
-            self.P = self.P[0]+0*self.percent_hub_shroud*0
+            self.percent_hub_shroud = np.linspace(0,1,self.num_streamlines)
+        self.P = convert_to_ndarray(P)
+        self.P = self.P[0]+0*self.percent_hub_shroud*0
         self.P_fun = interp1d(self.percent_hub_shroud,self.P)
-        self.row_type = RowType.Outlet
-        self.loss_function = None
-        self.location = location
-    
-    
+        
+        if massflow is not None:
+            self.total_massflow = massflow
+            self.outlet_type = OutletType.massflow_static_pressure
+        else:
+            self.outlet_type = OutletType.static_pressure    
+        
+    def init_total(self,P0:Union[List[float],float],percent_radii:Union[List[float],float]):
+        """Initialize compressor inputs
+
+        Args:
+            P0 (Union[List[float],float]): Exit Total Pressure (this will be matched)
+            percent_radii (Union[List[float],float]): percent radii where exit total pressure is defined
+        """
+
+        self.percent_hub_shroud = convert_to_ndarray(percent_radii)
+        self.IsCompressor = True
+        self.P0 = convert_to_ndarray(P0)
+        self.P0 = self.P0[0]+0*self.percent_hub_shroud*0
+        self.P0_fun = interp1d(self.percent_hub_shroud,self.P0)
+        self.IsCompressor = True
+        self.outlet_type = OutletType.total_pressure
+        self.P = self.P0 # Do this first but we will adjust
+        
     def transfer_quantities(self,upstream:BladeRow):
         """Transfer quantities from upstream row to outlet while maintaining the outlet static pressure
 
         Args:
-            upstream (BladeRow): Upstream row, for turbines this is a rotor, for compressors this is a stator. 
+            upstream (BladeRow): Upstream row, for turbines this is a rotor, for compressors this is a stator.
         """
-        self.__dict__ = upstream.__dict__.copy() # Copies P and hub shroud percentage  
-        self.P_fun = interp1d(self.percent_hub_shroud,self.P)
+        self.__dict__ = upstream.__dict__.copy() # Copies P and hub shroud percentage
+        if self.outlet_type == OutletType.static_pressure:
+            self.P_fun = interp1d(self.percent_hub_shroud,self.P)
+        else: # Compressor
+            self.P0_fun = interp1d(self.percent_hub_shroud,self.P0)
         self.row_type = RowType.Outlet
         
     
@@ -45,14 +91,27 @@ class Outlet(BladeRow):
         """Returns the static pressure at a certain percent hub_shroud
 
         Args:
-            percent_hub_shroud (Union[float,npt.NDArray]): _description_
+            percent_hub_shroud (Union[float,npt.NDArray]): value or array from 0 to 1 where you want the exit static pressure
 
         Returns:
-            _type_: _description_
+            npt.NDArray: Returns an array of static pressure
         """
         if type(percent_hub_shroud) == float:
             return float(self.P_fun(percent_hub_shroud))
         else:
             return self.P_fun(percent_hub_shroud)
+    
+    def get_total_pressure(self, percent_hub_shroud:Union[float,npt.NDArray]):
+        """Returns the total pressure at a certain percent hub shroud 
+
+        Args:
+            percent_hub_shroud (Union[float,npt.NDArray]): value or array from 0 to 1 where you want the exit total pressure
+
+        Returns:
+            npt.NDArray: Returns an array of total pressure
+        """
+        if type(percent_hub_shroud) == float:
+            return float(self.P0_fun(percent_hub_shroud))
+        else:
+            return self.P0_fun(percent_hub_shroud)
         
-