turbo-design 1.3.7__py3-none-any.whl → 1.3.9__py3-none-any.whl

turbodesign/bladerow.py

@@ -1,4 +1,4 @@
-from dataclasses import field, Field
+from dataclasses import dataclass, field, Field
 from typing import Any, Callable, List, Optional, Sequence, Tuple, Union
 from .enums import RowType, PowerType
 import numpy as np 
@@ -9,45 +9,53 @@ from cantera import Solution, composite
 from .coolant import Coolant
 from pyturbo.helper import line2D
 from pyturbo.aero.airfoil2D import Airfoil2D
-from .loss import LossBaseClass, CompositeLossModel
+from .loss import LossBaseClass
+from .deviation.deviation_base import DeviationBaseClass
 from .passage import Passage
+from .arrayfuncs import safe_interpolate
     
 
+@dataclass(eq=False)
 class BladeRow:
-    id:int = 0
-    stage_id:int = 0
+    id: int = 0
+    stage_id: int = 0
     row_type: RowType = RowType.Stator
-    loss_function:LossBaseClass
-    cutting_line:line2D         # Line perpendicular to the streamline
-    rp:float = 0.4              # Degree of Reaction
-    
+    loss_function: Optional[LossBaseClass] = None
+    deviation_function: Optional[DeviationBaseClass] = None
+    cutting_line: Optional[line2D] = None         # Line perpendicular to the streamline
+    rp: float = 0.4              # Degree of Reaction
+    hub_location: float = 0.0
+    shroud_location: float = 0.0
+
     # Fluid
     R: float = 287.15           # Ideal Gas constant J/(Kg K)
     gamma: float = 1.33         # Ratio of Cp/Cv
     Cp: float = 1019            # Cp J/(Kg*K)
     Cv: float = 1019/1.14       # Cv J/(Kg*K)
-    _coolant:Coolant = None     # type: ignore # Coolant Fluid
-    mu:float = 0 
-    
-    total_massflow:float = 0    # Massflow spool + all upstream cooling flow [kg/s]
-    massflow:npt.NDArray = field(default_factory=lambda: np.array([0]))  # Massflow per radii
-    total_massflow_no_coolant:float = 0     # Inlet massflow
+    _coolant: Optional[Coolant] = None     # Coolant Fluid
+    mu: float = 0
+
+    total_massflow: float = 0    # Massflow spool + all upstream cooling flow [kg/s]
+    massflow: npt.NDArray = field(default_factory=lambda: np.array([0]))  # Massflow per radii
+    total_massflow_no_coolant: float = 0     # Inlet massflow
     # ----------------------------------
 
     # Streamline Properties 
-    percent_hub:float = 0 # Where blade row is defined along the hub. 
+    percent_hub: float = 0 # Where blade row is defined along the hub. 
     percent_hub_shroud: npt.NDArray = field(default_factory=lambda: np.array([0]))    # Percent streamline length from hub to shroud.
     x: npt.NDArray = field(default_factory=lambda: np.array([0]))       # x - coordinates (useful for computing axial chord)
     r: npt.NDArray = field(default_factory=lambda: np.array([0]))       # Radius - coordinates 
     m: npt.NDArray = field(default_factory=lambda: np.array([0]))       # meridional 
-    area:float = 0
+    total_area: float = 0
+    area: npt.NDArray = field(default_factory=lambda: np.array([0]))
     # Calculated massflow is the massflow computed after radial eq solver
     calculated_massflow: float = 0
-    
+
     # Row Efficiency (calculated or specified)
-    eta_total:float = 0     # Total to Total
-    eta_static:float = 0    # Total to static
-    stage_loading:float = 0 # stage loading how much work done per stage
+    eta_total: float = 0     # Total to Total
+    eta_static: float = 0    # Total to static
+    eta_poly: float = 0     # Polytropic efficiency (per row if applicable)
+    stage_loading: float = 0 # stage loading how much work done per stage
 
     alpha1: npt.NDArray = field(default_factory=lambda: np.array([0]))               # Blade inlet absolute flow angle
     alpha2: npt.NDArray = field(default_factory=lambda: np.array([0]))               # Blade exit absolute flow angle
@@ -55,20 +63,21 @@ class BladeRow:
     beta1: npt.NDArray = field(default_factory=lambda: np.array([0]))                 # Blade inlet relative flow angle
     beta2: npt.NDArray = field(default_factory=lambda: np.array([0]))                 # Blade exit relative flow angle
     
-    _beta1_metal:npt.NDArray = field(default_factory=lambda: np.array([0]))           # blade inlet metal angle
-    beta1_metal_radii:npt.NDArray = field(default_factory=lambda: np.array([0]))      # radii where metal angle is defined
+    deviation: npt.NDArray = field(default_factory=lambda: np.array([0])) 
+    _beta1_metal: npt.NDArray = field(default_factory=lambda: np.array([0]))           # blade inlet metal angle
+    beta1_metal_radii: npt.NDArray = field(default_factory=lambda: np.array([0]))      # radii where metal angle is defined
     
-    _beta2_metal:npt.NDArray = field(default_factory=lambda: np.array([0]))           # blade exit metal angle
-    beta2_metal_radii:npt.NDArray = field(default_factory=lambda: np.array([0]))      # radii where metal angle is defined
+    _beta2_metal: npt.NDArray = field(default_factory=lambda: np.array([0]))           # blade exit metal angle
+    beta2_metal_radii: npt.NDArray = field(default_factory=lambda: np.array([0]))      # radii where metal angle is defined
     
-    beta1_fixed:bool = False    # Geometry already defined. This affects the inlet flow angle
-    beta2_fixed:bool = False    # Geometry already defined. This affects the exit flow angle
+    beta1_fixed: bool = False    # Geometry already defined. This affects the inlet flow angle
+    beta2_fixed: bool = False    # Geometry already defined. This affects the exit flow angle
 
     # Velocities 
     Vm: npt.NDArray = field(default_factory=lambda: np.array([0]))               # Meridional velocity
     Vx: npt.NDArray = field(default_factory=lambda: np.array([0]))               # Axial Velocity
     Vt: npt.NDArray = field(default_factory=lambda: np.array([0]))               # Tangential Velocity
-    Vr:npt.NDArray = field(default_factory=lambda: np.array([0]))                # Radial velocity 
+    Vr: npt.NDArray = field(default_factory=lambda: np.array([0]))                # Radial velocity 
     V: npt.NDArray = field(default_factory=lambda: np.array([0]))                # Absolute Velocity in 3D coordinate system
     V2: npt.NDArray = field(default_factory=lambda: np.array([0]))               # Absolute Velocity in Theta-Axial plane
     M: npt.NDArray = field(default_factory=lambda: np.array([0]))                # Mach Number
@@ -77,15 +86,17 @@ class BladeRow:
     W: npt.NDArray = field(default_factory=lambda: np.array([0]))                # Relative Velocity in Theta-Axial plane
     Wt: npt.NDArray = field(default_factory=lambda: np.array([0]))               # Relative Tangential Velocity    
 
-    _rpm: float = 0 
-    omega:float = 0 # angular velocity rad/s
+    _rpm: float = field(default=0, init=False, repr=False)
+    omega: float = 0 # angular velocity rad/s
     
-    P0_stator_inlet = field(default_factory=lambda: np.array([0]))              # Every quantity is an exit quantity, This is used  for efficiency calcs
-    T0_stator_inlet = field(default_factory=lambda: np.array([0]))              # Every quantity is an exit quantity, This is used  for efficiency calcs
+    P0_stator_inlet: npt.NDArray = field(default_factory=lambda: np.array([0]))              # Every quantity is an exit quantity, This is used  for efficiency calcs
+    T0_stator_inlet: npt.NDArray = field(default_factory=lambda: np.array([0]))              # Every quantity is an exit quantity, This is used  for efficiency calcs
     P0: npt.NDArray = field(default_factory=lambda: np.array([0]))              # Total Quantities 
+    P0_is: npt.NDArray = field(default_factory=lambda: np.array([0]))
     T0: npt.NDArray = field(default_factory=lambda: np.array([0]))          
