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

turbodesign/passage.py

@@ -1,4 +1,4 @@
-from typing import List, Tuple, Union
+from typing import List, Optional, Tuple, Union
 import numpy as np
 import numpy.typing as npt
 from scipy.interpolate import PchipInterpolator, interp1d
@@ -30,7 +30,7 @@ class Passage:
     
     def __init__(self,xhub:Union[npt.NDArray,List[float]],rhub:Union[npt.NDArray,List[float]],
                  xshroud:Union[npt.NDArray,List[float]],rshroud:Union[npt.NDArray,List[float]],
-                 passageType:PassageType=PassageType.Axial):
+                 passageType:PassageType=PassageType.Axial, zero_phi: bool = False):
         """_summary_
 
         Args:
@@ -42,6 +42,7 @@ class Passage:
         """
         assert len(xhub) == len(xshroud), "xHub and xShroud should be the same length"
         assert len(rhub) == len(rshroud), "rHub and rShroud should be the same length"
+        self.zero_phi = zero_phi
 
         hub_arc_len = xr_to_mprime(np.vstack([xhub,rhub]).transpose())[1]
         self.hub_arc_len = hub_arc_len[-1]
@@ -81,15 +82,14 @@ class Passage:
         r_streamline = t_streamline.copy()*0
         x_streamline = t_streamline.copy()*0
         for i,t in enumerate(t_streamline):
-            xhub = self.xhub(t)
-            rhub = self.rhub(t)
-            xshroud = self.xshroud(t)
-            rshroud = self.rshroud(t)
-            x_streamline[i] ,r_streamline[i] = line2D([xhub,rhub],[xshroud,rshroud]).get_point(t_radial)
+            xhub = float(self.xhub(t))
+            rhub = float(self.rhub(t))
+            xshroud = float(self.xshroud(t))
+            rshroud = float(self.rshroud(t))
+            x_streamline[i] ,r_streamline[i] = line2D((xhub,rhub),(xshroud,rshroud)).get_point(t_radial)
         return t_streamline,x_streamline,r_streamline
 
-    @staticmethod
-    def streamline_curvature(x_streamline:npt.NDArray,r_streamline:npt.NDArray) -> Tuple[npt.NDArray,npt.NDArray,npt.NDArray]:
+    def streamline_curvature(self, x_streamline:npt.NDArray,r_streamline:npt.NDArray) -> Tuple[npt.NDArray,npt.NDArray,npt.NDArray]:
         """Hub and casing values of streamline angles of inclination and curvature 
 
             x_streamline[axial,radial]
@@ -113,14 +113,16 @@ class Passage:
         phi = np.zeros(shape=x_streamline.shape)
         r  = np.zeros(shape=x_streamline.shape)
         radius_curvature = np.zeros(shape=x_streamline.shape)
+        if self.zero_phi:
+            return phi, radius_curvature, r_streamline
         # Have to make sure there isn't a divide by zero which could happen if there is a vertical line somewhere
         indices = np.where(np.abs(np.diff(x_streamline))>np.finfo(float).eps)[0]
     
         d_dx = FinDiff(0,x_streamline[indices[0]:indices[-1]],1)
         d2_dx2 = FinDiff(0,x_streamline[indices[0]:indices[-1]],2)
         
-        dr_dx = d_dx(r_streamline[indices[0]:indices[-1]])
-        d2r_dx2 = d2_dx2(r_streamline[indices[0]:indices[-1]])    
+        dr_dx = d_dx(r_streamline[indices[0]:indices[-1]]) # type: ignore
+        d2r_dx2 = d2_dx2(r_streamline[indices[0]:indices[-1]])     # type: ignore
             
         radius_curvature[indices[0]:indices[-1]] = np.power((1+np.power(dr_dx,2)),1.5)
         radius_curvature[indices[0]:indices[-1]] = np.divide(radius_curvature[indices[0]:indices[-1]], np.abs(d2r_dx2))
@@ -170,7 +172,7 @@ class Passage:
                 total_area += area
         return total_area
         
-    def get_cutting_line(self, t_hub:float) -> Tuple[line2D,float,float]:
+    def get_cutting_line(self, t_hub:float,t_shroud:Optional[float]=None) -> Tuple[line2D,float,float]:
         """Gets the cutting line perpendicular to hub and shroud 
 
         Args:
@@ -181,65 +183,90 @@ class Passage:
         
                 cut (line2D): line from hub to shroud
                 t_hub (float): Percentage along hub arc length
-                t_shroud (float): t corresponding to intersection of bisector of hub 
+                t_shroud (Optional[float]): t corresponding to intersection of bisector of hub. Defaults to None
                                 
         """
-        xhub = self.xhub(t_hub)
-        rhub = self.rhub(t_hub)
-        
-        if t_hub>0 and t_hub<1:
-            dx = self.xhub(t_hub+0.0001) - self.xhub(t_hub-0.0001) 
-            dr = self.rhub(t_hub+0.0001) - self.rhub(t_hub-0.0001)
-        elif t_hub>0:
-            dx = self.xhub(t_hub) - self.xhub(t_hub-0.0001) 
-            dr = self.rhub(t_hub) - self.rhub(t_hub-0.0001)
-        elif t_hub<1:
-            dx = self.xhub(t_hub+0.0001) - self.xhub(t_hub)
-            dr = self.rhub(t_hub+0.0001) - self.rhub(t_hub)
-        
-        if self.passageType == PassageType.Centrifugal:
-            if np.abs(dr)>1e-6:
-                # Draw a line perpendicular to the hub. 
-                # Find the intersection point to the shroud. 
-                h = -dx/dr # Slope of perpendicular line
+        xhub = float(self.xhub(t_hub))
+        rhub = float(self.rhub(t_hub))
+        if t_shroud is None:            
+            if t_hub>0 and t_hub<1:
+                dx = self.xhub(t_hub+0.0001) - self.xhub(t_hub-0.0001) 
+                dr = self.rhub(t_hub+0.0001) - self.rhub(t_hub-0.0001)
+            elif t_hub>0:
+                dx = self.xhub(t_hub) - self.xhub(t_hub-0.0001) 
+                dr = self.rhub(t_hub) - self.rhub(t_hub-0.0001)
+            else: # t_hub<1:
+                dx = self.xhub(t_hub+0.0001) - self.xhub(t_hub)
+                dr = self.rhub(t_hub+0.0001) - self.rhub(t_hub)
             
-                f = lambda t: h*(self.xshroud(t) - xhub)+rhub # line from hub to shroud 
-                fun = lambda t: np.abs(f(t)-self.rshroud(t)) # find where it intersects
-                res = minimize_scalar(fun,bounds=[0,1],tol=1E-3) 
-                t_shroud = res.x
+            if self.passageType == PassageType.Centrifugal:
+                if np.abs(dr)>1e-6:
+                    # Draw a line perpendicular to the hub. 
+                    # Find the intersection point to the shroud. 
+                    h = -dx/dr # Slope of perpendicular line
+                
+                    f = lambda t: h*(self.xshroud(t) - xhub)+rhub # line from hub to shroud 
+                    fun = lambda t: np.abs(f(t)-self.rshroud(t)) # find where it intersects
+                    res = minimize_scalar(fun,bounds=[0,1],tol=1E-3) 
+                    t_shroud = res.x # type: ignore
+                else:
+                    t_shroud = t_hub # Vertical line 
             else:
-                t_shroud = t_hub # Vertical line 
-        else:
-            t_shroud = t_hub
+                t_shroud = t_hub
+                
+        xshroud = float(self.xshroud(t_shroud))
+        rshroud = float(self.rshroud(t_shroud))
         
-        xshroud = self.xshroud(t_shroud)
-        rshroud = self.rshroud(t_shroud)
-        return line2D([xhub,rhub],[xshroud,rshroud]), t_hub, t_shroud
+        return line2D((xhub,rhub),(xshroud,rshroud)), t_hub, t_shroud # type: ignore
     
-    def get_xr_slice(self,t_span:float,percent_hub:Tuple[float,float],resolution:int=100):
-        """Returns the xr coordinates of a streamline, a line that is parallel to both hub and shroud
-            
+    def get_xr_slice(self, t_span: float, percent_hub: Tuple[float, float], 
+                     percent_shroud: Optional[Tuple[float, float]] = None, resolution: int = 100) -> npt.NDArray[np.float64]:
+        """
+        Return the (x, r) coordinates of a *straight* streamline segment that
+        connects corresponding hub and shroud points, sampled uniformly along
+        each surface between the given percent limits.
+
+        The point returned on each connecting line is at parametric position
+        `t_span` in [0, 1], where 0 = hub point and 1 = shroud point.
+
         Args:
-            t_span (float): _description_
-            meridional_location (float): _description_
-            resolution (int): number of points to resolve 
+            t_span: Interpolation parameter along each hub→shroud connector (0..1).
+            percent_hub: (start, end) fractional arc-length positions along the hub (0..1).
+            percent_shroud: Optional (start, end) along the shroud (0..1). If None,
+                the shroud uses the same normalized range as `percent_hub`.
+            resolution: Number of sample points along the streamwise direction.
 
         Returns:
-            np.NDArray: _description_
+            (resolution, 2) array of [x, r] coordinates.
         """
-        t_hub = np.linspace(percent_hub[0],percent_hub[1],resolution)
-        t_hub = convert_to_ndarray(t_hub)*self.hub_length
-        
-        shroud_pts_cyl = np.vstack([self.xshroud(t_hub),self.rshroud(t_hub)]).transpose()
-        hub_pts_cyl = np.vstack([self.xhub(t_hub),self.rhub(t_hub)]).transpose()
-        n = len(t_hub)
-            
-        xr = np.zeros((n,2))
-        for j in range(n):
-            l = line2D(hub_pts_cyl[j,:],shroud_pts_cyl[j,:])
-            xr[j,0],xr[j,1] = l.get_point(t_span)
-            
-        return xr
+        # ---- validation
+        if not (0.0 <= t_span <= 1.0):
+            raise ValueError("t_span must be in [0, 1].")
+        if resolution < 2:
+            raise ValueError("resolution must be >= 2.")
+        if not (0.0 <= percent_hub[0] <= 1.0 and 0.0 <= percent_hub[1] <= 1.0):
+            raise ValueError("percent_hub values must be in [0, 1].")
+        if percent_shroud is not None and not (
+            0.0 <= percent_shroud[0] <= 1.0 and 0.0 <= percent_shroud[1] <= 1.0
+        ):
+            raise ValueError("percent_shroud values must be in [0, 1].")
+
+        # ---- parameterize along hub and shroud (use each surface's own length!)
+        t_hub = np.linspace(percent_hub[0], percent_hub[1], resolution) * self.hub_length
+        if percent_shroud is None:
+            t_shroud = np.linspace(percent_hub[0], percent_hub[1], resolution) * self.shroud_length
+        else:
+            t_shroud = np.linspace(percent_shroud[0], percent_shroud[1], resolution) * self.shroud_length
+
+        # ---- sample hub & shroud curves (x, r)
+        hub_pts = np.column_stack([self.xhub(t_hub), self.rhub(t_hub)])          # (N, 2)
+        shroud_pts = np.column_stack([self.xshroud(t_shroud), self.rshroud(t_shroud)])  # (N, 2)
+
+        # ---- vectorized interpolation along each connector: hub + t*(shroud - hub)
+        xr = hub_pts + (shroud_pts - hub_pts) * float(t_span)  # (N, 2)
+
+        return xr.astype(np.float64, copy=False)
+
     
     def get_m(self,t_span:float,resolution:int=100) -> npt.NDArray:
         """Meridional cooridnates
@@ -251,7 +278,7 @@ class Passage:
         Returns:
             npt.NDArray: _description_
         """
-        xr = self.get_xr_slice(t_span,(0,1),resolution)
+        xr = self.get_xr_slice(t_span=t_span,percent_hub=(0,1),resolution=resolution)
         dx = np.diff(xr[:,0])
         dr = np.diff(xr[:,1])
         m = np.concat([[0],np.cumsum(np.sqrt(dx**2 + dr**2))])
@@ -269,7 +296,7 @@ class Passage:
             (float) : returns the derivative 
         """
         m = self.get_m(t_span,resolution)
-        return PchipInterpolator(np.linspace(0,1,resolution),np.diff(m))(location)
+        return PchipInterpolator(np.linspace(0,1,resolution),np.diff(m))(location) # type: ignore
     
     @property
     def hub_length(self):
@@ -279,6 +306,14 @@ class Passage:
         """
         return np.sum(np.sqrt(np.diff(self.xhub_pts)**2 + np.diff(self.rhub_pts)**2))
     
+    @property
+    def shroud_length(self):
+        """returns the computed length of the shroud 
+        Returns:
+            _type_: _description_
+        """
+        return np.sum(np.sqrt(np.diff(self.xshroud_pts)**2 + np.diff(self.rshroud_pts)**2))
+    
     def plot_cuts(self,percent_axial:List[float]=[]):
         """_summary_
 

turbodesign/row_factory.py

@@ -0,0 +1,129 @@
+"""Convenience helpers for constructing BladeRow objects with minimal boilerplate."""
+
+from __future__ import annotations
+
+from typing import Optional, Sequence, Any
+
+import numpy as np
+
+from .bladerow import BladeRow
+from .enums import RowType
+
+__all__ = ["make_blade_row", "make_rotor_row", "make_stator_row"]
+
+
+def make_blade_row(
+    *args: Any,
+    row_type: Optional[RowType] = None,
+    hub_location: Optional[float] = None,
+    shroud_location: Optional[float] = None,
+    stage_id: int = 0,
+    **attrs: Any,
+) -> BladeRow:
+    """Generic BladeRow factory that supports legacy calling styles.
+
+    Args mirror the original BladeRow constructor; any extra keyword arguments
+    are set as attributes on the created row for convenience.
+    """
+    # Allow positional legacy (hub_location, row_type, stage_id, shroud_location)
+    pos = list(args)
+    # Legacy positional usage: (RowType, power=...) or (hub_loc, RowType, ...)
+    if pos and isinstance(pos[0], RowType):
+        row_type = pos.pop(0)
+    if hub_location is None and pos:
+        hub_location = pos.pop(0)
+    if row_type is None and pos and isinstance(pos[0], RowType):
+        row_type = pos.pop(0)
+    if shroud_location is None and pos:
+        shroud_location = pos.pop(0)
+
+    hub_location = 0.0 if hub_location is None else float(hub_location)
+    row_type = row_type if row_type is not None else RowType.Stator
+
+    row = BladeRow(hub_location=hub_location, row_type=row_type, stage_id=stage_id, shroud_location=shroud_location)
+
+    # Apply extra attributes (e.g., loss_function, beta2_metal, etc.)
+    for key, val in attrs.items():
+        setattr(row, key, val)
+    return row
+
+def _maybe_set_pitch(row: BladeRow, pitch_to_chord: Optional[float], solidity: Optional[float]) -> None:
+    """Apply pitch/solidity inputs to a blade row if provided."""
+    if pitch_to_chord is not None:
+        row.pitch_to_chord = pitch_to_chord
+    elif solidity is not None and solidity != 0:
+        row.pitch_to_chord = 1.0 / solidity
+
+
+def make_rotor_row(
+    hub_location: float,
+    metal_exit_angle_deg: Optional[float | Sequence[float]] = None,
+    loss_function: Optional[object] = None,
+    P0_ratio: float = 1.0,
+    pitch_to_chord: Optional[float] = None,
+    solidity: Optional[float] = None,
+    num_blades: Optional[int] = None,
+    axial_chord: Optional[float] = None,
+) -> BladeRow:
+    """Create a Rotor blade row with common inputs.
+
+    Args:
+        hub_location: Streamwise position (0–1) for the row.
+        beta2_metal_deg: Exit metal angle(s) in degrees.
+        loss_function: Loss model to attach.
+        P0_ratio: Total-pressure ratio target across the row.
+        pitch_to_chord: Pitch-to-chord ratio (alternative to solidity).
+        solidity: Solidity (chord/pitch) if preferred over pitch_to_chord.
+        num_blades: Number of blades (used to derive pitch).
+        axial_chord: Axial chord length if known.
+    """
+    row = BladeRow(hub_location=hub_location, row_type=RowType.Rotor)
+    row.P0_ratio = P0_ratio
+    row.P0_ratio_target = P0_ratio
+    _maybe_set_pitch(row, pitch_to_chord, solidity)
+    if num_blades is not None:
+        row.num_blades = num_blades
+    if axial_chord is not None:
+        row.axial_chord = axial_chord
+    if metal_exit_angle_deg is not None:
+        row.metal_exit_angle = np.atleast_1d(metal_exit_angle_deg)
+    if loss_function is not None:
+        row.loss_function = loss_function
+    return row
+
+
+def make_stator_row(
+    hub_location: float,
+    metal_exit_angle_deg: Optional[float | Sequence[float]] = None,
+    loss_function: Optional[object] = None,
+    P0_ratio: float = 1.0,
+    pitch_to_chord: Optional[float] = None,
+    solidity: Optional[float] = None,
+    num_blades: Optional[int] = None,
+    axial_chord: Optional[float] = None,
+) -> BladeRow:
+    """Create a Stator/IGV blade row with common inputs.
+
+    Args:
+        hub_location: Streamwise position (0–1) for the row.
+        alpha2_metal_deg: Exit metal angle(s) in degrees.
+        loss_function: Loss model to attach.
+        P0_ratio: Total-pressure ratio target across the row.
+        pitch_to_chord: Pitch-to-chord ratio (alternative to solidity).
+        solidity: Solidity (chord/pitch) if preferred over pitch_to_chord.
+        num_blades: Number of blades (used to derive pitch).
+        axial_chord: Axial chord length if known.
+    """
+    row = BladeRow(hub_location=hub_location, row_type=RowType.Stator)
+    row.P0_ratio = P0_ratio
+    row.P0_ratio_target = P0_ratio
+    _maybe_set_pitch(row, pitch_to_chord, solidity)
+    if num_blades is not None:
+        row.num_blades = num_blades
+    if axial_chord is not None:
+        row.axial_chord = axial_chord
+    if metal_exit_angle_deg is not None:
+        row.metal_exit_angle = np.atleast_1d(metal_exit_angle_deg)
+    if loss_function is not None:
+        row.loss_function = loss_function
+    return row

turbodesign/solve_radeq.py

@@ -1,31 +1,30 @@
 from typing import List, Tuple
 from .radeq import radeq
-from .enums import LossType, RowType, PowerType, MassflowConstraint
+from .enums import LossType, RowType, PowerType
 from .bladerow import BladeRow
-from .td_math import compute_gas_constants
-from .td_math import compute_quantities, compute_power, compute_massflow
+from .turbine_math import compute_gas_constants
+from .turbine_math import compute_quantities, compute_power
+from .flow_math import compute_massflow
 import numpy.typing as npt
 import numpy as np
 from scipy.interpolate import interp1d
 from scipy.optimize import minimize_scalar
 from .passage import Passage     
     
-def adjust_streamlines(blade_rows:List[BladeRow],passage:Passage):
+def adjust_streamlines(blade_rows:List[BladeRow],passage:Passage,massflow_fraction:np.ndarray):
     """Adjust the streamlines to evenly divide the massflow
 
     Args:
         blade_rows (List[BladeRow]): List of blade rows
         passage (Passage): passage object describing the hub and shroud 
-
+        massflow_fraction (np.ndarray): array from 0 to 1 of how the massflow should be distributed from hub to shroud
     """
     for row_index,row in enumerate(blade_rows):
         print(f"Adjusting Streamlines to balance massflow Row: {row_index}")
-        massflow_fraction =  np.linspace(0,1,len(row.percent_hub_shroud))
         row.total_massflow = row.massflow[-1]
-        ideal_massflow_fraction = row.massflow[-1] * massflow_fraction
         
-        new_percent_streamline = interp1d(row.massflow,row.percent_hub_shroud)(ideal_massflow_fraction[1:-1])
-        row.percent_hub_shroud[1:-1] = new_percent_streamline
+        new_percent_streamline = interp1d(row.massflow,row.percent_hub_shroud)(massflow_fraction[1:-1])
+        row.percent_hub_shroud[1:-1] = new_percent_streamline 
 
         cut_line, thub,_ = passage.get_cutting_line(row.percent_hub)
         row.x,row.r = cut_line.get_point(row.percent_hub_shroud)
@@ -36,4 +35,4 @@ def adjust_streamlines(blade_rows:List[BladeRow],passage:Passage):
             row.phi[i] = float(interp1d(t_streamline,phi)(row.percent_hub))
             row.rm[i] = float(interp1d(t_streamline,rm)(row.percent_hub))
             row.r[i] = float(interp1d(t_streamline,r)(row.percent_hub))
-            row.x[i] = float(interp1d(t_streamline,x_streamline)(row.percent_hub))
+            row.x[i] = float(interp1d(t_streamline,x_streamline)(row.percent_hub))