turbo-design 1.3.2__tar.gz → 1.3.4__tar.gz

{turbo_design-1.3.2 → turbo_design-1.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.1
 Name: turbo-design
-Version: 1.3.2
+Version: 1.3.4
 Summary: TurboDesign is a library used to design turbines and compressors using radial equilibrium.
 Author: Paht Juangphanich
 Author-email: paht.juangphanich@nasa.gov
@@ -10,7 +10,6 @@ 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 → turbo_design-1.3.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "turbo-design"
-version = "1.3.2"
+version = "1.3.4"
 description = "TurboDesign is a library used to design turbines and compressors using radial equilibrium."
 authors = ["Paht Juangphanich <paht.juangphanich@nasa.gov>"]
 packages = [

{turbo_design-1.3.2 → turbo_design-1.3.4}/turbodesign/bladerow.py

@@ -14,6 +14,7 @@ from .passage import Passage
     
 
 class BladeRow:
+    id:int = 0
     stage_id:int = 0
     row_type: RowType = RowType.Stator
     loss_function:LossBaseClass

{turbo_design-1.3.2 → turbo_design-1.3.4}/turbodesign/radeq.py

@@ -1,12 +1,12 @@
+from typing import Optional
 from scipy.interpolate import interp1d,PchipInterpolator
 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:
+def radeq(row:BladeRow,upstream:BladeRow,downstream:Optional[BladeRow]=None) -> BladeRow:
     """Solves the radial equilibrium equation for axial machines and returns the convergence. 
 
     Note:
@@ -81,8 +81,8 @@ def radeq(row:BladeRow,upstream:BladeRow,downstream:BladeRow=None) -> BladeRow:
             else:
                 func_Vm_m = PchipInterpolator([up_m, row_m],[up_Vm, Vm])    
         else:
-            func_Vm_m = PchipInterpolator([up_m, row_m],[up_Vm, Vm])    
-        dVm_dm = func_Vm_m.derivative()(row_m)
+            func_Vm_m = PchipInterpolator([up_m, row_m],[up_Vm, Vm])     # type: ignore
+        dVm_dm = func_Vm_m.derivative()(row_m) # type: ignore
         
         # Upstream 
         dT_dr = float(interp1d(row_radius, np.gradient(row.T,row_radius))(r))
@@ -94,12 +94,12 @@ def radeq(row:BladeRow,upstream:BladeRow,downstream:BladeRow=None) -> BladeRow:
         # 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")
+        if (C>1):
+            raise Exception(f"Invalid value of C {C:0.2f} which causes Vm to be nan.\nChange reduce alpha/beta for {row.row_type} {row.id}")
         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 = Vt**2/r - Vm**2/rm*np.cos(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
@@ -107,7 +107,6 @@ def radeq(row:BladeRow,upstream:BladeRow,downstream:BladeRow=None) -> BladeRow:
             dVm_dr = T0/(2*Vm*A) * (rho*eqn15_rhs - B*dP0_dr) + Vm/(2*T0) * dT0_dr # Eqn 21
         else:
             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])
 
         return ydot
@@ -133,18 +132,22 @@ def radeq(row:BladeRow,upstream:BladeRow,downstream:BladeRow=None) -> BladeRow:
     # 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)
-    
+    r_eval = row.r - mean_radius 
     # 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)
+    res1 = solve_ivp(ode_radeq_streamtube, t_span =[0, tip_radius-mean_radius], y0 = ics,
+                     t_eval=np.linspace(0,tip_radius-mean_radius,len(row_radius)*2))
     
     # 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)
+    res2 = solve_ivp(ode_radeq_streamtube, t_span = [0,hub_radius-mean_radius], y0 = ics,
+                     t_eval=np.linspace(0,hub_radius-mean_radius,len(row_radius)*2))
     
     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)
+    mid_to_hub_r = np.flipud(mid_to_hub_r)
+    
     hub_to_tip_vals = np.concatenate([mid_to_hub_vals[:-1,:],mid_to_tip_vals])
     
     r = np.concatenate([mid_to_hub_r[:-1], mid_to_tip_r])

{turbo_design-1.3.2 → turbo_design-1.3.4}/turbodesign/spool.py

@@ -69,6 +69,7 @@ class Spool:
                 1. Conventional: Stator-Rotor-Stator-Rotor-etc. Set the RPM equally across all
                 2. Counter Rotation: We either use the RPM already persecribed for each blade row.
             '''    
+            self.blade_rows[i].id = i
             if (type(self.blade_rows[i]) != Inlet) and (type(self.blade_rows[i]) != Outlet):
                 self.blade_rows[i].rpm = rpm
                 self.blade_rows[i].axial_chord = self.blade_rows[i].location * self.passage.hub_length

{turbo_design-1.3.2 → turbo_design-1.3.4}/turbodesign/td_math.py

@@ -132,7 +132,8 @@ def compute_power(row:BladeRow,upstream:BladeRow) -> None:
         a = np.sqrt(row.gamma*row.R*row.T_is)
         row.T0_is = row.T_is * (1+(row.gamma-1)/2*(row.V/a)**2)
         
-        row.power = row.massflow[-1] * row.Cp * (upstream.T0.mean() - row.T0.mean())
+        row.power = row.massflow[-1] * (row.Cp * (upstream.T0 - row.T0)).mean()
+        # row.power = sum(v * w for v, w in zip(row.power[1:], np.diff(row.massflow))) # Massflow weighted average 
         row.eta_static = row.power/ (row.massflow[-1]*row.Cp*(upstream.T0.mean()-row.T_is.mean()))
         row.eta_total = (upstream.T0.mean() - row.T0.mean()) / (upstream.T0.mean() - row.T0_is.mean())
         row.stage_loading = row.Cp*(upstream.T0.mean() - row.T0.mean())/row.U.mean()**2