-    T0_is:npt.NDArray = field(default_factory=lambda: np.array([0])) 
+    T0_is: npt.NDArray = field(default_factory=lambda: np.array([0])) 
     P0R: npt.NDArray = field(default_factory=lambda: np.array([0]))             # Relative Total Pressure (Pa)
+    P0R_is: npt.NDArray = field(default_factory=lambda: np.array([0]))
     T0R: npt.NDArray = field(default_factory=lambda: np.array([0]))
     
     # Static Quantities
@@ -93,36 +104,49 @@ class BladeRow:
     T: npt.NDArray = field(default_factory=lambda: np.array([0]))
     T_is: npt.NDArray = field(default_factory=lambda: np.array([0]))
     rho: npt.NDArray = field(default_factory=lambda: np.array([0]))
-
+    entropy_rise: npt.NDArray = field(default_factory=lambda: np.array([0]))
+    
     # Related to streamline curvature
-    phi:npt.NDArray = field(default_factory=lambda: np.array([0]))                      # Inclination angle x,r plane. AY td2.f
+    phi: npt.NDArray = field(default_factory=lambda: np.array([0]))                      # Inclination angle x,r plane. AY td2.f
     rm: npt.NDArray = field(default_factory=lambda: np.array([0]))                      # Curvature
     incli_curve_radii: npt.NDArray = field(default_factory=lambda: np.array([0]))       # radius at which curvature was evaluated
-    mprime:npt.NDArray = field(default_factory=lambda: np.array([0]))                   # Mprime distance
-    
-    Yp: float = 0                   # Pressure loss
-    power:float = 0                 # Watts 
-    power_mean:float = 0
-    power_distribution:npt.NDArray  # How power is divided by radius. Example: Equal distribution [0.33 0.33 0.33]. More at Tip [0.2,0.3,0.5]. More at Hub [0.6 0.5 ]
-    P0_P:float = 0                  # Total to Static Pressure Ratio 
-    Power_Type:PowerType
-    euler_power:float = 0
-    Reynolds:float = 0
+    mprime: npt.NDArray = field(default_factory=lambda: np.array([0]))                   # Mprime distance
+    
+    Yp: npt.NDArray = field(default_factory=lambda: np.array([0]))                       # Pressure loss
+    blockage: float = 0 
+    flow_coefficient: float = 0     # Vm/U or similar nondimensional flow coefficient
+    power: float = 0                 # Watts 
+    power_mean: float = 0
+    power_distribution: npt.NDArray = field(default_factory=lambda: np.array([0]))  # How power is divided by radius.
+    P0_P: float = 0                  # Total to Static Pressure Ratio
+    P0_ratio: float = 0              # Total-to-total pressure ratio target (design input; may be overwritten in legacy diagnostics)
+    P0_ratio_target: float = 0       # Frozen design target for P0_ratio (never overwritten; used for initial guesses)
+    Power_Type: PowerType = PowerType.P0_P
+    euler_power: float = 0
+    Reynolds: float = 0
+    eta_poly: float = 0.0            # Optional per-row polytropic efficiency target
+    num_blades: int = 0
     
     # Used for loss calculations
-    _blade_to_blade_gap:float = 0.025 # Gap between blade in terms of percent chord.
+    _blade_to_blade_gap: float = 0.025 # Gap between blade in terms of percent chord.
     
-    _aspect_ratio:float = 0.9 # 
-    _pitch_to_chord:float = 0.7 # Pitch to chord ratio, used to determine number of blades and compute loss 
+    _aspect_ratio: float = 0.9 # 
+    _pitch_to_chord: npt.NDArray = field(default_factory=lambda: np.array([0.7])) # Pitch to chord ratio, used to determine number of blades and compute loss 
     
-    _axial_chord:float = -1 
-    _chord:float = -1 
-    _stagger:float = 42
-    _te_s:float = 0.08
-    _tip_clearance:float = 0 # Clearance as a percentage of span or blade height
+    _axial_chord: float = -1 
+    _chord: npt.NDArray = field(default_factory=lambda: np.array([-1.0]))
+    _stagger: npt.NDArray = field(default_factory=lambda: np.array([42.0]))
+    _te_s: float = 0.08
+    _tip_clearance: float = 0 # Clearance as a percentage of span or blade height
+
+    _inlet_to_outlet_pratio: list = field(default_factory=lambda: [0.06,0.95])
 
-    _inlet_to_outlet_pratio = [0.06,0.95]
-    location:float = 0 # Percent along hub where bladerow is defined
+    def __post_init__(self):
+        if self.shroud_location == 0:
+            self.shroud_location = self.hub_location
+        # Preserve any user-specified target ratio so later diagnostics can safely overwrite P0_ratio.
+        if self.P0_ratio_target == 0 and self.P0_ratio != 0:
+            self.P0_ratio_target = self.P0_ratio
     
     @property
     def inlet_to_outlet_pratio(self) -> Tuple[float,float]:
@@ -192,7 +216,7 @@ class BladeRow:
         
         
     @property
-    def pitch_to_chord(self) -> float:
+    def pitch_to_chord(self) -> npt.NDArray:
         """Gets the pitch to chord ratio 
 
         Returns:
@@ -207,10 +231,10 @@ class BladeRow:
         Args:
             val (float): new pitch to chord ratio. Typically stators are 0.8 to 0.95. Rotors 0.7 to 0.8 
         """
-        self._pitch_to_chord = val
+        self._pitch_to_chord = convert_to_ndarray(val)
     
     @property
-    def solidity(self) -> float:
+    def solidity(self) -> npt.NDArray:
         """Inverse of pitch to chord ratio
 
         Returns:
@@ -228,16 +252,28 @@ class BladeRow:
         Returns:
             float: solidity
         """
-        self._pitch_to_chord = 1/val
+        self._pitch_to_chord = 1/convert_to_ndarray(val)
 
     @property
-    def beta1_metal(self) -> npt.NDArray:
+    def metal_inlet_angle(self) -> npt.NDArray:
+        """Blade metal inlet angle (degrees)."""
         return np.degrees(self._beta1_metal)
     
     @property
-    def beta2_metal(self) -> npt.NDArray:
+    def beta1_metal(self) -> npt.NDArray:
+        """Backward-compatible alias for metal_inlet_angle."""
+        return self.metal_inlet_angle
+    
+    @property
+    def metal_exit_angle(self) -> npt.NDArray:
+        """Blade metal exit angle (degrees)."""
         return np.degrees(self._beta2_metal)
     
+    @property
+    def beta2_metal(self) -> npt.NDArray:
+        """Backward-compatible alias for metal_exit_angle."""
+        return self.metal_exit_angle
+    
     @property
     def stagger(self) -> float:
         """Average stagger angle
@@ -257,7 +293,7 @@ class BladeRow:
         self._stagger = val
     
     @property
-    def chord(self) -> float:
+    def chord(self) -> npt.NDArray:
         """Chord defined at mean radius
 
         Returns:
@@ -286,14 +322,16 @@ class BladeRow:
         else:
             return self.pitch*np.sin(np.pi/2-self.beta2.mean())
     
+    _num_blades: float = 0
+
     @property
-    def num_blades(self) ->float:
-        """returns the number of blades 
+    def num_blades(self) -> float:
+        """Configured number of blades (set during design/initialization)."""
+        return self._num_blades
 
-        Returns:
-            float: number of blades
-        """
-        return int(2*np.pi*self.r.mean() / self.pitch)
+    @num_blades.setter
+    def num_blades(self, val: float) -> None:
+        self._num_blades = val
     
     @property
     def camber(self) -> float:
