turbo-design 1.0.0__py2.py3-none-any.whl

turbodesign/outlet.py

@@ -0,0 +1,56 @@
+from dataclasses import dataclass, field
+from typing import List, Union
+from .enums import RowType
+from .bladerow import BladeRow, compute_gas_constants, interpolate_quantities
+from .arrayfuncs import convert_to_ndarray
+import numpy as np
+import numpy.typing as npt 
+import copy 
+from scipy.interpolate import interp1d
+
+
+class Outlet(BladeRow):
+    P_fun:interp1d
+    
+    def __init__(self,P:Union[float,List[float]],percent_radii:List[float],num_streamlines:int=3):
+        """Initialize the outlet
+
+        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 
+        """
+        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_fun = interp1d(self.percent_hub_shroud,self.P)
+        self.row_type = RowType.Outlet
+        self.loss_function = None
+    
+    
+    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. 
+        """
+        self.__dict__ = upstream.__dict__.copy() # Copies P and hub shroud percentage  
+        self.P_fun = interp1d(self.percent_hub_shroud,self.P)
+        self.row_type = RowType.Outlet
+        
+    
+    def get_static_pressure(self,percent_hub_shroud:Union[float,npt.NDArray]):
+        """Returns the static pressure at a certain percent hub_shroud
+
+        Args:
+            percent_hub_shroud (Union[float,npt.NDArray]): _description_
+
+        Returns:
+            _type_: _description_
+        """
+        if type(percent_hub_shroud) == float:
+            return float(self.P_fun(percent_hub_shroud))
+        else:
+            return self.P_fun(percent_hub_shroud)
+        
+        

turbodesign/passage.py

@@ -0,0 +1,198 @@
+from typing import List, Tuple
+import numpy as np
+import numpy.typing as npt
+from scipy.interpolate import interp1d
+from pyturbo.helper import line2D
+from .enums import PassageType
+from scipy.optimize import minimize_scalar
+from findiff import FinDiff
+from pyturbo.helper import convert_to_ndarray 
+import matplotlib.pyplot as plt 
+
+class Passage:
+    xhub:interp1d
+    rhub:interp1d
+    xhub_pts:npt.NDArray
+    rhub_pts:npt.NDArray
+    
+    xshroud:interp1d
+    rshroud:interp1d
+    xshroud_pts:npt.NDArray
+    rshroud_pts:npt.NDArray
+    
+    n:int
+    passageType:PassageType
+
+    x_streamlines:npt.NDArray
+    r_streamlines:npt.NDArray
+    
+    def __init__(self,xhub:List[float],rhub:List[float],
+                 xshroud:List[float],rshroud:List[float],
+                 passageType:PassageType=PassageType.Axial):
+        """_summary_
+
+        Args:
+            xhub (List[float]): xhub coordinates
+            rhub (List[float]): rhub coordinates 
+            xshroud (List[float]): xshroud coordinates 
+            rshroud (List[float]): rshroud coordinates 
+            passageType (PassageType, optional): Axial or Centrifugal. Defaults to PassageType.Axial.
+        """
+        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.n = len(xhub)
+        t_streamline = np.linspace(0,1,len(xhub))
+        self.xhub = interp1d(t_streamline,xhub)
+        self.rhub = interp1d(t_streamline,rhub)
+        self.xshroud = interp1d(t_streamline,xshroud)
+        self.rshroud = interp1d(t_streamline,rshroud)
+        
+        self.xhub_pts = convert_to_ndarray(xhub)
+        self.rhub_pts = convert_to_ndarray(rhub)
+        self.xshroud_pts = convert_to_ndarray(xshroud)
+        self.rshroud_pts = convert_to_ndarray(rshroud)
+        
+        self.passageType = passageType
+        
+    def get_streamline(self,t_radial:float) -> Tuple[npt.NDArray,npt.NDArray, npt.NDArray]:
+        """Gets the streamline at a certain percent radius 
+
+        Args:
+            t_radial (float): _description_
+
+        Returns:
+            Tuple containing:
+            
+                t_streamline (npt.NDArray): Non dimensional length of the streamline
+                x_streamline (npt.NDArray): x-coordinate along the streamline
+                r_streamline (npt.NDArray): r-coordinate along the streamline
+        """
+        t_streamline = np.linspace(0,1,self.n)
+        # first streamline is at the hub
+        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)
+        
+        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]:
+        """Hub and casing values of streamline angles of inclination and curvature 
+
+            x_streamline[axial,radial]
+            r_streamline[axial,radial]
+            
+        Args:
+            x_streamline (np.ndarray): Axial position as a matrix with shape [number of stations, number of x-positions]
+            r_streamline (np.ndarray): Annulus Radii of streamlines arranged with shape [number of stations, number of x-positions]
+
+        Returns:
+            Tuple: containing
+
+                *phi* (np.ndarray): Array containing angles of inclination for each radi at each station. Rows = radius, columns = station
+                *rm* (np.ndarray): Array containing the curvature for each station and streamline
+                *r* (np.ndarray): Annulus radius
+
+        References:
+            https://stackoverflow.com/questions/28269379/curve-curvature-in-numpy
+
+        """
+        phi = np.zeros(shape=x_streamline.shape)
+        rm = phi.copy()
+        r  = phi.copy()
+            
+        d_dx = FinDiff(0,x_streamline,1)
+        d2_dx2 = FinDiff(0,x_streamline,2)
+        dr_dx = d_dx(r_streamline)
+        d2r_dx2 = d2_dx2(r_streamline)    
+            
+        radius_curvature = np.power((1+np.power(dr_dx,2)),1.5)
+        radius_curvature = np.divide(radius_curvature, np.abs(d2r_dx2))
+        radius_curvature = np.nan_to_num(radius_curvature,nan=0)
+        
+        rm = radius_curvature     # https://www.cuemath.com/radius-of-curvature-formula/ should be 1/curvature
+        phi = np.arctan(dr_dx)
+        r = r_streamline
+            
+        return phi, rm, r
+        
+    def get_cutting_line(self, t_hub:float) -> line2D:
+        """Gets the cutting line between hub and shroud 
+
+        Args:
+            t_hub (float): percentage along the axial direction 
+
+        Returns:
+            (Tuple) containing:
+        
+                cut (line2D): line from hub to shroud
+                t_hub (float): t corresponding to xhub location
+                t_shroud (float): t corresponding to intersection of bisector of hub 
+                                
+        """
+        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
+            
+                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
+            else:
+                t_shroud = t_hub # Vertical line 
+        else:
+            t_shroud = t_hub
+        
+        xshroud = self.xshroud(t_shroud)
+        rshroud = self.rshroud(t_shroud)
+        return line2D([xhub,rhub],[xshroud,rshroud]), t_hub, t_shroud
+    
+        
+    @property
+    def hub_length(self):
+        """returns the computed length of the hub 
+        Returns:
+            _type_: _description_
+        """
+        return np.sum(np.sqrt(np.diff(self.xhub_pts)**2 + np.diff(self.rhub_pts)**2))
+    
+    def plot_cuts(self,percent_axial:List[float]=[]):
+        """_summary_
+
+        Args:
+            percent_axial (List[float], optional): _description_. Defaults to [].
+        """
+        
+        plt.figure(num=1,clear=True,dpi=150,figsize=(15,10))
+        plt.plot(self.xhub_pts,self.rhub_pts,label='hub',linestyle='solid',linewidth=2,color='black')
+        plt.plot(self.xshroud_pts,self.rshroud_pts,label='hub',linestyle='solid',linewidth=2,color='black')
+        for p in percent_axial:
+            cut,_,_ = self.get_cutting_line(p)
+            x,r = cut.get_point(np.linspace(0,1,10))
+            plt.plot(x,r,label=f'{p}',linestyle='dashed')
+            
+        plt.legend()
+        plt.axis('scaled')
+        plt.show()
+        

turbodesign/radeq.py

@@ -0,0 +1,255 @@
+from scipy.interpolate import interp1d
+from scipy.integrate import odeint
+import numpy as np 
+from .bladerow import BladeRow
+from .enums import RowType
+
+
+def radeq(row:BladeRow,upstream:BladeRow) -> BladeRow:
+    """Solves the radial equilibrium equation for axial machines and returns the convergence. 
+
+    Note:
+        This function will give you T0, P0, Vm as a function of the radius. 
+        
+    Args:
+        row (BladeRow): Current row
+        upstream (BladeRow): Previous row
+
+    Returns:
+        BladeRow: current row with T0, P0, and Vm calculated
+    """
+    row_radius = row.r     # Use these for gradient 
+    up_radius = upstream.r
+    
+    def ode_radeq_streamtube(r:np.ndarray,y:np.ndarray):
+        """Solves the radial equilibrium equation for a streamtube 
+
+        Args:
+            r (np.ndarray): radius not as a percent
+            y (np.ndarray): Array containing [P0,Vt,VtU,T0]
+            
+        """
+        P0 = y[0]
+        T0 = y[1]
+        Vm = y[2]
+        if r>row_radius[-1]:
+            return [0,0,0]
+        elif r<row_radius[0]:
+            return [0,0,0]
+
+        Cp = row.Cp
+        phi = interp1d(row_radius, row.phi)(r)
+        alpha = interp1d(row_radius, row.alpha2)(r)
+        rm = interp1d(row_radius, row.rm)(r)
+        rho = row.rho.mean()
+        
+        if (row.row_type == RowType.Rotor):
+            omega = row.rpm*np.pi/30
+            U = omega*r
+        else:
+            omega = 0
+            U = 0
+        gamma = row.gamma
+
+        # Solve the Radial Equlibrium 
+        Vt = Vm*np.cos(phi)*np.tan(alpha)
+        Vr = Vm*np.sin(phi)
+        # Estimations 
+        dVm_dr = float(interp1d(row_radius, np.gradient(row.Vm, row_radius))(r))
+        dVt_dr = dVm_dr*np.cos(phi)*np.tan(alpha)
+        dVr_dr = 0 #dVm_dr*np.sin(phi)
+
+        # Upstream 
+        dT0up_dr = float(interp1d(upstream.percent_hub_shroud, np.gradient(upstream.T0,up_radius))((r-row_radius[0])/(row_radius[-1]-row_radius[0]))) # use percentage to get the T0 upstream value
+        dP0up_dr = float(interp1d(upstream.percent_hub_shroud, np.gradient(upstream.P0,up_radius))((r-row_radius[0])/(row_radius[-1]-row_radius[0]))) # use percentage to get the T0 upstream value
+        
+        dP0_dr = float(interp1d(row.percent_hub_shroud, np.gradient(row.P0,row_radius))((r-row_radius[0])/(row_radius[-1]-row_radius[0]))) # use percentage to get 
+
+        U_up = float(interp1d(upstream.percent_hub_shroud,up_radius*omega)((r-row_radius[0])/(row_radius[-1]-row_radius[0]))) # use percentage to get the T0 upstream value
+        dVtup_dr = float(interp1d(upstream.percent_hub_shroud,np.gradient(upstream.Vt,up_radius))((r-row_radius[0])/(row_radius[-1]-row_radius[0])))
+        Vtup = float(interp1d(upstream.percent_hub_shroud,upstream.Vt)((r-row_radius[0])/(row_radius[-1]-row_radius[0])))
+        
+        
+        dT0_dr = dT0up_dr - 1/row.Cp*(U_up*dVtup_dr + Vtup*omega - (U*dVt_dr+Vt*omega)) # Eqn 8
+        # if row.loss_function.LossType == LossType.Pressure: # type: ignore
+        #     dP0_dr = dP0up_dr-row.Yp*(dP0up_dr - dP_dr)     # Eqn 9
+
+        C = Vm**2*(1+np.cos(phi)**2 * np.tan(alpha)**2)/(2*Cp*T0)
+        B = (1-C)**(gamma/(gamma-1))      
+        A = P0 * gamma/(gamma-1) * (1-C)**(1/(gamma-1))
+        dVm_dr = 1/(2*Vm*A) * (rho*(Vt/r - Vm**2/rm * np.cos(phi) - Vr*dVr_dr) - dP0_dr*B) + 1/(2*T0) *dT0_dr  # Eqn 6
+        
+        ydot = np.array([dP0_dr,dT0_dr,dVm_dr])
+
+        return ydot
+
+    T0 = row.T0
+    
+    P0 = row.P0
+    Vm = row.Vm
+
+    # Estimate the Vt based on a given turning angle 
+    mean_radius = row_radius.mean()
+    tip_radius = row_radius[-1]
+    hub_radius = row_radius[0]
+
+    T0m = interp1d(row.percent_hub_shroud,T0)(0.5); 
+    P0m = interp1d(row.percent_hub_shroud,P0)(0.5); Vmm = interp1d(row.percent_hub_shroud,Vm)(0.5)
+    # We are solving for the values of these quantities at row exit
+    ics = np.array([P0m,T0m,Vmm])
+
+    rm_to_tip = np.linspace(mean_radius,tip_radius)
+    res1 = odeint(ode_radeq_streamtube, ics, rm_to_tip, tfirst=True)
+    
+    rm_to_hub = np.flip(np.linspace(hub_radius,mean_radius))
+    res2 = odeint(ode_radeq_streamtube, ics, rm_to_hub, tfirst=True)
+    
+    res2 = np.flipud(res2)
+    res = np.concatenate([res2[:-1,:],res1])
+    r = np.concatenate([np.flip(rm_to_hub)[:-1], rm_to_tip])
+    
+    P0_new = interp1d(r,res[:,0])(row_radius)
+    T0_new = interp1d(r,res[:,1])(row_radius)
+    Vm_new = interp1d(r,res[:,2])(row_radius)
+    
+    row.P0 = P0_new
+    row.T0 = T0_new
+    row.Vm = Vm_new
+    if row.row_type == RowType.Rotor:
+        # U(VT1-VT2) = Power/massflow; VT2 = VT1 - Power/massflow 
+        row.Vt = upstream.Vt-row.power/(row.total_massflow*row.U)
+        row.alpha2 = np.arctan2(row.Vt,row.Vx)
+    elif row.row_type == RowType.Stator:
+        row.Vt = row.Vm*np.cos(row.phi)*np.tan(row.alpha2)
+    row.Vr = row.Vm*np.sin(row.phi)
+    row.Vx = row.Vm*np.cos(row.phi)
+    
+    return row
+
+
+def radeq_normalized(row:BladeRow,upstream:BladeRow) -> BladeRow:
+    """Solves the radial equilibrium equation for axial or radial machines and returns the convergence. 
+
+    Args:
+        row (BladeRow): Current row
+        upstream (BladeRow): Previous row
+
+    Returns:
+        BladeRow: current row with Vt, T0, P0, and Vm calculated
+    """
+    _,row_radius = row.streamline.get_point(row.percent_hub_shroud)     # Use these for gradient 
+    _,up_radius = upstream.streamline.get_point(upstream.percent_hub_shroud)
+
+    def ode_radeq_streamtube(t:np.ndarray,y:np.ndarray):
+        """Solves the radial equilibrium equation for a streamtube 
+
+        Args:
+            t (np.ndarray): percent from hub to shroud
+            y (np.ndarray): Array containing [P0,Vt,VtU,T0]
+            
+        """
+        P0 = y[0]
+        T0 = y[1]
+        Vm = y[2]
+        if t>1:
+            return [0,0,0]
+        elif t<0:
+            return [0,0,0]
+
+        _,r = row.streamline.get_point()
+        Cp = row.Cp
+        # Interpolate angle of inclination (phi), exit flow angle (alpha), radius of curvature (rm) at a particular percentage from hub to shroud
+        phi = interp1d(row.percent_hub_shroud, row.phi)(t)
+        alpha = interp1d(row.percent_hub_shroud, row.alpha2)(t)
+        rm = interp1d(row.percent_hub_shroud,row.rm)(t)
+        rho = interp1d(row.percent_hub_shroud,row.rho)(t)
+    
+        
+        if (row.row_type == RowType.Rotor):
+            omega = row.rpm*np.pi/30
+            U = omega*r
+        else:
+            omega = 0
+            U = 0
+        gamma = row.gamma
+
+        # Solve the Radial Equlibrium 
+        Vt = Vm*np.cos(phi)*np.tan(alpha)
+        Vr = float(interp1d(row.percent_hub_shroud, row.Vr)(t))
+        # Estimations: need the radius of the streamline to compute gradients  
+        dVm_dr = interp1d(row_radius,np.gradient(row.Vm, row_radius))(r)
+        dVt_dr = dVm_dr*np.cos(phi)*np.tan(alpha)
+        
+        dVm_dm = interp1d(row_radius, np.gradient(Vm, r)) + interp1d(x, np.gradient(Vm, r))
+        
+        # Upstream: We interpolate the gradient based on the percentage from hub to shroud
+        dT0up_dr = interp1d(upstream.percent_hub_shroud,
+                            np.gradient(upstream.T0,up_radius))(t)
+        dP0up_dr = interp1d(upstream.percent_hub_shroud,
+                            np.gradient(upstream.P0,up_radius))(t)
+        dP0_dr = interp1d(upstream.percent_hub_shroud,
+                          np.gradient(upstream.P0,up_radius))(t)
+
+        U_up = interp1d(upstream.percent_hub_shroud,up_radius*omega)(t) # use percentage to get the T0 upstream value
+        dVtup_dr = interp1d(upstream.percent_hub_shroud,np.gradient(upstream.Vt,up_radius))(t)
+        Vtup = interp1d(upstream.percent_hub_shroud,upstream.Vt)(t)
+        
+        dP_dr = interp1d(row.percent_hub_shroud,np.gradient(row.P,row_radius))(t)
+        dT0_dr = dT0up_dr - 1/row.Cp*(U_up*dVtup_dr + Vtup*omega - (U*dVt_dr+Vt*omega)) # Eqn 8
+        # if row.loss_function.LossType == LossType.Pressure: # type: ignore
+        #     dP0_dr = dP0up_dr-row.Yp*(dP0up_dr - dP_dr)     # Eqn 9
+
+        C = Vm**2*(1+np.cos(phi)**2 * np.tan(alpha)**2)/(2*Cp*T0)
+        B = (1-C)**(gamma/(gamma-1))      
+        A = P0 * gamma/(gamma-1) * (1-C)**(1/(gamma-1))
+        dVm_dr = 1/(2*Vm*A) * (rho*(Vt/r - Vm**2/rm * np.cos(phi)-Vr*dVm_dm) - dP0_dr*B) + 1/(2*T0) *dT0_dr # Eqn 6
+        
+        ydot = np.array([dP0_dr,dT0_dr,dVm_dr])
+
+        return ydot
+
+    T0 = row.T0
+    P0 = row.P0
+    Vm = row.Vm
+
+    # Estimate the Vt based on a given turning angle 
+    _, mean_radius = row.streamline.get_point(0.5)
+    _, tip_radius = row.streamline.get_point(1)
+    _, hub_radius = row.streamline.get_point(0)
+
+    T0m = interp1d(row.percent_hub_shroud,T0)(0.5); 
+    P0m = interp1d(row.percent_hub_shroud,P0)(0.5); 
+    Vmm = interp1d(row.percent_hub_shroud,Vm)(0.5)
+    # We are solving for the values of these quantities at row exit
+    ics = np.array([P0m,T0m,Vmm])
+
+    mid_to_tip = np.linspace(0,1)
+    res1 = odeint(ode_radeq_streamtube, ics, mid_to_tip, tfirst=True) # Results
+    
+    mid_to_hub = np.flip(np.linspace(hub_radius,mean_radius))
+    res2 = odeint(ode_radeq_streamtube, ics, mid_to_hub, tfirst=True) # Results
+    
+    res2 = np.flipud(res2)
+    res = np.concatenate([res2[:-1,:],res1])    # Combine the results
+    t = np.concatenate([np.flip(mid_to_hub)[:-1], mid_to_tip])
+    
+    P0_new = interp1d(t,res[:,0])(row.percent_hub_shroud)
+    T0_new = interp1d(t,res[:,1])(row.percent_hub_shroud)
+    Vm_new = interp1d(t,res[:,2])(row.percent_hub_shroud)
+    
+    row.P0 = P0_new
+    row.T0 = T0_new
+    row.Vm = Vm_new
+    if row.row_type == RowType.Rotor:
+        # U(VT1-VT2) = Power/massflow; VT2 = VT1 - Power/massflow 
+        row.Vt = upstream.Vt-row.power/(row.total_massflow*row.U)
+        row.alpha2 = np.arctan2(row.Vt,row.Vx)
+    elif row.row_type == RowType.Stator:
+        row.Vt = row.Vm*np.cos(row.phi)*np.tan(row.alpha2)
+    row.Vr = row.Vm*np.sin(row.phi)
+    row.Vx = row.Vm*np.cos(row.phi)
+    
+    return row
+  
+
+        

turbodesign/rotor.py

@@ -0,0 +1,38 @@
+from dataclasses import dataclass, field
+from .enums import RowType
+from .bladerow import BladeRow
+from .arrayfuncs import convert_to_ndarray
+import numpy as np 
+
+class Rotor(BladeRow):
+    """Station defined at rotor exit
+
+    Inherits:
+        (BladeRow): Defines the properties of the blade row
+    """
+
+    beta2:np.ndarray = field(default_factory=lambda: np.array([72]))    # Degrees   
+    M_rel:np.ndarray = field(default_factory=lambda: np.array([1.2]))   # Relative mach number
+    power:float = 0         # Watts
+
+    def __init__(self,power:float=50000):
+        """Initialize the Rotor
+
+        Args:
+            coolant_P0 (float, optional): Coolant massflow used to cool the rotor internal cooling, tip leakage, hub disk leakage. Defaults to 0.
+            coolant_T0 (float, optional): _description_. Defaults to 500.
+            power (float, optional): _description_. Defaults to 50000.
+        """
+        self.row_type = RowType.RotorExit
+        self.power = power
+        super().__init__(self)
+
+    def initialize_rotor_exit(self,beta:float,M_exit:float):
+        """Uses the beta and exit mach number to predict a value for Vm
+
+        Args:
+            beta (float): exit relative flow angle
+            M_exit (float): exit relative mach number
+        """
+        self.beta2 = convert_to_ndarray(beta)
+        self.M_rel = convert_to_ndarray(M_exit)

turbodesign/solve_radeq.py

@@ -0,0 +1,37 @@
+from typing import List, Tuple
+from .radeq import radeq, radeq_normalized
+from .enums import LossType, RowType, PowerType, MassflowConstraint
+from .bladerow import BladeRow
+from .td_math import compute_gas_constants
+from .td_math import compute_quantities, compute_power, 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):
+    """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 
+
+    """
+    for _,row in enumerate(blade_rows):
+        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
+
+        cut_line, thub,_ = passage.get_cutting_line(row.axial_location)
+        row.x,row.r = cut_line.get_point(row.percent_hub_shroud)
+        # Radii may have shifted, recompute Ay and rm
+        for i,tr in enumerate(row.percent_hub_shroud):
+            t_streamline, x_streamline, r_streamline = passage.get_streamline(tr)                
+            phi, rm, r = passage.streamline_curvature(x_streamline,r_streamline)
+            row.phi[i] = float(interp1d(t_streamline,phi)(row.axial_location))
+            row.rm[i] = float(interp1d(t_streamline,rm)(row.axial_location))
+            row.r[i] = float(interp1d(t_streamline,r)(row.axial_location))