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

turbodesign/coolant.py

@@ -1,10 +1,22 @@
-from dataclasses import dataclass, field
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Optional
+
 from cantera import Solution
 
+
 @dataclass
 class Coolant:
-    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
-    Cp:float = field(default=1000)                              # J/K
-    
+    """Simple container for coolant properties used in spool calculations."""
+
+    fluid: Optional[Solution] = None
+    T0: float = 300.0
+    P0: float = 101325.0
+    massflow_percentage: float = 0.0
+    Cp: Optional[float] = None
+
+    def __post_init__(self) -> None:
+        # Default Cp to the provided fluid value when available.
+        if self.Cp is None:
+            self.Cp = float(self.fluid.cp) if self.fluid is not None else 0.0

turbodesign/deviation/__init__.py

@@ -0,0 +1,5 @@
+from .deviation_base import DeviationBaseClass
+from .fixed_deviation import FixedDeviation
+from .carter_deviation import CarterDeviation
+
+__all__ = ["DeviationBaseClass", "FixedDeviation", "CarterDeviation"]

turbodesign/deviation/axial_compressor.py

@@ -0,0 +1,3 @@
+from .carter_deviation import CarterDeviation
+
+__all__ = ["CarterDeviation"]

turbodesign/deviation/carter_deviation.py

@@ -0,0 +1,79 @@
+from typing import Optional, TYPE_CHECKING
+
+import numpy as np
+import numpy.typing as npt
+
+from ..arrayfuncs import convert_to_ndarray
+from ..enums import RowType
+from .deviation_base import DeviationBaseClass
+
+if TYPE_CHECKING:
+    from ..bladerow import BladeRow  # for type hints only
+
+
+class CarterDeviation(DeviationBaseClass):
+    """Carter-style exit deviation for axial compressor blades.
+
+    Uses Mattingly's form:
+        gamma_e = (4 * alpha_exit * sqrt(sigma) - gamma_i) / (4 * sqrt(sigma) - 1)
+        deviation = alpha_exit - gamma_e
+
+    where gamma_i/gamma_e are inlet/exit metal (or flow) angles and sigma is solidity.
+    """
+
+    def __init__(self, gamma_inlet: Optional[float | npt.ArrayLike] = None, gamma_exit: Optional[float | npt.ArrayLike] = None, alpha_exit: Optional[float | npt.ArrayLike] = None):
+        """
+        Args:
+            gamma_inlet: Optional inlet metal/camber angle array (radians). If not
+                provided, defaults to ``row.alpha1`` (stator) or ``row.beta1`` (rotor).
+            gamma_exit: Optional exit metal/camber angle array (radians). If not
+                provided, defaults to ``row.alpha2`` (stator) or ``row.beta2`` (rotor).
+            alpha_exit: Optional flow exit angle array (radians). If not provided,
+                defaults to ``row.alpha2`` for stators and ``row.beta2`` for rotors.
+        """
+        super().__init__()
+        self.gamma_inlet = gamma_inlet
+        self.gamma_exit = gamma_exit
+        self.alpha_exit = alpha_exit
+
+    def _spanwise(self, value: float | npt.ArrayLike, row: "BladeRow") -> npt.NDArray:
+        """Convert scalar/array input to spanwise distribution on row grid."""
+        arr = convert_to_ndarray(value)
+        if arr.size == 1:
+            return arr * np.ones_like(row.percent_hub_shroud, dtype=float)
+        t_src = np.linspace(0, 1, arr.size)
+        return np.interp(row.percent_hub_shroud, t_src, arr)
+
+    def __call__(self, row: "BladeRow", upstream: "BladeRow") -> npt.NDArray:  # noqa: ARG002
+        """Compute deviation (radians) along the span for the supplied row."""
+        gamma_i = self.gamma_inlet
+        gamma_e = self.gamma_exit
+        alpha_exit = self.alpha_exit
+
+        if gamma_i is None:
+            gamma_i = getattr(row, "gamma_inlet", None)
+        if gamma_e is None:
+            gamma_e = getattr(row, "gamma_exit", None)
+        if alpha_exit is None:
+            alpha_exit = row.alpha2 if row.row_type == RowType.Stator else row.beta2
+
+        # Default to blade flow angles if no explicit camber/metal angles are provided.
+        if gamma_i is None:
+            gamma_i = row.alpha1 if row.row_type == RowType.Stator else row.beta1
+        if gamma_e is None:
+            gamma_e = row.alpha2 if row.row_type == RowType.Stator else row.beta2
+
+        gamma_i_span = self._spanwise(gamma_i, row)
+        alpha_exit_span = self._spanwise(alpha_exit, row)
+
+        sigma = getattr(row, "solidity", 0.0) or 0.0
+        sigma = max(float(sigma), 1e-6)  # avoid divide-by-zero
+        k = np.sqrt(sigma)
+
+        if gamma_e is not None:
+            gamma_e_span = self._spanwise(gamma_e, row)
+        else:
+            gamma_e_span = (4.0 * alpha_exit_span * k - gamma_i_span) / np.maximum(4.0 * k - 1.0, 1e-6)
+
+        deviation = alpha_exit_span - gamma_e_span
+        return deviation

turbodesign/deviation/deviation_base.py

@@ -0,0 +1,20 @@
+from abc import ABC, abstractmethod
+from typing import Any, Dict, Iterable, Tuple
+import numpy.typing as npt
+import os 
+
+class DeviationBaseClass(ABC):  
+    """All deviation models should inherit from this abstract base class 
+    """
+    def __init__(self):
+        # 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)
+        
+    @abstractmethod
+    def __call__(self, row:Any, upstream:Any) -> npt.NDArray:
+        """Evaluate the loss for the supplied blade row."""
+        raise NotImplementedError
+    
+

turbodesign/deviation/fixed_deviation.py

@@ -0,0 +1,42 @@
+from typing import Optional, TYPE_CHECKING
+
+import numpy as np
+import numpy.typing as npt
+from scipy.interpolate import interp1d
+
+from ..arrayfuncs import convert_to_ndarray
+from .deviation_base import DeviationBaseClass
+
+if TYPE_CHECKING:
+    from ..bladerow import BladeRow  # for type hints only
+
+
+class FixedDeviation(DeviationBaseClass):
+    """Fixed deviation angle (scalar or spanwise distribution)."""
+
+    t: Optional[npt.ArrayLike]
+    deviation_angles: npt.NDArray
+    
+    def __init__(self, deviation_angles: float | npt.ArrayLike, t: Optional[npt.ArrayLike] = None):
+        """
+        Args:
+            deviation_angles: deviation angle in degrees; either scalar or an array
+                along the span (0 at hub to 1 at shroud).
+            t: optional spanwise coordinates corresponding to ``deviation_angles``.
+                If not provided and ``deviation_angles`` is array-like, a uniform
+                spanwise distribution is assumed.
+        """
+        super().__init__()
+        self.deviation_angles = convert_to_ndarray(deviation_angles)
+        self.t = t
+    
+    def __call__(self, row: "BladeRow", upstream: "BladeRow") -> npt.NDArray:
+        """Outputs the fixed deviation distribution."""
+        deviation_angles = self.deviation_angles
+        if deviation_angles.size == 1:
+            deviation = deviation_angles * np.ones_like(row.r)
+        else:
+            if self.t is None:
+                self.t = np.linspace(0, 1, len(self.deviation_angles))
+            deviation = interp1d(self.t, self.deviation_angles, bounds_error=True)(row.percent_hub_shroud)
+        return deviation

turbodesign/enums.py

@@ -4,18 +4,17 @@ class LossType(Enum):
     Pressure = 1
     Enthalpy = 2
     Entropy = 3
+    Polytropic = 4
 
 class RowType(Enum):
+    # Similar to a stator but for compressor calculations there is no Total Pressure rise
+    IGV = 0
     Stator = 1
-    Rotor = 2 
+    Rotor = 2
     CounterRotating = 2
     Inlet = 3
     Outlet = 4
 
-class MassflowConstraint(Enum):
-    MatchMassFlow = 1 # Changes the exit angles to match the massflow
-    BalanceMassFlow = 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.
     
@@ -33,4 +32,4 @@ class PowerType(Enum):
 
 class PassageType(Enum):
     Centrifugal=0
-    Axial=1
+    Axial=1

turbodesign/flow_math.py

@@ -0,0 +1,158 @@
+from typing import Tuple
+
+import numpy as np
+import numpy.typing as npt
+
+from .bladerow import BladeRow
+from .enums import RowType
+
+def compute_streamline_areas(row: BladeRow) -> Tuple[float, npt.NDArray]:
+    """Compute total annulus area and individual streamline cross-sectional areas.
+
+    Calculates the total annulus area and the cross-sectional area for each streamtube
+    based on the radial (r) and axial (x) coordinates of the blade row. Handles both
+    axial machines (constant x) and radial machines (varying x).
+
+    Args:
+        row: BladeRow object containing percent_hub_shroud, x, r coordinates
+
+    Returns:
+        tuple: (total_area, streamline_area) where
+            - total_area (float): Total annulus cross-sectional area [m²]
+            - streamline_area (ndarray): Array of streamtube areas [m²] matching row.r shape
+    """
+    total_area = 0.0
+    streamline_area = np.zeros(len(row.percent_hub_shroud))
+    if len(row.percent_hub_shroud) <= 1:
+        if hasattr(row, "total_area") and row.total_area:
+            total_area = float(row.total_area)
+            streamline_area = np.array([total_area])
+        return total_area, streamline_area
+    for j in range(1, len(row.percent_hub_shroud)):
+        if np.abs((row.x[j] - row.x[j - 1])) < 1e-5:  # Axial machines
+            delta = np.pi * (row.r[j] ** 2 - row.r[j - 1] ** 2)
+            streamline_area[j] = delta
+            total_area += delta
+        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)
+            streamline_area[j] = 2 * np.pi * C * (S / 2 * dx ** 2 + row.r[j - 1] * dx)
+            total_area += streamline_area[j]
+    return total_area, streamline_area
+
+
+def compute_massflow(row: BladeRow) -> None:
+    """Calculate massflow distribution across streamlines and populate row attributes.
+
+    Computes the cumulative massflow through each streamtube based on density, meridional
+    velocity, and streamtube cross-sectional areas. Accounts for blockage and optional
+    coolant injection. Updates row attributes in-place.
+
+    Args:
+        row: BladeRow object with Vm, rho, percent_hub_shroud, blockage defined
+
+    Returns:
+        None. Updates the following row attributes in-place:
+            - row.massflow: Cumulative massflow array [kg/s]
+            - row.total_massflow: Total massflow including coolant [kg/s]
+            - row.total_massflow_no_coolant: Massflow without coolant [kg/s]
+            - row.calculated_massflow: Final massflow value [kg/s]
+            - row.total_area: Total annulus area [m²]
+            - row.area: Streamtube areas array [m²]
+    """
+    n = len(row.percent_hub_shroud)
+    massflow_fraction = np.linspace(0, 1, n)
+    total_area, streamline_area = compute_streamline_areas(row)
+
+    if n <= 1:
+        Vm = float(row.Vm[0]) if len(row.Vm) else 0.0
+        rho = float(row.rho[0]) if len(row.rho) else 0.0
+        mass = Vm * rho * (total_area if total_area else 0.0) * (1 - row.blockage)
+        massflow = np.array([mass])
+        row.total_massflow_no_coolant = mass
+        if row.coolant is not None:
+            massflow += row.coolant.massflow_percentage * mass
+        row.massflow = massflow
+        row.calculated_massflow = massflow[-1]
+        row.total_massflow = massflow[-1]
+        row.total_area = total_area
+        row.area = streamline_area
+        return
+
+    massflow = np.zeros_like(row.percent_hub_shroud, dtype=float)
+    for j in range(1, n):
+        Vm = (row.Vm[j] + row.Vm[j - 1]) / 2
+        rho = (row.rho[j] + row.rho[j - 1]) / 2
+        massflow[j] = Vm * rho * streamline_area[j] * (1 - row.blockage) + massflow[j - 1]
+
+    row.total_massflow_no_coolant = massflow[-1]
+    if row.coolant is not None:
+        # account for coolant as a fraction of inlet flow
+        massflow += massflow_fraction * row.coolant.massflow_percentage * row.total_massflow_no_coolant
+    row.massflow = massflow
+    row.calculated_massflow = massflow[-1]
+    row.total_massflow = massflow[-1]
+    row.total_area = total_area
+    row.area = streamline_area
+
+
+def compute_power(row: BladeRow, upstream: BladeRow | None = None, downstream: BladeRow | None = None, is_compressor: bool | None = None) -> None:
+    """Calculate power and efficiencies for a blade row (compressor or turbine).
+
+    Args:
+        row: The blade row being evaluated.
+        upstream: Upstream reference row (default for turbine-style calculations).
+        downstream: Downstream reference row (optional; useful for compressor-style staging).
+        is_compressor: Force compressor sign convention when True (power added to flow);
+            when False, assumes turbine (power extracted). If None, infers from P0 gain.
+    """
+    ref = upstream if upstream is not None else downstream
+    if ref is None:
+        return
+
+    mdot = row.massflow[-1] if getattr(row, "massflow", np.array([])).size else getattr(row, "total_massflow", 0.0)
+
+    if row.row_type == RowType.Stator:
+        row.power = 0.0
+        row.eta_static = 0.0
+        row.eta_total = 0.0
+        row.stage_loading = 0.0
+        row.euler_power = 0.0
+        row.T_is = 0 * row.T0
+        row.T0_is = 0 * row.T0  # Make it an array
+    else:
+        # Preserve any user-configured target ratio. compute_power historically overwrote row.P0_ratio,
+        # which makes it hard to treat P0_ratio as a design input elsewhere.
+        if getattr(row, "P0_ratio_target", 0.0) == 0 and getattr(row, "P0_ratio", 0.0) != 0:
+            row.P0_ratio_target = row.P0_ratio
+
+        P0_P = (ref.P0 / row.P).mean()
+        P0_ratio_actual = (row.P0 / ref.P0).mean()
+        row.P0_ratio = P0_ratio_actual
+        setattr(row, "P0_ratio_actual", float(P0_ratio_actual))
+        row.T_is = ref.T0 * (1 / P0_P) ** ((row.gamma - 1) / row.gamma)
+        row.T0_is = ref.T0 * (row.P0 / ref.P0) ** ((row.gamma - 1) / row.gamma)
+
+        comp_mode = is_compressor
+        if comp_mode is None:
+            comp_mode = bool(np.mean(row.P0) > np.mean(ref.P0))
+
+        if comp_mode:
+            deltaT = row.T0.mean() - ref.T0.mean()
+            row.power = mdot * row.Cp * deltaT
+            denom_static = max(row.T.mean() - ref.T0.mean(), 1e-9)
+            denom_total = max(row.T0.mean() - ref.T0.mean(), 1e-9)
+            row.eta_static = (row.T_is.mean() - ref.T0.mean()) / denom_static
+            row.eta_total = (row.T0_is.mean() - ref.T0.mean()) / denom_total
+        else:
+            deltaT = ref.T0.mean() - row.T0.mean()
+            row.power = mdot * row.Cp * deltaT
+            row.eta_static = row.power / (mdot * row.Cp * (ref.T0.mean() - row.T_is.mean()))
+            row.eta_total = (ref.T0.mean() - row.T0.mean()) / (ref.T0.mean() - row.T0_is.mean())
+        
+        row.stage_loading = row.Cp * (ref.T0.mean() - row.T0.mean()) / max(row.U.mean() ** 2, 1e-9)
+        if is_compressor:
+            row.stage_loading *= -1 # Stage_loading will be negative 
+        row.euler_power = mdot * (ref.U * ref.Vt - row.U * row.Vt).mean()
+        row.flow_coefficient = abs(float(np.mean(row.Vm / row.U)))

turbodesign/inlet.py

@@ -1,8 +1,10 @@
 from dataclasses import dataclass, field
-from typing import List, Union
+from optparse import Option
+from typing import List, Optional, Union
+
 from .enums import RowType
-from .bladerow import BladeRow, compute_gas_constants, interpolate_quantities
-from .arrayfuncs import convert_to_ndarray
+from .bladerow import BladeRow, compute_gas_constants
+from .arrayfuncs import convert_to_ndarray, safe_interpolate
 import numpy as np 
 from cantera import Solution
 from .passage import Passage
@@ -16,41 +18,88 @@ class Inlet(BladeRow):
         (BladeRow): Defines the properties of the blade row
     """
     fun: interp1d
-    
-    def __init__(self,M:float,T0:Union[float,List[float]],
-                 P0:Union[float,List[float]],
-                 location:float=0,
-                 beta:Union[float,List[float]]=[0],
-                 percent_radii:Union[float,List[float]]=[0.5]):
+    static_defined: bool
+    def __init__(self, 
+                 hub_location:float=0,
+                 shroud_location:Optional[float]=None,
+                 alpha: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
-            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
             location (float): Location as a percentage of hub length
             beta (Union[float,List[float]], optional): Inlet flow angle in relative direction. Defaults to [].
 
         """
-        super().__init__(row_type=RowType.Inlet,location=location,stage_id=-1)
-        self.beta1 = convert_to_ndarray(beta)
+        super().__init__(row_type=RowType.Inlet,hub_location=hub_location,shroud_location=shroud_location,stage_id=-1)
+        self.beta1 = convert_to_ndarray([0.0])
+        # Default absolute angles to zero to avoid attribute errors during interpolation
+        self.alpha1 = convert_to_ndarray([0.0])
+        self.alpha2 = convert_to_ndarray(alpha)
+        self.beta2 = convert_to_ndarray([0.0])
+                   
+    
+    def init_static(self,P:Union[float,List[float]],T:Union[float,List[float]],M:Union[float,List[float]],percent_radii:Union[float,List[float]]=[0.5]):
+        """Initializes the inlet with static quantities at the inlet
+
+        Args:
+            P (Union[float,List[float]]): Static Pressure either as a float or array
+            T (Union[float,List[float]]): Static Temperature either as a float or array 
+            M (Union[float,List[float]]): Mach Number either as a float or array 
+            percent_radii (Union[float,List[float]], optional): Percent radii where P,T, and M are defined. Defaults to [0.5].
+        """
+        self.P = convert_to_ndarray(P)
         self.M = convert_to_ndarray(M)
-        self.T0 = convert_to_ndarray(T0)
-        self.P0 = convert_to_ndarray(P0)
+        self.T = convert_to_ndarray(T)
+        self.static_defined = True
         self.percent_hub_shroud = convert_to_ndarray(percent_radii)
-   
-    def initialize_inputs(self,num_streamlines:int=5):
-        self.M = interpolate_quantities(self.M, self.percent_hub_shroud, np.linspace(0,1,num_streamlines))
-        self.P0 = interpolate_quantities(self.P0,self.percent_hub_shroud, np.linspace(0,1,num_streamlines))
-        self.T0 = interpolate_quantities(self.T0,self.percent_hub_shroud, np.linspace(0,1,num_streamlines)) 
-        # if it's inlet alpha and beta are the same, relative flow angle = absolute. 
-        self.beta1 = interpolate_quantities(self.beta1,self.percent_hub_shroud, np.linspace(0,1,num_streamlines)) 
-        self.beta2 = np.radians(convert_to_ndarray(self.beta1))
-        self.alpha1 = np.radians(convert_to_ndarray(self.beta1))         
         
-    def initialize_fluid(self,fluid:Solution=None,R:float=287.15,gamma:float=1.4,Cp:float=1024):
+    def init_total(
+        self,
+        P0:Union[float,List[float]],
+        T0:Union[float,List[float]],
+        M:Union[float,List[float]],
+        percent_radii:Optional[Union[float,List[float]]]=None
+    ):
+        """Initializes the inlet with total quantities at the inlet
+
+        Args:
+            P0 (Union[float,List[float]]): Total Pressure either as a float or array 
+            T0 (Union[float,List[float]]): Total Temperature either as a float or array 
+            M (Union[float,List[float]]): Mach Number either as a float or array 
+            percent_radii (Optional[Union[float,List[float]]], optional): Percent radii where P0, T0, and M are defined. Defaults to `None`, which uses evenly spaced radii when multiple values exist or `[0.5]` otherwise.
+        """
+        self.P0 = convert_to_ndarray(P0)
+        self.T0 = convert_to_ndarray(T0) 
+        self.M = convert_to_ndarray(M)
+        if percent_radii is None:
+            percent_radii = convert_to_ndarray([0.5]) # type: ignore
+        if len(self.M)>1: 
+            percent_radii = np.linspace(0,1,len(self.M))  # type: ignore
+        self.static_defined = False
+        self.percent_hub_shroud = percent_radii
+        
+    def __interpolate_quantities__(self,num_streamlines:int=5):
+        """Initializes the inputs 
+        
+        Args:
+            num_streamlines (int, optional): _description_. Defaults to 5.
+            IsCompressor (bool, optional): This is if static pressure is defined at the inlet and total pressure at the outlet. Defaults to False.
+        """
+        dst = np.array([0.5]) if num_streamlines <= 1 else np.linspace(0,1,num_streamlines)
+        self.M = safe_interpolate(self.M, self.percent_hub_shroud, dst)
+        if self.static_defined: # This comes from the initialization
+            self.P = safe_interpolate(self.P, self.percent_hub_shroud, dst)
+        else:
+            self.P0 = safe_interpolate(self.P0, self.percent_hub_shroud, dst)
+        self.T0 = safe_interpolate(self.T0, self.percent_hub_shroud, dst)
+        # Angles: default to 0 if unspecified
+        self.beta1 = safe_interpolate(self.beta1, self.percent_hub_shroud, dst, radians=True)
+        self.beta2 = safe_interpolate(self.beta2, self.percent_hub_shroud, dst, radians=True)
+        self.alpha1 = safe_interpolate(self.alpha1, self.percent_hub_shroud, dst, radians=True)
+        self.alpha2 = safe_interpolate(self.alpha2, self.percent_hub_shroud, dst, radians=True)
+        
+    def __initialize_fluid__(self,fluid:Optional[Solution]=None,R:float=287.15,gamma:float=1.4,Cp:float=1024):
         """Initialize the inlet using the fluid. This function should be called by a class that inherits from spool
 
         Args:
@@ -58,15 +107,18 @@ class Inlet(BladeRow):
             R (float, optional): Ideal Gas Constant. Defaults to 287.15 J/(Kg K) for air
             gamma (float, optional): _description_. Defaults to 1.4.
             Cp (float, optional): _description_. Defaults to 1024 J/(Kg K).
-        
         """
         self.loss_function = None
         
         if fluid:
             fluid.TP = self.T0.mean(),self.P0.mean()
             self.gamma = fluid.cp/fluid.cv
+            if self.static_defined:
+                self.P0 = self.P * (1+(self.gamma-1)/2 * self.M**2) ** (self.gamma/(self.gamma-1))
+                self.T0 = self.T * (1+(self.gamma-1)/2 * self.M**2)
+            else:
+                self.P = self.P0 * 1/(1 + (self.gamma-1) * self.M**2)**(self.gamma/(self.gamma-1))
             self.T = self.T0 * 1/(1 + (self.gamma-1) * self.M**2)
-            self.P = self.P0 * 1/(1 + (self.gamma-1) * self.M**2)**(self.gamma/(self.gamma-1))
             fluid.TP = self.T.mean(),self.P.mean()
             self.rho = convert_to_ndarray([fluid.density])
         else:
@@ -74,10 +126,13 @@ class Inlet(BladeRow):
             self.gamma = gamma
             self.R = R
             self.T = self.T0 * 1/(1 + (self.gamma-1) * self.M**2)
-            self.P = self.P0 * 1/(1 + (self.gamma-1) * self.M**2)**(self.gamma/(self.gamma-1))
+            if self.static_defined:
+                self.P0 = self.P * (1+(self.gamma-1)/2 * self.M**2) ** (self.gamma/(self.gamma-1)) 
+                self.T0 = self.T * (1+(self.gamma-1)/2 * self.M**2)
+            else:
+                self.P = self.P0 * 1/(1 + (self.gamma-1) * self.M**2)**(self.gamma/(self.gamma-1))
             self.rho = self.P/(self.R*self.T)
 
-        self.rpm = 0
         self.beta1_metal = [0] 
         self.beta2_metal = [0]
         if len(self.percent_hub_shroud) == 1:
@@ -86,9 +141,9 @@ class Inlet(BladeRow):
             self.T0 = self.percent_hub_shroud*0+self.T0[0]
         self.P0_fun = interp1d(self.percent_hub_shroud,self.P0)
         self.T0_fun = interp1d(self.percent_hub_shroud,self.T0)
-        self.mprime = [0]
+        self.mprime = [0] # type: ignore
         
-    def initialize_velocity(self,passage:Passage,num_streamlines:int):
+    def __initialize_velocity__(self,passage:Passage,num_streamlines:int):
         """Initialize velocity calculations. Assumes streamlines and inclination angles have been calculated 
             Call this before performing calculations
             
@@ -100,13 +155,14 @@ class Inlet(BladeRow):
         # Perform Calculations on Velocity 
         Vm_prev = 0; Vm_err = 0 
 
-        cutline,_,_ = passage.get_cutting_line(self.location)
-        self.x,self.r = cutline.get_point(np.linspace(0,1,num_streamlines))
-        for _ in range(10):
+        cutline,_,_ = passage.get_cutting_line(t_hub=self.location,t_shroud=self.shroud_location)
+        t_span = np.array([0.5]) if num_streamlines <= 1 else np.linspace(0,1,num_streamlines)
+        self.x,self.r = cutline.get_point(t_span)
+        for _ in range(2):
             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)
+                        / (1+np.cos(self.phi)**2 * np.tan(self.alpha2)**2)
 
             self.Vm = np.sqrt(self.Vm)
             self.T = self.T0/T0_T
@@ -114,40 +170,54 @@ class Inlet(BladeRow):
             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.Vt = self.Vm * np.cos(self.phi) * np.tan(self.alpha2)
             self.V = np.sqrt(self.Vm**2 + self.Vt**2)        
             self.Vr = self.Vm * np.sin(self.phi) 
             
             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]
+            Vm_tube = np.zeros(max(len(self.massflow)-1, 1))
+            if len(self.massflow) <= 1:
+                Vm_tube[0] = float(self.Vm.mean())
+            # Compute tube-averaged Vm from massflow differences
+            for i in range(1, len(self.massflow)):
+                tube_massflow = self.massflow[i]-self.massflow[i-1]
+                rho_bar = rho_mean if len(self.rho) == 1 else 0.5 * (self.rho[i] + self.rho[i-1])
                 if np.abs((self.x[-1]-self.x[0]))<1E-5: # Axial Machines
-                    self.Vm[i+1] = tube_massflow/(rho_mean*np.pi*(self.r[i+1]**2-self.r[i]**2))
+                    area = np.pi*(self.r[i]**2-self.r[i-1]**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()
+                Vm_tube[i-1] = tube_massflow/(rho_bar*area + 1e-12)
+
+            # Recover per-streamline Vm; handle single-streamline as meanline
+            if len(self.Vm) <= 1:
+                self.Vm = np.array([Vm_tube[0] if len(Vm_tube) else rho_mean*0])
+            else:
+                self.Vm[0] = Vm_tube[0]
+                for i in range(1, len(self.Vm)):
+                    self.Vm[i] = 2 * Vm_tube[i-1] - self.Vm[i-1]
             
-            self.M = self.Vm /np.sqrt(self.gamma*self.R*self.T)
+            self.M = self.V /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)
-                
+        if num_streamlines <= 1:
+            Area = passage.get_area(self.location)
+        else:
+            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
 
 
@@ -177,4 +247,4 @@ class Inlet(BladeRow):
         if type(percent_hub_shroud) == float:
             return float(self.T0_fun(percent_hub_shroud))
         else:
-            return self.T0_fun(percent_hub_shroud)
+            return self.T0_fun(percent_hub_shroud)