@@ -330,54 +368,63 @@ class BladeRow:
         """
         self._tip_clearance = val
         
-    def __init__(self,location:float,row_type:RowType=RowType.Stator,stage_id:int = 0):
-        """Initializes the blade row to be a particular type
-
-        Args:
-            location (float): Location of the blade row as a percentage of hub length
-            row_type (RowType): Specifies the Type. Defaults to RowType.Stator
-            power (float, optional): power . Defaults to 0.
-            P0_P (float, optional): Total to Static Pressure Ratio
-            stage_id (int, optional): ID of the stage so if you have 9 stages, the id could be 9. It's used to separate the stages. Each stage will have it's own unique degree of reaction 
-        """
-        self.row_type = row_type
-        self.location = location 
-        self.Yp = 0 # Loss
-        self.stage_id = stage_id
-    
-    @beta1_metal.setter
-    def beta1_metal(self,beta1_metal:List[float],percent:List[float]=[]):
-        """Sets the leading edge metal angle for the blade
-
-        Args:
-            beta1_metal (List[float]): blade leading edge angle
-            percent (List[float]): percent location of metal angles from hub to shroud.
-        """
-        self._beta1_metal = np.radians(convert_to_ndarray(beta1_metal))
-        if len(percent) != len(beta1_metal):
-            percent = np.linspace(0,1,len(self._beta1_metal)).tolist() # type: ignore
+    # Backwards-compatible alias
+    @property
+    def location(self) -> float:
+        return self.hub_location
+
+    @location.setter
+    def location(self, val: float) -> None:
+        self.hub_location = val
+    
+    @metal_inlet_angle.setter
+    def metal_inlet_angle(self, metal_inlet_angle: List[float], percent: List[float] = []):
+        """Sets the leading edge metal angle for the blade (degrees)."""
+        arr = np.radians(convert_to_ndarray(metal_inlet_angle))
+        if len(percent) != len(metal_inlet_angle):
+            percent = np.linspace(0, 1, len(arr)).tolist()  # type: ignore
+        self._beta1_metal = arr
         self.beta1_metal_radii = convert_to_ndarray(percent)
         self.beta1_fixed = True
-        self.beta1 = self.beta1_metal.copy()
+        self.beta1 = self.metal_inlet_angle.copy()
+    
+    @beta1_metal.setter
+    def beta1_metal(self, beta1_metal: List[float], percent: List[float] = []):
+        """Backward-compatible alias for metal_inlet_angle setter."""
+        self.metal_inlet_angle = beta1_metal
         
-    @beta2_metal.setter
-    def beta2_metal(self,beta2_metal:List[float],percent:List[float]=[]):
-        """Sets the trailing edge metal angle for the blade
-
-        Args:
-            beta2_metal (List[float]): Blade exit metal angle
-            percent (List[float]): percent location of metal angles from hub to shroud.
-
-        """
-        self._beta2_metal = np.radians(convert_to_ndarray(beta2_metal))
-        if len(percent) != len(beta2_metal):
-            percent = np.linspace(0,1,len(self._beta2_metal)).tolist() # type: ignore
+    @metal_exit_angle.setter
+    def metal_exit_angle(self, metal_exit_angle: List[float], percent: List[float] = []):
+        """Sets the trailing edge metal angle for the blade (degrees)."""
+        arr = np.radians(convert_to_ndarray(metal_exit_angle))
+        if len(percent) != len(metal_exit_angle):
+            percent = np.linspace(0, 1, len(arr)).tolist()  # type: ignore
+        self._beta2_metal = arr
         self.beta2_metal_radii = convert_to_ndarray(percent)
         self.beta2_fixed = True
-        self.beta2 = self._beta2_metal.copy()
-        
+
+        # Apply deviation if defined; deviation_function returns degrees
+        deviation_func = getattr(self, "deviation_function", None)
+        deviation_rad = 0.0
+        if callable(deviation_func):
+            try:
+                deviation_val = deviation_func(self, None)
+                deviation_rad = np.radians(deviation_val)
+            except Exception:
+                deviation_rad = 0.0
+
+        beta2_effective = self._beta2_metal + deviation_rad
         if self.row_type == RowType.Stator:
-            self.alpha2 = self._beta2_metal.copy()
+            self.alpha2 = beta2_effective.copy()
+            self.beta2 = beta2_effective.copy()
+        else:
+            self.beta2 = beta2_effective.copy()
+        self.deviation = np.full_like(self.beta2, deviation_rad)
+    
+    @beta2_metal.setter
+    def beta2_metal(self, beta2_metal: List[float], percent: List[float] = []):
+        """Backward-compatible alias for metal_exit_angle setter."""
+        self.metal_exit_angle = beta2_metal
         
     @property
     def rpm(self):
@@ -416,14 +463,6 @@ class BladeRow:
             self.loss_function = model
             return
 
-        if isinstance(model, Sequence):
-            if len(model) == 0:
-                raise ValueError("At least one loss model must be provided.")
-            if not all(isinstance(m, LossBaseClass) for m in model):
-                raise TypeError("All entries must inherit LossBaseClass.")
-            self.loss_function = CompositeLossModel(model)
-            return
-
         raise TypeError("Loss models must inherit LossBaseClass.")
     
     @property
@@ -446,6 +485,39 @@ class BladeRow:
     
     def __repr__(self):
         return f"{self.row_type.name} P0:{np.mean(self.P0):0.2f} T0:{np.mean(self.T0):0.2f} P:{np.mean(self.P):0.2f} massflow:{np.mean(self.total_massflow_no_coolant):0.3f}"
+
+    def synchronize_blade_geometry(self) -> None:
+        """Couple num_blades, pitch-to-chord/solidity, chord, and stagger.
+
+        Uses mean radius from interpolated streamlines to derive pitch, chord,
+        and stagger (axial chord / chord).
+        """
+        if self.num_blades <= 0 or self.r.size == 0:
+            return
+
+        # Pitch from blade count and local radius
+        pitch = 2 * np.pi * self.r / self.num_blades
+
+        # Pitch-to-chord (or 1/solidity) may be scalar or spanwise; broadcast it
+        ptc = convert_to_ndarray(self.pitch_to_chord)
+        if ptc.size == 1:
+            ptc = ptc * np.ones_like(self.r, dtype=float)
+        else:
+            t_src = np.linspace(0, 1, ptc.size)
+            ptc = np.interp(self.percent_hub_shroud, t_src, ptc)
+
+        chord = pitch / np.maximum(ptc, 1e-9)
+        self._chord = chord
+        self._pitch_to_chord = ptc
+
+        axial = self.axial_chord if self.axial_chord > 0 else float(np.mean(chord))
+        if self.axial_chord <= 0:
+            self.axial_chord = axial
+
+        ratio = np.clip(axial / np.maximum(chord, 1e-9), -1.0, 1.0)
+        stagger_rad = np.arccos(ratio)
+        # Store stagger distribution in degrees
+        self._stagger = np.degrees(stagger_rad)
     
     def to_dict(self):
         
@@ -487,15 +559,18 @@ class BladeRow:
             "rho":self.rho.tolist(),
             "mu":self.mu,
             "Yp":self.Yp,
+            "flow_coefficient": self.flow_coefficient,
             "Power":self.power,
             "P0_P": self.P0_P,
             "eta_total":self.eta_total,
             "eta_static":self.eta_static,
+            "eta_poly": self.eta_poly,
             "euler_power":self.euler_power,
             "axial_chord":self.axial_chord,
             "aspect_ratio":self.aspect_ratio,
             "num_blades":self.num_blades,
-            "area": self.area,
+            "total_area": self.total_area,
+            "area": self.area.tolist(),
             "radius":self.r.tolist(),
             "x":self.x.tolist(),
             "dx":self.x[-1]-self.x[0],
@@ -508,7 +583,7 @@ class BladeRow:
         return data
 
 #* Some functions related to blade row 
-def interpolate_streamline_radii(row:BladeRow,passage:Passage,num_streamlines:int=3):
+def interpolate_streamline_quantities(row:BladeRow,passage:Passage,num_streamlines:int=3):
     """Interpolate all quantities onto the streamline and allocates variables. 
     Run this after setting some initial conditions 
 
@@ -520,9 +595,17 @@ def interpolate_streamline_radii(row:BladeRow,passage:Passage,num_streamlines:in
     Returns:
         (BladeRow): new row object with quantities interpolated
     """
+    src_percent = convert_to_ndarray(row.percent_hub_shroud)
+
     row.cutting_line,_,_ = passage.get_cutting_line(row.location)
-    row.x,row.r = row.cutting_line.get_point(np.linspace(0,1,num_streamlines))
-    streamline_percent_length = np.sqrt((row.r-row.r[0])**2+(row.x-row.x[0])**2)/row.cutting_line.length
+    t_span = np.array([0.5]) if num_streamlines <= 1 else np.linspace(0, 1, num_streamlines)
+    row.x, row.r = row.cutting_line.get_point(t_span)
+    if num_streamlines <= 1:
+        streamline_percent_length = np.array([0.5])
+        row.total_area = passage.get_area(row.location)
+        row.area = np.array([row.total_area])
+    else:
+        streamline_percent_length = np.sqrt((row.r-row.r[0])**2+(row.x-row.x[0])**2)/row.cutting_line.length
     
     # Flow angles 
     row._beta1_metal = row._beta1_metal.default_factory() if type(row._beta1_metal) == Field else row._beta1_metal
@@ -534,51 +617,48 @@ def interpolate_streamline_radii(row:BladeRow,passage:Passage,num_streamlines:in
     row._beta2_metal = interpolate_quantities(row._beta2_metal,row.beta2_metal_radii,streamline_percent_length)
     row.beta1_metal_radii = streamline_percent_length
     row.beta2_metal_radii = streamline_percent_length
+    row.deviation = streamline_percent_length * 0
     
-    if type(row.percent_hub_shroud) == Field: 
-        row.percent_hub_shroud = streamline_percent_length
-    else:
-        row.percent_hub_shroud = streamline_percent_length # Reset the radii to streamline radii
+    row.mprime = interpolate_quantities(row.mprime, src_percent, streamline_percent_length)
 
-    row.alpha1 = interpolate_quantities(row.alpha1,row.percent_hub_shroud,streamline_percent_length)
-    row.alpha2 = interpolate_quantities(row.alpha2,row.percent_hub_shroud,streamline_percent_length)
-    row.beta1 = interpolate_quantities(row.beta1,row.percent_hub_shroud,streamline_percent_length)
-    row.beta2 = interpolate_quantities(row.beta2,row.percent_hub_shroud,streamline_percent_length)
+    row.alpha1 = safe_interpolate(row.alpha1, src_percent, streamline_percent_length, radians=False)
+    row.alpha2 = safe_interpolate(row.alpha2, src_percent, streamline_percent_length, radians=False)
+    row.beta1 = safe_interpolate(row.beta1, src_percent, streamline_percent_length, radians=False)
+    row.beta2 = safe_interpolate(row.beta2, src_percent, streamline_percent_length, radians=False)
     
     # Velocities 
-    row.Vm = interpolate_quantities(row.Vm, row.percent_hub_shroud, streamline_percent_length)
-    row.Vx = interpolate_quantities(row.Vx, row.percent_hub_shroud, streamline_percent_length)
-    row.Vt = interpolate_quantities(row.Vt, row.percent_hub_shroud, streamline_percent_length)
-    row.Vr = interpolate_quantities(row.Vr, row.percent_hub_shroud, streamline_percent_length)
-    row.V = interpolate_quantities(row.V, row.percent_hub_shroud, streamline_percent_length)
-    row.V2 = interpolate_quantities(row.V2, row.percent_hub_shroud, streamline_percent_length)
-    row.M = interpolate_quantities(row.M, row.percent_hub_shroud, streamline_percent_length)
-    row.M_rel = interpolate_quantities(row.M_rel, row.percent_hub_shroud, streamline_percent_length)
-    row.U = interpolate_quantities(row.U, row.percent_hub_shroud, streamline_percent_length)
-    row.W = interpolate_quantities(row.W, row.percent_hub_shroud, streamline_percent_length)
-    row.Wt = interpolate_quantities(row.Wt, row.percent_hub_shroud, streamline_percent_length)
+    row.Vm = interpolate_quantities(row.Vm, src_percent, streamline_percent_length)
+    row.Vx = interpolate_quantities(row.Vx, src_percent, streamline_percent_length)
+    row.Vt = interpolate_quantities(row.Vt, src_percent, streamline_percent_length)
+    row.Vr = interpolate_quantities(row.Vr, src_percent, streamline_percent_length)
+    row.V = interpolate_quantities(row.V, src_percent, streamline_percent_length)
+    row.V2 = interpolate_quantities(row.V2, src_percent, streamline_percent_length)
+    row.M = interpolate_quantities(row.M, src_percent, streamline_percent_length)
+    row.M_rel = interpolate_quantities(row.M_rel, src_percent, streamline_percent_length)
+    row.U = interpolate_quantities(row.U, src_percent, streamline_percent_length)
+    row.W = interpolate_quantities(row.W, src_percent, streamline_percent_length)
+    row.Wt = interpolate_quantities(row.Wt, src_percent, streamline_percent_length)
 
     # Total Quantities
-    row.T0 = interpolate_quantities(row.T0,row.percent_hub_shroud,streamline_percent_length)
-    row.T0_is = interpolate_quantities(row.T0,row.percent_hub_shroud,streamline_percent_length)
-    row.P0 = interpolate_quantities(row.P0,row.percent_hub_shroud,streamline_percent_length)
-    row.P0_stator_inlet = interpolate_quantities(row.P0_stator_inlet,row.percent_hub_shroud,streamline_percent_length)
+    row.T0 = interpolate_quantities(row.T0, src_percent, streamline_percent_length)
+    row.T0_is = interpolate_quantities(row.T0, src_percent, streamline_percent_length) # For Turbines
+    row.P0 = interpolate_quantities(row.P0, src_percent, streamline_percent_length)
+    row.P0_is = interpolate_quantities(row.P0, src_percent, streamline_percent_length) # For Compressors 
+    row.P0_stator_inlet = interpolate_quantities(row.P0_stator_inlet, src_percent, streamline_percent_length)
     
     # Relative Quantities
-    row.P0R = interpolate_quantities(row.P0R,row.percent_hub_shroud,streamline_percent_length)
-    row.T0R = interpolate_quantities(row.T0R,row.percent_hub_shroud,streamline_percent_length)
+    row.P0R = interpolate_quantities(row.P0R, src_percent, streamline_percent_length)
+    row.P0R_is = interpolate_quantities(row.P0, src_percent, streamline_percent_length)
+    row.T0R = interpolate_quantities(row.T0R, src_percent, streamline_percent_length)
 
     # Static Quantities 
-    row.P = interpolate_quantities(row.P,row.percent_hub_shroud,streamline_percent_length)
-    row.T = interpolate_quantities(row.T,row.percent_hub_shroud,streamline_percent_length)
-    row.T_is = interpolate_quantities(row.T_is,row.percent_hub_shroud,streamline_percent_length)
-    row.rho = interpolate_quantities(row.rho,row.percent_hub_shroud,streamline_percent_length)
+    row.P = interpolate_quantities(row.P, src_percent, streamline_percent_length)
+    row.T = interpolate_quantities(row.T, src_percent, streamline_percent_length)
+    row.T_is = interpolate_quantities(row.T_is, src_percent, streamline_percent_length)
+    row.rho = interpolate_quantities(row.rho, src_percent, streamline_percent_length)
+    row.entropy_rise = interpolate_quantities(row.entropy_rise, src_percent, streamline_percent_length)
 
-    # if row.row_type == RowType.Inlet:
-    #     row.P0_fun = interp1d(row.percent_hub_shroud,row.P0) 
-    #     row.T0_fun = interp1d(row.percent_hub_shroud,row.T0) 
-    # elif row.row_type == RowType.Outlet:
-    #     row.P_fun = interp1d(row.percent_hub_shroud,row.P) 
+    row.percent_hub_shroud = streamline_percent_length
 
     return row
 
@@ -615,6 +695,8 @@ def interpolate_quantities(q:npt.NDArray,r:npt.NDArray,r2:npt.NDArray):
         q2 = np.zeros(shape=r2.shape)
         return q[0]+q2
     else:
+        if len(r) != len(q):
+            r = np.linspace(0, 1, len(q))
         return interp1d(r,q,kind='linear')(r2)
     
 def compute_gas_constants(row:BladeRow,fluid:Optional[Solution]=None) -> None: