turbo-design 1.0.8__tar.gz → 1.0.10__tar.gz

{turbo_design-1.0.8 → turbo_design-1.0.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: turbo-design
-Version: 1.0.8
+Version: 1.0.10
 Summary: TurboDesign is a library used to design turbines and compressors using radial equilibrium.
 Author: Paht Juangphanich
 Author-email: paht.juangphanich@nasa.gov

{turbo_design-1.0.8 → turbo_design-1.0.10}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "turbo-design"
-version = "1.0.8"
+version = "1.0.10"
 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.0.8 → turbo_design-1.0.10}/turbodesign/passage.py

@@ -59,7 +59,7 @@ class Passage:
         """Gets the streamline at a certain percent radius 
 
         Args:
-            t_radial (float): _description_
+            t_radial (float): percent between hub and shroud
 
         Returns:
             Tuple containing:

{turbo_design-1.0.8 → turbo_design-1.0.10}/turbodesign/solve_radeq.py

@@ -34,4 +34,5 @@ def adjust_streamlines(blade_rows:List[BladeRow],passage:Passage):
             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))
+            row.r[i] = float(interp1d(t_streamline,r)(row.axial_location))
+            row.x[i] = float(interp1d(t_streamline,x_streamline)(row.axial_location))

{turbo_design-1.0.8 → turbo_design-1.0.10}/turbodesign/spool.py

@@ -28,6 +28,7 @@ class Spool:
     _fluid: Solution = Solution("air.yaml")
 
     massflow_constraint: MassflowConstraint
+    _adjust_streamlines:bool = True
     
     # Inlet Conditions 
     def __init__(self,passage:Passage,
@@ -87,6 +88,23 @@ class Spool:
         """
         self._fluid = newFluid
 
+    @property
+    def adjust_streamlines(self) -> bool:
+        """Variable that determines whether or not to try and adjust the streamlines to balance massflow
+        This can be a source of failure. Setting it to false may help with debugging. 
+
+        Returns:
+            bool: True = streamlines are adjusted after calculation; False = No changes in streamlines
+        """
+        return self._adjust_streamlines
+    
+    @adjust_streamlines.setter
+    def adjust_streamlines(self,val:bool):
+        """Variable that determines whether or not to try and adjust the streamlines to balance massflow
+        This can be a source of failure. Setting it to false may help with debugging. 
+        """
+        self._adjust_streamlines = val
+    
 
     def set_blade_row_rpm(self,index:int,rpm:float):
         """sets the rpm of a particular blade row"""    
@@ -229,7 +247,7 @@ class Spool:
             x_start = 0
             y_max = 0; y_min = 0
             plt.figure(num=1,clear=True)
-            for i in range(1,len(self.blade_rows)):
+            for i in range(1,len(self.blade_rows)-1): # Don't plot inlet or outlet 
                 row = self.blade_rows[i]
                 x_end = x_start + row.Vx.mean()
                 dx = x_end - x_start

{turbo_design-1.0.8 → turbo_design-1.0.10}/turbodesign/td_math.py

@@ -57,8 +57,8 @@ def compute_massflow(row:BladeRow) -> None:
     massflow = row.percent_hub_shroud*0
     total_area = 0 
     for j in range(1,len(row.percent_hub_shroud)):
-        Vm = row.Vm[j]
-        rho = row.rho[j]
+        Vm = (row.Vm[j]+row.Vm[j-1])/2
+        rho = (row.rho[j]+row.rho[j-1])/2
         if np.abs((row.x[j]-row.x[j-1]))<1E-12: # Axial Machines
             total_area += np.pi*(row.r[j]**2-row.r[j-1]**2)
             massflow[j] = Vm * rho * np.pi* (row.r[j]**2-row.r[j-1]**2) + massflow[j-1]
@@ -360,8 +360,10 @@ def inlet_calc(row:BladeRow):
         row (BladeRow): _description_
     """
     area = row.Vm.copy()*0
+    # Estimate the density
     row.T = row.T0
     row.P = row.P0 
+    row.rho = row.P/(row.T*row.R)
     total_area = 0 
     for _ in range(5): # Lets converge the Mach and Total and Static pressures
         for j in range(1,len(row.percent_hub_shroud)):
@@ -381,7 +383,7 @@ def inlet_calc(row:BladeRow):
         row.Vr = row.Vm*np.sin(row.phi)
         row.Vt = row.Vm*np.cos(row.phi)*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)
         row.T = row.T0 * 1/(1+(row.gamma-1)/2*row.M**2)
         row.P = row.P0 * (row.T/row.T0)**(row.gamma/(row.gamma-1))

{turbo_design-1.0.8 → turbo_design-1.0.10}/turbodesign/turbinespool.py

@@ -3,7 +3,7 @@ from cantera.composite import Solution
 from .bladerow import BladeRow, interpolate_streamline_radii
 from .enums import RowType, MassflowConstraint, LossType, PassageType
 from .spool import Spool
-import json
+import json, copy
 from .passage import Passage
 from scipy.interpolate import interp1d
 import numpy as np
@@ -11,7 +11,8 @@ import numpy.typing as npt
 from .td_math import inlet_calc,rotor_calc, stator_calc, compute_massflow, compute_power, compute_gas_constants
 from .solve_radeq import adjust_streamlines, radeq
 from scipy.optimize import minimize_scalar, minimize, fmin_slsqp
-
+from .inlet import Inlet
+from .outlet import Outlet
 
 class TurbineSpool(Spool):
     def __init__(self,passage:Passage,
@@ -49,7 +50,7 @@ class TurbineSpool(Spool):
             self.blade_rows[0].total_massflow = W0 
             self.blade_rows[0].total_massflow_no_coolant = W0 
             
-            interpolate_streamline_radii(self.blade_rows[0],self.passage)
+            interpolate_streamline_radii(self.blade_rows[0],self.passage,self.num_streamlines)
 
             # Set the gas to total values for now             
             self.blade_rows[0].fluid.TP = self.blade_rows[0].T0.mean(), self.blade_rows[0].P0.mean()
@@ -61,7 +62,7 @@ class TurbineSpool(Spool):
             inlet_calc(self.blade_rows[0])
         
         for row in self.blade_rows:
-            interpolate_streamline_radii(row,self.passage)
+            interpolate_streamline_radii(row,self.passage,self.num_streamlines)
 
         outlet = self.blade_rows[-1]
         for j in range(self.num_streamlines):
@@ -191,56 +192,122 @@ class TurbineSpool(Spool):
                 3. Adjust the streamlines for each blade row to balance the massflow
         """
         
-        # Balance the massflow between Stages
-        def balance_massflows(x0:List[float],blade_rows:List[List[BladeRow]],P0:npt.NDArray,P:npt.NDArray):
-            total_massflow = list(); massflow_stage = list()
-            stage_ids = list(set([row.stage_id for row in self.blade_rows if row.stage_id>=0])); s = 0 
-            sign = 1 
-            for j in range(self.num_streamlines):                
-                Ps_range = outlet_pressure(x0,P0[j],P[j])
-                for i in range(1,len(blade_rows)-1):
-                    blade_rows[i].P[j] = Ps_range[i-1]
-            blade_rows[-1].P = P
-            calculate_massflows(blade_rows,True)
+        def calculate_error(blade_rows):
+            total_massflow = list(); s = 0; massflow_stage = list()
+            stage_ids = list(set([row.stage_id for row in self.blade_rows if row.stage_id>=0]))
             for row in blade_rows[1:]:
                 total_massflow.append(row.total_massflow_no_coolant)
-            for s in stage_ids:
-                for row in blade_rows:
-                    if row.stage_id == s and row.row_type == RowType.Rotor:
-                        massflow_stage.append(sign*row.total_massflow_no_coolant)
-                        sign*=-1
-            if len(stage_ids) % 2 == 1:
-                massflow_stage.append(massflow_stage[-1]*sign)
-            print(x0)
+                    
+                sign = 1
+                for s in stage_ids:
+                    for row in blade_rows:
+                        if row.stage_id == s and row.row_type == RowType.Rotor:
+                            massflow_stage.append(sign*row.total_massflow_no_coolant)
+                            sign*=-1
+                if len(stage_ids) % 2 == 1:
+                    massflow_stage.append(massflow_stage[-1]*sign)
+                
             return np.std(total_massflow)*2 # + abs(sum(massflow_stage))  # Equation 28
-        
+            
+        # Balance the massflow between Stages
+        def balance_massflows(x0:List[float],blade_rows:List[List[BladeRow]],P0:npt.NDArray,P:npt.NDArray,balance_mean_pressure:bool=True):
+            """Balance Massflows. 
+            
+            Steps:
+                1. Balance the mean static pressure in between the blade rows. X0 = [0.2,0.5,...] size = num_rows
+                    P = outlet static pressure 
+                    
+                2. Keep the mean 
+
+            Args:
+                x0 (List[float]): _description_
+                blade_rows (List[List[BladeRow]]): _description_
+                P0 (npt.NDArray): _description_
+                P (npt.NDArray): (1) Outlet Static Pressure. (2) 
+                balance_mean_pressure (bool, optional): _description_. Defaults to True.
+
+            Returns:
+                _type_: _description_
+            """
+            try:
+                if balance_mean_pressure:
+                    for j in range(self.num_streamlines):                
+                        Ps_range = outlet_pressure(x0,P0[j],P[j])
+                        for i in range(1,len(blade_rows)-1):
+                            blade_rows[i].P[j] = Ps_range[i-1]
+                    blade_rows[-1].P = P
+                else:
+                    for i in range(1,len(blade_rows)-1):
+                        for j in range(self.num_streamlines):
+                            blade_rows[i].P[j] = P[j]*x0[(i-1)*self.num_streamlines+j]    # x0 size = num_streamlines -1 
+                    
+                calculate_massflows(blade_rows,True)
+                print(x0)
+                return calculate_error(blade_rows)
+            except:
+                for i in range(1,len(blade_rows)-1):
+                    for j in range(self.num_streamlines):
+                        blade_rows[i].P[j] = P[j]
+                calculate_massflows(blade_rows,True)
+                return 10
         # Break apart the rows to stages
-        outlet_P=list(); outlet_P_guess = list()
+        outlet_P=list(); outlet_P_guess = list() # Outlet P is the bounds, outlet_p_guess is the guessed values 
         
         for i in range(1,len(self.blade_rows)-2):
             outlet_P.append(self.blade_rows[i].inlet_to_outlet_pratio)
             outlet_P_guess.append(np.mean(self.blade_rows[i].inlet_to_outlet_pratio))
         
+        print('Find average P in between stages')
         if len(outlet_P) == 1:
-            res1 = minimize_scalar(fun=balance_massflows,args=(self.blade_rows[:-1],self.blade_rows[0].P0,self.blade_rows[-1].P), 
-                        bounds=outlet_P[0],tol=0.001,options={'disp': True})
-            x = res1.x
+            res = minimize_scalar(fun=balance_massflows,args=(self.blade_rows[:-1],self.blade_rows[0].P0,self.blade_rows[-1].P), 
+                        bounds=outlet_P[0],tol=0.0001,options={'disp': True})
+            x = res.x
         else:
             x = fmin_slsqp(func=balance_massflows,args=(self.blade_rows[:-1],self.blade_rows[0].P0,self.blade_rows[-1].P), 
                         bounds=outlet_P, x0=outlet_P_guess,epsilon=0.001,iter=100) # ,tol=0.001,options={'disp': True})
+            outlet_P_guess = x 
         
         # Adjust the inlet: Set the massflow
         self.blade_rows[0].massflow = np.linspace(0,1,self.num_streamlines)*self.blade_rows[1].total_massflow_no_coolant
         inlet_calc(self.blade_rows[0]) # adjust the inlet to match massflow 
-        for _ in range(3):
-            adjust_streamlines(self.blade_rows[:-1],self.passage)
+        
+        if self.adjust_streamlines:
+            for _ in range(2):
+                adjust_streamlines(self.blade_rows[:-1],self.passage)
+                self.blade_rows[-1].transfer_quantities(self.blade_rows[-2])
+                self.blade_rows[-1].P = self.blade_rows[-1].get_static_pressure(self.blade_rows[-1].percent_hub_shroud)
+                balance_massflows(x,self.blade_rows[:-1],self.blade_rows[0].P0,self.blade_rows[-1].P) 
+        else:
             self.blade_rows[-1].transfer_quantities(self.blade_rows[-2])
             self.blade_rows[-1].P = self.blade_rows[-1].get_static_pressure(self.blade_rows[-1].percent_hub_shroud)
-            err = balance_massflows(x,self.blade_rows[:-1],self.blade_rows[0].P0,self.blade_rows[-1].P)
-        if err>5E-2:
-            print(f"Massflow is not convergenced error:{err}")
-        else: 
-            print(f"Massflow converged to less than 0.05kg/s error:{err}")
+        err = calculate_error(self.blade_rows[:-1])
+        print(f"Massflow convergenced error:{err}")
+            
+        # finetune = True
+        # if finetune:        
+        #     print('Finetune static pressure between stages')
+        #     self.blade_rows[-1].transfer_quantities(self.blade_rows[-2])
+        #     self.blade_rows[-1].P = self.blade_rows[-1].get_static_pressure(self.blade_rows[-1].percent_hub_shroud)
+        #     P = [row.P for row in self.blade_rows] # Average static pressures
+        #     bounds = []; guess = []
+        #     for i in range(1,len(self.blade_rows)-1): # set the bounds 
+        #         for j in range(self.num_streamlines):
+        #             bounds.append([0.8,1.2]) # vary by +- 20%
+        #             guess.append(1)
+            
+        #     x = fmin_slsqp(func=balance_massflows,args=(self.blade_rows[:-1],self.blade_rows[0].P0,P,False), 
+        #                 bounds=bounds, x0=guess,epsilon=0.001,iter=200)
+        #     P = [row.P for row in self.blade_rows] # Average static pressures
+            
+        #     for _ in range(2):
+        #         adjust_streamlines(self.blade_rows[:-1],self.passage)
+        #         self.blade_rows[-1].transfer_quantities(self.blade_rows[-2])
+        #         self.blade_rows[-1].P = self.blade_rows[-1].get_static_pressure(self.blade_rows[-1].percent_hub_shroud)
+        #         balance_massflows(x,self.blade_rows[:-1],self.blade_rows[0].P0,P,False)
+                
+        #     err = calculate_error(self.blade_rows[:-1])
+        #     print(f"Massflow convergenced error after finetuning:{err}")
+            
     
     def export_properties(self,filename:str="turbine_spool.json"):
         """Export the spool object to json 
@@ -277,7 +344,13 @@ class TurbineSpool(Spool):
                 t,x,r = self.passage.get_streamline(p)
                 x_streamline[j,indx] = float(interp1d(t,x)(row.axial_location))
                 r_streamline[j,indx] = float(interp1d(t,r)(row.axial_location))
-                
+        
+        Pratio_Total_Total = np.mean(self.blade_rows[0].P0 / self.blade_rows[-2].P0)
+        Pratio_Total_Static = np.mean(self.blade_rows[0].P0 / self.blade_rows[-2].P)
+        FlowFunction = np.mean(massflow)*np.sqrt(self.blade_rows[0].T0)*self.blade_rows[0].P0/1000 # kg sqrt(K)/(sec kPa)
+        CorrectedSpeed = self.rpm * np.pi/30 / np.sqrt(self.blade_rows[0].T0.mean())   # rad/s * 1/sqrt(K)
+        EnergyFunction = (self.blade_rows[0].T0 - self.blade_rows[-2].T0) * 0.5* (self.blade_rows[0].Cp + self.blade_rows[-2].Cp) / self.blade_rows[0].T0 # J/(KgK)
+        EnergyFunction = np.mean(EnergyFunction)
         data = {            
             "blade_rows": blade_rows,
             "massflow":np.mean(massflow),
@@ -292,7 +365,12 @@ class TurbineSpool(Spool):
             "total-total_efficiency":total_total_efficiency,
             "total-static_efficiency":total_static_efficiency,
             "stage_loading":stage_loading,
-            "degree_of_reaction":degree_of_reaction
+            "degree_of_reaction":degree_of_reaction,
+            "Pratio_Total_Total":Pratio_Total_Total,
+            "Pratio_Total_Static":Pratio_Total_Static,
+            "FlowFunction":FlowFunction,
+            "CorrectedSpeed":CorrectedSpeed,
+            "EnergyFunction":EnergyFunction
         }
         # Dump all the Python objects into a single JSON file.
         class NumpyEncoder(json.JSONEncoder):
@@ -326,7 +404,7 @@ def calculate_massflows(blade_rows:List[BladeRow],calculate_vm:bool=False):
             else:
                 downstream = None 
             
-                # Pressure loss = shift in entropy which affects the total pressure of the row
+            # Pressure loss = shift in entropy which affects the total pressure of the row
             if row.row_type == RowType.Inlet:
                 row.Yp = 0
             else: