turbo-design 1.3.1__py3-none-any.whl → 1.3.2__py3-none-any.whl

{turbo_design-1.3.1.dist-info → turbo_design-1.3.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: turbo-design
-Version: 1.3.1
+Version: 1.3.2
 Summary: TurboDesign is a library used to design turbines and compressors using radial equilibrium.
 Author: Paht Juangphanich
 Author-email: paht.juangphanich@nasa.gov
@@ -10,6 +10,7 @@ Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Requires-Dist: cantera
 Requires-Dist: findiff
 Requires-Dist: matplotlib

turbo_design-1.3.2.dist-info/RECORD

@@ -0,0 +1,55 @@
+turbodesign/.DS_Store,sha256=t7V1NfD6bO4j43hG3uNmietQ86qxjKeImkJzP2ywlbo,8196
+turbodesign/__init__.py,sha256=N8Nu0I1vrlEHYJZZ7yhhg-FtbNbLyrgjy7hoicygUqg,325
+turbodesign/arrayfuncs.py,sha256=GHIlTyLfeNsNCQQoh5m1aXK3iyvU6RjdYQipkqpU_ps,519
+turbodesign/bladerow.py,sha256=v4tX27aOL7iuN0ILWYbtSbANWZ_7_LIxksu4ux1aQ2o,24959
+turbodesign/cantera_gas/co2.yaml,sha256=M2o_RzxV9B9rDkgkXJC-l3voKraFZguTZuKKt4F7S_c,887
+turbodesign/compressorspool.py,sha256=z8ZVczJ-EdZvIqqZArC6UdwC5MbU2SZh_MT2CGq5avY,2600
+turbodesign/coolant.py,sha256=evDtUFOYhfZKTVAsDWzxRzUX20gTvfjj0uybaWg4CsI,427
+turbodesign/enums.py,sha256=T4aFrGMnx9fgZkrExMBIY2IbCueA0utqr_afk-TUe9Q,1188
+turbodesign/inlet.py,sha256=L_IHE8zzm3uFMSow0iO-VxI71SnyQZwRhJMlJDcwZ4o,7329
+turbodesign/isentropic.py,sha256=YLTmNx69e_M5fTuLOmk_KvaQ6ABv0aZsityfBihJOmI,2003
+turbodesign/loss/.DS_Store,sha256=e_rC7wNyUbhwj0B0K6KYPxjmDluA2pn-nPFKtB93cfg,8196
+turbodesign/loss/__init__.py,sha256=ZJomzXa6ElduFruURukCrFwJQXMWS2aW8JSaVQ-M2r8,46
+turbodesign/loss/__pycache__/__init__.cpython-310.pyc,sha256=O-Uef93wkpiZg2LEZJlwSRHJmyWvzUVPdQhazmUDzqY,240
+turbodesign/loss/__pycache__/__init__.cpython-312.pyc,sha256=hb-aUXzBVDra2DhnX5EHnMxHhOGg5GtGTSYeDYOSV7k,242
+turbodesign/loss/__pycache__/losstype.cpython-310.pyc,sha256=Xng0JhBRPhBVq3ajlo2iXy0TU1X8eZpfAHEiJ3nuemg,1258
+turbodesign/loss/__pycache__/losstype.cpython-312.pyc,sha256=D2cC1pJyAsSeYpm4cl09qIQG_0Z-0lQpQ9Q9JdhbueI,1729
+turbodesign/loss/compressor/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+turbodesign/loss/losstype.py,sha256=Vzj3UPk1_5IA3DtL56Eb5Z7LkYyMQ97DGZvgfki8ByA,708
+turbodesign/loss/turbine/TD2.py,sha256=evyTG4K6s56NGdjxrZFD3G7zsB8_2lJTBOxT3Ju2uG8,5207
+turbodesign/loss/turbine/__init__.py,sha256=d1UrbiIicO60FhDlOemo_irYW2asUaYoqlXUz-UG9zk,285
+turbodesign/loss/turbine/__pycache__/TD2.cpython-310.pyc,sha256=_xmRJL3-uKEX7wIfFNJwlKrTl5NEfFhqe--NsGHlbpA,4037
+turbodesign/loss/turbine/__pycache__/TD2.cpython-312.pyc,sha256=AKWBhyn5DqDolrhmJHYN1VfOz2qbtxSlBPfOo99GnCg,5657
+turbodesign/loss/turbine/__pycache__/__init__.cpython-310.pyc,sha256=08oqidbLwK0k2Bwe_mrK7TupB3h5UrEcCG-scobWCas,533
+turbodesign/loss/turbine/__pycache__/__init__.cpython-312.pyc,sha256=7_ZJqoesRMXAMEVhltiRTEdJBwCaX9AtOEhFcBQyABM,546
+turbodesign/loss/turbine/__pycache__/ainleymathieson.cpython-310.pyc,sha256=0aWYiEVGu3IfCHQ8b4-z3T3Ov7wdqDOHW1ERkMDNGy8,4887
+turbodesign/loss/turbine/__pycache__/ainleymathieson.cpython-312.pyc,sha256=FdgZSynbR0LiwunAj4UPVGkfbtZ9uoJDaeVtr25uelo,9397
+turbodesign/loss/turbine/__pycache__/craigcox.cpython-310.pyc,sha256=xsBf4UJSwijRq6r_WQRk7q9tYpS2id5XZJiF-ovMslg,6353
+turbodesign/loss/turbine/__pycache__/craigcox.cpython-312.pyc,sha256=nTzvA31LQKYQriHuYQNmHCjTMNpqphfpRL306ilbJzI,12163
+turbodesign/loss/turbine/__pycache__/fixedefficiency.cpython-310.pyc,sha256=D00hoTdPBqqm6J7m2iMMMb3fKsnZqdbwhXS6R8ezWxI,1263
+turbodesign/loss/turbine/__pycache__/fixedefficiency.cpython-312.pyc,sha256=CGw2WgkjJfKxvpUO0Qlw19w_6HnZqX47cRJIz763vgI,1498
+turbodesign/loss/turbine/__pycache__/fixedpressureloss.cpython-310.pyc,sha256=-cwVbUmXsqGnYlUccc1ZWpSl4X4ZO1-XJtQ78mps5N0,1191
+turbodesign/loss/turbine/__pycache__/fixedpressureloss.cpython-312.pyc,sha256=anr2ZSqXg5_AFQnTZYdRw2dTHK-wCpIDJeMCTGu_RMg,1370
+turbodesign/loss/turbine/__pycache__/kackerokapuu.cpython-310.pyc,sha256=Snq6kyzAbRQ_h9WSKD5sjQs_ADcUj-JHEVqVmPY9ixE,4432
+turbodesign/loss/turbine/__pycache__/kackerokapuu.cpython-312.pyc,sha256=ldnWoi8a1T2UE_iH-aw_L7M-Xgak4gYdPa02Hwdt5xc,8574
+turbodesign/loss/turbine/__pycache__/traupel.cpython-310.pyc,sha256=OUGOncOs84iMlPd5mGgtqiY95V2NU2JHyDXLF_kwKk8,3183
+turbodesign/loss/turbine/__pycache__/traupel.cpython-312.pyc,sha256=x_BnQ49DhhL_cMYzORlOLAoxd8GgGGmd-w4ec5kHDds,6445
+turbodesign/loss/turbine/ainleymathieson.py,sha256=8UbugNmxI12I68HGctJe2lQpqjKZN1b40UOTzqU6hQQ,5861
+turbodesign/loss/turbine/craigcox.py,sha256=TrbNdpGdyD5kTRFKfNmbRDhCOjA0-GT5xoluLQpO1gA,9664
+turbodesign/loss/turbine/fixedefficiency.py,sha256=JJv4GUS5q9pvuf3akjBtlcHOykRYmRVFfDDrdWqH6S4,774
+turbodesign/loss/turbine/fixedpressureloss.py,sha256=jbm8dt8wtyN1RaOgpgYZsvwM0-0lv2Y73kXleyoy0zE,683
+turbodesign/loss/turbine/kackerokapuu.py,sha256=hUmZdyA1hAhN3_xbwBhka2dyk0Aq9rqq62S2ghuKSOk,5071
+turbodesign/loss/turbine/traupel.py,sha256=aZxFE9JDcCfi1gy-fqS1SxjjlhuDG-H-g3LPurty1M0,4164
+turbodesign/lossinterp.py,sha256=B2KEobp-nD9jwD6UINgBmTlH9kKyWg3UNvXxqfUsr-k,6198
+turbodesign/outlet.py,sha256=-0XpeEmTQpFjUQNYQxOp5WuHkF7cXfx59hxy7BmaxgY,2119
+turbodesign/passage.py,sha256=Ur6zZCzI9Y7HW0o5LrDq9yeatRain1mBLZBcTOzgjEU,11996
+turbodesign/radeq.py,sha256=1_OOOBP_UglnnPuF5WKhMXTzfzXcuMDJ5A0Zsr_2Mf0,6201
+turbodesign/rotor.py,sha256=tHl9o5H4aQ6Etd4gqa8Ime1UK7k0de4GLt5Yb1sJdGs,1376
+turbodesign/solve_radeq.py,sha256=nLYlRtXElPgHaoUP9jwMulRmYKTJs_uQ1eCulk2V59I,1938
+turbodesign/spool.py,sha256=XKvYABvfigLulGLHH23X7k6aL6wvfuqgfLkKCMK9X8c,14338
+turbodesign/stage.py,sha256=UP45sDKDLsAkO_WfDWJ6kqXU7cYKh_4QO01QZnSN1oQ,166
+turbodesign/td_math.py,sha256=1hWf-B24jxiDfJHNUVOTC_0lEMZ8iu_4GNoKE4uxm6Y,16072
+turbodesign/turbinespool.py,sha256=8ttt2DuExuQFt9SXraRWhaYHQDkgyh_B6AoJqdNgRlg,25046
+turbo_design-1.3.2.dist-info/METADATA,sha256=8QYJqpja9gYWj8N5aKgfJcSj510Odrdir761wlhav0A,734
+turbo_design-1.3.2.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
+turbo_design-1.3.2.dist-info/RECORD,,

{turbo_design-1.3.1.dist-info → turbo_design-1.3.2.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.9.0
+Generator: poetry-core 2.0.1
 Root-Is-Purelib: true
 Tag: py3-none-any

turbodesign/radeq.py

@@ -1,10 +1,10 @@
 from scipy.interpolate import interp1d,PchipInterpolator
-from scipy.integrate import odeint
+from scipy.integrate import solve_ivp
 import numpy as np  
 import numdifftools as nd 
 from .bladerow import BladeRow
 from .enums import RowType
-
+import math 
 
 def radeq(row:BladeRow,upstream:BladeRow,downstream:BladeRow=None) -> BladeRow:
     """Solves the radial equilibrium equation for axial machines and returns the convergence. 
@@ -22,7 +22,7 @@ def radeq(row:BladeRow,upstream:BladeRow,downstream:BladeRow=None) -> BladeRow:
     """
     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 
 
@@ -34,6 +34,7 @@ def radeq(row:BladeRow,upstream:BladeRow,downstream:BladeRow=None) -> BladeRow:
         P0 = y[0]
         T0 = y[1]
         Vm = y[2]
+        r = row.r.mean()+r
         if r>row_radius[-1]:
             return [0,0,0]
         elif r<row_radius[0]:
@@ -42,6 +43,8 @@ def radeq(row:BladeRow,upstream:BladeRow,downstream:BladeRow=None) -> BladeRow:
         Cp = row.Cp
         phi = interp1d(row_radius, row.phi)(r)
         alpha = interp1d(row_radius, row.alpha2)(r)
+        T = interp1d(row_radius, row.T)(r)
+        P = interp1d(row_radius, row.P)(r)
         rm = interp1d(row_radius, row.rm)(r)
         rho = row.rho.mean()
         
@@ -57,11 +60,9 @@ def radeq(row:BladeRow,upstream:BladeRow,downstream:BladeRow=None) -> BladeRow:
         Vt = Vm*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.tan(alpha)
-        # dVr_dr = dVm_dr*np.sin(phi)
-        
+        dVm_dr = float(interp1d(row_radius, np.gradient(row.Vm, row_radius))(r))        
         up_Vm = interp1d(row_radius, upstream.Vm)(r)
+        
         if downstream:
             if downstream.row_type == RowType.Outlet:
                 down_Vm = Vm
@@ -84,31 +85,28 @@ def radeq(row:BladeRow,upstream:BladeRow,downstream:BladeRow=None) -> BladeRow:
         dVm_dm = func_Vm_m.derivative()(row_m)
         
         # 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.tan(alpha)**2)/(2*Cp*T0)
+        dT_dr = float(interp1d(row_radius, np.gradient(row.T,row_radius))(r))
+        dP_dr = float(interp1d(row_radius, np.gradient(row.P,row_radius))(r))
+        P = float(interp1d(row_radius, np.gradient(row.P,row_radius))(r))
+        dT0_dr = dT_dr + Vm/Cp * (1 + np.tan(alpha)**2)*dVm_dr 
+        dP0_dr = dP_dr * (T0/T)**(gamma/(gamma-1)) + P*gamma/(gamma-1) * (T0/T)**(1/(gamma-1)) * (T*dT0_dr-T0*dT_dr)/T**2
+        # dT0_dr = float(interp1d(row.percent_hub_shroud, np.gradient(row.T0,row_radius))((r-row_radius[0])/(row_radius[-1]-row_radius[0]))) 
+        # dP0_dr = float(interp1d(row.percent_hub_shroud, np.gradient(row.P0,row_radius))((r-row_radius[0])/(row_radius[-1]-row_radius[0]))) 
+        
+        C = (1 + np.tan(alpha)**2) * Vm**2/(2*Cp*T0)
         if (C>1) & ((gamma/(gamma-1))<2):
             raise Exception("Invalid value of C {C}, change reduce alpha or Vm")
-        B = (1-C)**(gamma/(gamma-1))      
-        A = P0 * gamma/(gamma-1) * (1-C)**(1/(gamma-1)) * (1+np.tan(alpha)**2)/(2*Cp)
+        B = (1-C)**(gamma/(gamma-1))
+        A = -P0 * gamma/(gamma-1) * (1-C)**(1/(gamma-1)) * (1 + np.tan(alpha)**2)/(2*Cp)
+        
+        eqn15_rhs = Vt**2/r - Vm**2/rm*np.sin(phi) - Vr*dVm_dm # right hand side of equation 15
+        eqn15_rhs_simple = Vt**2/r # right hand side of equation 15 simplified for axial machines
         
         epsilon = 1e-10  # or another small threshold
         if abs(rm) > epsilon:
-            dVm_dr = Vm/(2*T0**2) * dT0_dr - rho/(2*A*Vm) * (Vt**2/r + Vm/rm*np.cos(phi)-Vr*dVm_dm) + B/(2*A*Vm) * dP0_dr  # Eqn 21
+            dVm_dr = T0/(2*Vm*A) * (rho*eqn15_rhs - B*dP0_dr) + Vm/(2*T0) * dT0_dr # Eqn 21
         else:
-            dVm_dr = Vm/(2*T0**2) * dT0_dr - rho/(2*A*Vm) * (Vt**2/r) + B/(2*A*Vm) * dP0_dr  # Eqn 21, modified 
+            dVm_dr = T0/(2*Vm*A) * (rho*eqn15_rhs_simple - B*dP0_dr) + Vm/(2*T0) * dT0_dr  # Eqn 21, simple 
         
         ydot = np.array([dP0_dr,dT0_dr,dVm_dr])
 
@@ -121,166 +119,42 @@ def radeq(row:BladeRow,upstream:BladeRow,downstream:BladeRow=None) -> BladeRow:
 
     # Estimate the Vt based on a given turning angle 
     mean_radius = row_radius.mean()
-    tip_radius = row_radius[-1]
-    hub_radius = row_radius[0]
+    tip_radius = row_radius.max()
+    hub_radius = row_radius.min()
 
     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)
+    # hub_to_tip = np.linspace(hub_radius,tip_radius)
+    # res = odeint(ode_radeq_streamtube, ics, hub_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)
+    # P0_new = interp1d(hub_to_tip,res[:,0])(row_radius)
+    # T0_new = interp1d(hub_to_tip,res[:,1])(row_radius)
+    # Vm_new = interp1d(hub_to_tip,res[:,2])(row_radius)
     
-    res2 = np.flipud(res2)
-    res = np.concatenate([res2[:-1,:],res1])
-    r = np.concatenate([np.flip(rm_to_hub)[:-1], rm_to_tip])
+    # mean_radius_to_tip = np.linspace(0,tip_radius-mean_radius,len(row_radius)*5)
+    res1 = solve_ivp(ode_radeq_streamtube, t_span =[0, tip_radius-mean_radius], y0 = ics)
     
-    P0_new = interp1d(r,res[:,0])(row_radius)
-    T0_new = interp1d(r,res[:,1])(row_radius)
-    Vm_new = interp1d(r,res[:,2])(row_radius)
+    # mean_radius_to_hub = np.linspace(0,hub_radius-mean_radius,len(row_radius)*5)
+    res2 = solve_ivp(ode_radeq_streamtube, t_span = [hub_radius-mean_radius,0], y0 = ics)
     
-    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)
+    mid_to_tip_vals = res1.y.transpose()
+    mid_to_tip_r = res1.t + mean_radius
+    mid_to_hub_vals = res2.y.transpose()
+    mid_to_hub_r = res2.t + mean_radius
+    mid_to_hub_vals = np.flipud(mid_to_hub_vals)
+    hub_to_tip_vals = np.concatenate([mid_to_hub_vals[:-1,:],mid_to_tip_vals])
     
-    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
+    r = np.concatenate([mid_to_hub_r[:-1], mid_to_tip_r])
     
-    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)
+    P0_new = interp1d(r,hub_to_tip_vals[:,0])(row_radius)
+    T0_new = interp1d(r,hub_to_tip_vals[:,1])(row_radius)
+    Vm_new = interp1d(r,hub_to_tip_vals[:,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
-  
 
-        

turbodesign/solve_radeq.py

@@ -1,5 +1,5 @@
 from typing import List, Tuple
-from .radeq import radeq, radeq_normalized
+from .radeq import radeq
 from .enums import LossType, RowType, PowerType, MassflowConstraint
 from .bladerow import BladeRow
 from .td_math import compute_gas_constants

turbodesign/td_math.py

@@ -296,7 +296,7 @@ def rotor_calc(row:BladeRow,upstream:BladeRow,calculate_vm:bool=True):
     row.P0R = upstream.P0R - row.Yp*(upstream.P0R-row.P)
     
     # Total Relative Temperature stays constant through the rotor. Adjust for change in radius from rotor inlet to exit
-    row.T0R = (upstream_rothalpy + 0.5*row.U**2)/row.Cp - T0_coolant_weighted_average(row) 
+    row.T0R = upstream.T0R # (upstream_rothalpy + 0.5*row.U**2)/row.Cp # - T0_coolant_weighted_average(row) 
     P0R_P = row.P0R / row.P
     T0R_T = P0R_P**((row.gamma-1)/row.gamma)
     row.T = (row.T0R/T0R_T)     # Exit static temperature
@@ -326,7 +326,7 @@ def rotor_calc(row:BladeRow,upstream:BladeRow,calculate_vm:bool=True):
         row.Vt = row.Wt+row.U
         
         row.alpha2 = np.arctan2(row.Vt,row.Vm)
-        row.V = np.sqrt(row.Vx**2 + row.Vr**2 + row.Vt**2)
+        row.V = np.sqrt(row.Vm**2*(1+np.tan(row.alpha2)**2))
         
         row.M = row.V/np.sqrt(row.gamma*row.R*row.T)
         T0_T = (1+(row.gamma-1)/2 * row.M**2)
@@ -369,7 +369,7 @@ def inlet_calc(row:BladeRow):
             raise ValueError(f"Unusually slow flow:{iter} Mach:{avg_mach}")
         row.Vm[0] = 1/(len(row.Vm)-1)*row.Vm[1:].sum() # Initialize the value at the hub to not upset the mean
         row.Vr = row.Vm*np.sin(row.phi)
-        row.Vt = row.Vm*np.cos(row.phi)*np.tan(row.alpha2)
+        row.Vt = row.Vm*np.tan(row.alpha2)
         row.V = np.sqrt(row.Vt**2+row.Vm**2)
         # Fine tune the Temperature and Pressure and density
         row.M = row.V/np.sqrt(row.gamma*row.R*row.T)

turbodesign/turbinespool.py

@@ -13,6 +13,7 @@ from .solve_radeq import adjust_streamlines, radeq
 from scipy.optimize import minimize_scalar, differential_evolution, fmin_slsqp
 from .inlet import Inlet
 from .outlet import Outlet
+from pyturbo.helper import convert_to_ndarray
 
 class TurbineSpool(Spool):
     
@@ -193,7 +194,7 @@ class TurbineSpool(Spool):
         """
         total_massflow = list(); s = 0; massflow_stage = list()
         stage_ids = list(set([row.stage_id for row in blade_rows if row.stage_id>=0]))
-        for row in blade_rows[1:-1]: # Ignore inlet and outlet
+        for row in blade_rows: # Ignore inlet and outlet
             total_massflow.append(row.total_massflow_no_coolant)
             sign = 1
             for s in stage_ids:
@@ -237,7 +238,7 @@ class TurbineSpool(Spool):
                 2. Keep the mean 
 
             Args:
-                x0 (List[float]): _description_
+                x0 (List[float]): Percentage of P0 exiting each row
                 blade_rows (List[List[BladeRow]]): _description_
                 P0 (npt.NDArray): _description_
                 P (npt.NDArray): (1) Outlet Static Pressure. (2) 
@@ -250,9 +251,9 @@ class TurbineSpool(Spool):
             # try:
             if balance_mean_pressure:
                 for j in range(self.num_streamlines):
-                    Ps_range = outlet_pressure(x0,P0[j],P[j])
+                    Ps = outlet_pressure(x0,P0[j],P[j])
                     for i in range(1,len(blade_rows)-2):
-                        blade_rows[i].P[j] = Ps_range[i-1]
+                        blade_rows[i].P[j] = float(Ps[i-1])
                 blade_rows[-2].P = P
             else:
                 for i in range(1,len(blade_rows)-1):
@@ -261,7 +262,7 @@ class TurbineSpool(Spool):
             # try:  
             calculate_massflows(blade_rows,True,self.fluid)
             print(x0)
-            return self.__massflow_std__(blade_rows)
+            return self.__massflow_std__(blade_rows[1:-1]) # do not consider inlet and outlet
             # except Exception as e:
             #     print(e)
             # finally:
@@ -280,7 +281,7 @@ class TurbineSpool(Spool):
         past_err = -100; loop_iter = 0; err = 0.001
         while (np.abs((err-past_err)/err)>0.05) and loop_iter<10:
             if len(outlet_P) == 1:
-                # x = balance_massflows(0.658,self.blade_rows[:-1],self.blade_rows[0].P0,self.blade_rows[-1].P)
+                # x = balance_massflows(0.22896832148169688,self.blade_rows,self.blade_rows[0].P0,self.blade_rows[-1].P)
                 res = minimize_scalar(fun=balance_massflows,args=(self.blade_rows,self.blade_rows[0].P0,self.blade_rows[-1].P),bounds=outlet_P[0],tol=0.001,options={'disp': True},method='bounded')
                 x = res.x
                 print(x)
@@ -395,64 +396,63 @@ def calculate_massflows(blade_rows:List[BladeRow],calculate_vm:bool=False,fluid:
         passage (Passage): _description_
         calculate_vm (bool, optional): _description_. Defaults to False.
     """
-    for p in range(3):
-        for i in range(1,len(blade_rows)-1):
-            row = blade_rows[i]
-            # Upstream Row
-            if i == 0:
-                upstream = blade_rows[i]
-            else:
-                upstream = blade_rows[i-1]
-            if i<len(blade_rows)-1:
-                downstream = blade_rows[i+1]
-            
-            # Pressure loss = shift in entropy which affects the total pressure of the row
-            if row.row_type == RowType.Inlet:
-                row.Yp = 0
-            else:
-                if row.loss_function.loss_type == LossType.Pressure:
-                    row.Yp = row.loss_function(row,upstream)
-                    for _ in range(2):
-                        if row.row_type == RowType.Rotor:
-                            rotor_calc(row,upstream,calculate_vm=True)
-                            # Finds Equilibrium between Vm, P0, T0
-                            row = radeq(row,upstream,downstream) 
-                            compute_gas_constants(row,fluid)
-                            rotor_calc(row,upstream,calculate_vm=False)
-                        elif row.row_type == RowType.Stator:
-                            stator_calc(row,upstream,downstream,calculate_vm=True)
-                            # Finds Equilibrium between Vm, P0, T0
-                            row = radeq(row,upstream,downstream)
-                            compute_gas_constants(row,fluid)
-                            stator_calc(row,upstream,downstream,calculate_vm=False)
-                        compute_gas_constants(row,fluid)
-                        compute_massflow(row)
-                        compute_power(row,upstream)
-                        
-                elif row.loss_function.loss_type == LossType.Enthalpy: 
+    for i in range(1,len(blade_rows)-1):
+        row = blade_rows[i]
+        # Upstream Row
+        if i == 0:
+            upstream = blade_rows[i]
+        else:
+            upstream = blade_rows[i-1]
+        if i<len(blade_rows)-1:
+            downstream = blade_rows[i+1]
+        
+        # Pressure loss = shift in entropy which affects the total pressure of the row
+        if row.row_type == RowType.Inlet:
+            row.Yp = 0
+        else:
+            if row.loss_function.loss_type == LossType.Pressure:
+                row.Yp = row.loss_function(row,upstream)
+                for _ in range(2):
                     if row.row_type == RowType.Rotor:
-                        row.Yp = 0
-                        rotor_calc(row,upstream,calculate_vm=calculate_vm)
-                        eta_total = float(row.loss_function(row,upstream))
-                        def find_yp(Yp,row,upstream):
-                            row.Yp = Yp
-                            rotor_calc(row,upstream,calculate_vm=True)
-                            row = radeq(row,upstream)
-                            compute_gas_constants(row,fluid)
-                            rotor_calc(row,upstream,calculate_vm=False)
-                            return abs(row.eta_total - eta_total)
-                        
-                        res = minimize_scalar(find_yp,bounds=[0,0.6],args=(row,upstream))
-                        row.Yp = res.x
+                        rotor_calc(row,upstream,calculate_vm=True)
+                        # Finds Equilibrium between Vm, P0, T0
+                        row = radeq(row,upstream,downstream) 
+                        compute_gas_constants(row,fluid)
+                        rotor_calc(row,upstream,calculate_vm=False)
                     elif row.row_type == RowType.Stator:
-                        row.Yp = 0
                         stator_calc(row,upstream,downstream,calculate_vm=True)
-                        row = radeq(row,upstream) 
-                        row = compute_gas_constants(row,fluid)
+                        # Finds Equilibrium between Vm, P0, T0
+                        row = radeq(row,upstream,downstream)
+                        compute_gas_constants(row,fluid)
                         stator_calc(row,upstream,downstream,calculate_vm=False)
-                    row = compute_gas_constants(row,fluid)
+                    compute_gas_constants(row,fluid)
                     compute_massflow(row)
                     compute_power(row,upstream)
+                    
+            elif row.loss_function.loss_type == LossType.Enthalpy: 
+                if row.row_type == RowType.Rotor:
+                    row.Yp = 0
+                    rotor_calc(row,upstream,calculate_vm=calculate_vm)
+                    eta_total = float(row.loss_function(row,upstream))
+                    def find_yp(Yp,row,upstream):
+                        row.Yp = Yp
+                        rotor_calc(row,upstream,calculate_vm=True)
+                        row = radeq(row,upstream)
+                        compute_gas_constants(row,fluid)
+                        rotor_calc(row,upstream,calculate_vm=False)
+                        return abs(row.eta_total - eta_total)
+                    
+                    res = minimize_scalar(find_yp,bounds=[0,0.6],args=(row,upstream))
+                    row.Yp = res.x
+                elif row.row_type == RowType.Stator:
+                    row.Yp = 0
+                    stator_calc(row,upstream,downstream,calculate_vm=True)
+                    row = radeq(row,upstream) 
+                    row = compute_gas_constants(row,fluid)
+                    stator_calc(row,upstream,downstream,calculate_vm=False)
+                row = compute_gas_constants(row,fluid)
+                compute_massflow(row)
+                compute_power(row,upstream)
     
 def massflow_loss_function(exit_angle:float,index:int,row:BladeRow,upstream:BladeRow,downstream:BladeRow=None,fluid:Solution=None):
     """Finds the blade exit angles that balance the massflow throughout the stage 
@@ -533,14 +533,10 @@ def outlet_pressure(percents:List[float],inletP0:float,outletP:float) -> npt.NDA
     Returns:
         npt.NDArray: Array of static pressures
     """
-    maxP = inletP0
-    minP = outletP
-    if isinstance(percents, float):
-        Ps = [percents*(maxP-minP)+minP]
-    else:
-        Ps = np.zeros(shape=(len(percents),1)); i = 0
-        for p in percents:
-            Ps[i] = p*(maxP - minP) + minP
-            maxP = Ps[i]
-            i+=1
-    return Ps
+    percents = convert_to_ndarray(percents)
+    Ps = np.zeros((len(percents),))
+    for i in range(len(percents)):
+        Ps[i] = float(interp1d((0,1),(inletP0,outletP))(percents[i]))
+        inletP0 = Ps[i] 
+    return Ps
+    

turbo_design-1.3.1.dist-info/RECORD

@@ -1,33 +0,0 @@
-turbodesign/__init__.py,sha256=N8Nu0I1vrlEHYJZZ7yhhg-FtbNbLyrgjy7hoicygUqg,325
-turbodesign/arrayfuncs.py,sha256=GHIlTyLfeNsNCQQoh5m1aXK3iyvU6RjdYQipkqpU_ps,519
-turbodesign/bladerow.py,sha256=v4tX27aOL7iuN0ILWYbtSbANWZ_7_LIxksu4ux1aQ2o,24959
-turbodesign/cantera_gas/co2.yaml,sha256=M2o_RzxV9B9rDkgkXJC-l3voKraFZguTZuKKt4F7S_c,887
-turbodesign/compressorspool.py,sha256=z8ZVczJ-EdZvIqqZArC6UdwC5MbU2SZh_MT2CGq5avY,2600
-turbodesign/coolant.py,sha256=evDtUFOYhfZKTVAsDWzxRzUX20gTvfjj0uybaWg4CsI,427
-turbodesign/enums.py,sha256=T4aFrGMnx9fgZkrExMBIY2IbCueA0utqr_afk-TUe9Q,1188
-turbodesign/inlet.py,sha256=L_IHE8zzm3uFMSow0iO-VxI71SnyQZwRhJMlJDcwZ4o,7329
-turbodesign/isentropic.py,sha256=YLTmNx69e_M5fTuLOmk_KvaQ6ABv0aZsityfBihJOmI,2003
-turbodesign/loss/__init__.py,sha256=ZJomzXa6ElduFruURukCrFwJQXMWS2aW8JSaVQ-M2r8,46
-turbodesign/loss/compressor/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-turbodesign/loss/losstype.py,sha256=Vzj3UPk1_5IA3DtL56Eb5Z7LkYyMQ97DGZvgfki8ByA,708
-turbodesign/loss/turbine/TD2.py,sha256=evyTG4K6s56NGdjxrZFD3G7zsB8_2lJTBOxT3Ju2uG8,5207
-turbodesign/loss/turbine/__init__.py,sha256=d1UrbiIicO60FhDlOemo_irYW2asUaYoqlXUz-UG9zk,285
-turbodesign/loss/turbine/ainleymathieson.py,sha256=8UbugNmxI12I68HGctJe2lQpqjKZN1b40UOTzqU6hQQ,5861
-turbodesign/loss/turbine/craigcox.py,sha256=TrbNdpGdyD5kTRFKfNmbRDhCOjA0-GT5xoluLQpO1gA,9664
-turbodesign/loss/turbine/fixedefficiency.py,sha256=JJv4GUS5q9pvuf3akjBtlcHOykRYmRVFfDDrdWqH6S4,774
-turbodesign/loss/turbine/fixedpressureloss.py,sha256=jbm8dt8wtyN1RaOgpgYZsvwM0-0lv2Y73kXleyoy0zE,683
-turbodesign/loss/turbine/kackerokapuu.py,sha256=hUmZdyA1hAhN3_xbwBhka2dyk0Aq9rqq62S2ghuKSOk,5071
-turbodesign/loss/turbine/traupel.py,sha256=aZxFE9JDcCfi1gy-fqS1SxjjlhuDG-H-g3LPurty1M0,4164
-turbodesign/lossinterp.py,sha256=B2KEobp-nD9jwD6UINgBmTlH9kKyWg3UNvXxqfUsr-k,6198
-turbodesign/outlet.py,sha256=-0XpeEmTQpFjUQNYQxOp5WuHkF7cXfx59hxy7BmaxgY,2119
-turbodesign/passage.py,sha256=Ur6zZCzI9Y7HW0o5LrDq9yeatRain1mBLZBcTOzgjEU,11996
-turbodesign/radeq.py,sha256=hmHNmP5Fj0qgwq0o_j_bSyC4ktL3XFuC3QaebH5Ju_M,11361
-turbodesign/rotor.py,sha256=tHl9o5H4aQ6Etd4gqa8Ime1UK7k0de4GLt5Yb1sJdGs,1376
-turbodesign/solve_radeq.py,sha256=mGVBHmc20pAXEDKGzyiU3BVUsmY9gJl7zhbtHZqxARg,1956
-turbodesign/spool.py,sha256=XKvYABvfigLulGLHH23X7k6aL6wvfuqgfLkKCMK9X8c,14338
-turbodesign/stage.py,sha256=UP45sDKDLsAkO_WfDWJ6kqXU7cYKh_4QO01QZnSN1oQ,166
-turbodesign/td_math.py,sha256=NMKgHkc36LCrr4bZxjxx7TcA4ztaRps1cIsm1tucMrk,16069
-turbodesign/turbinespool.py,sha256=VmoyLH-TqaX9uXF5xWhwNriLPKZ5trjLiRg8NdV9MiE,25268
-turbo_design-1.3.1.dist-info/METADATA,sha256=3b9pATZ2DBpozyTFfEHxS5YxjY-pCCfwgYEQ5NGnjkA,683
-turbo_design-1.3.1.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-turbo_design-1.3.1.dist-info/RECORD,,