turbo-design 1.1.4__tar.gz → 1.3.0__tar.gz

{turbo_design-1.1.4 → turbo_design-1.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: turbo-design
-Version: 1.1.4
+Version: 1.3.0
 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.1.4 → turbo_design-1.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "turbo-design"
-version = "1.1.4"
+version = "1.3.0"
 description = "TurboDesign is a library used to design turbines and compressors using radial equilibrium."
 authors = ["Paht Juangphanich <paht.juangphanich@nasa.gov>"]
 packages = [
@@ -18,7 +18,7 @@ matplotlib = "*"
 pandas = "*"
 python = ">=3.9"
 
-[tool.poetry.dev-dependencies]
+[poetry.group.dev.dependencies]
 python = ">=3.9"
 
 [build-system]

{turbo_design-1.1.4 → turbo_design-1.3.0}/turbodesign/bladerow.py

@@ -26,7 +26,6 @@ class BladeRow:
     Cp: float = 1019            # Cp J/(Kg*K)
     Cv: float = 1019/1.14       # Cv J/(Kg*K)
     _coolant:Coolant = None     # type: ignore # Coolant Fluid
-    fluid: composite.Solution = Solution("air.yaml")
     mu:float = 0 
     
     total_massflow:float = 0    # Massflow spool + all upstream cooling flow [kg/s]
@@ -35,10 +34,11 @@ class BladeRow:
     # ----------------------------------
 
     # Streamline Properties 
-    axial_location:float = 0 # Where blade row is defined along the hub. 
+    percent_hub:float = 0 # Where blade row is defined along the hub. 
     percent_hub_shroud: npt.NDArray = field(default_factory=lambda: np.array([0]))    # Percent streamline length from hub to shroud.
     x: npt.NDArray = field(default_factory=lambda: np.array([0]))       # x - coordinates (useful for computing axial chord)
     r: npt.NDArray = field(default_factory=lambda: np.array([0]))       # Radius - coordinates 
+    m: npt.NDArray = field(default_factory=lambda: np.array([0]))       # meridional 
     area:float = 0
     # Calculated massflow is the massflow computed after radial eq solver
     calculated_massflow: float = 0
@@ -121,6 +121,7 @@ class BladeRow:
     _tip_clearance:float = 0 # Clearance as a percentage of span or blade height
 
     _inlet_to_outlet_pratio = [0.06,0.95]
+    location:float = 0 # Percent along hub where bladerow is defined
     
     @property
     def inlet_to_outlet_pratio(self) -> Tuple[float,float]:
@@ -328,18 +329,18 @@ class BladeRow:
         """
         self._tip_clearance = val
         
-    def __init__(self,axial_location:float,row_type:RowType=RowType.Stator,stage_id:int = 0):
+    def __init__(self,location:float,row_type:RowType=RowType.Stator,stage_id:int = 0):
         """Initializes the blade row to be a particular type
 
         Args:
-            axial_location (float): Location of the blade row as a percentage of the total axial length
+            location (float): Location of the blade row as a percentage of hub length
             row_type (RowType): Specifies the Type. Defaults to RowType.Stator
             power (float, optional): power . Defaults to 0.
             P0_P (float, optional): Total to Static Pressure Ratio
             stage_id (int, optional): ID of the stage so if you have 9 stages, the id could be 9. It's used to separate the stages. Each stage will have it's own unique degree of reaction 
         """
         self.row_type = row_type
-        self.axial_location = axial_location 
+        self.location = location 
         self.Yp = 0 # Loss
         self.stage_id = stage_id
     
@@ -437,7 +438,7 @@ class BladeRow:
         self._te_s = val
     
     def __repr__(self):
-        return f"{self.row_type.name:0.2f}' P0:{np.mean(self.P0):0.2f} T0:{np.mean(self.T0):0.2f} P:{np.mean(self.P):0.2f} massflow:{self.total_massflow_no_coolant}:0.3f"
+        return f"{self.row_type.name} P0:{np.mean(self.P0):0.2f} T0:{np.mean(self.T0):0.2f} P:{np.mean(self.P):0.2f} massflow:{np.mean(self.total_massflow_no_coolant):0.3f}"
     
     def to_dict(self):
         
@@ -512,7 +513,7 @@ def interpolate_streamline_radii(row:BladeRow,passage:Passage,num_streamlines:in
     Returns:
         (BladeRow): new row object with quantities interpolated
     """
-    row.cutting_line,_,_ = passage.get_cutting_line(row.axial_location)
+    row.cutting_line,_,_ = passage.get_cutting_line(row.location)
     row.x,row.r = row.cutting_line.get_point(np.linspace(0,1,num_streamlines))
     streamline_percent_length = np.sqrt((row.r-row.r[0])**2+(row.x-row.x[0])**2)/row.cutting_line.length
     
@@ -609,21 +610,24 @@ def interpolate_quantities(q:npt.NDArray,r:npt.NDArray,r2:npt.NDArray):
     else:
         return interp1d(r,q,kind='linear')(r2)
     
-def compute_gas_constants(row:BladeRow):
-    """Calculates all the gas constants for a row. 
-        This should be done if T or P change 
+def compute_gas_constants(row:BladeRow,fluid:Solution=None) -> None:
+    """Updates the Cp, Gamma, and density for a blade row. If fluid is not specified then only density and viscosity is updated. 
+    
+    Args:
+        row (BladeRow): _description_
+        fluid (Solution, optional): _description_. Defaults to None.
+
+    Returns:
+        (BladeRow): updated row
     """
-    Tm = row.T.mean()
-    Pm = row.P.mean()
-    row.fluid.TP = Tm,Pm
-    row.Cp = row.fluid.cp
-    row.Cv = row.fluid.cv
-    row.R = row.Cp-row.Cv
-    row.gamma = row.Cp/row.Cv
-    row.mu = sutherland(Tm) # type: ignore
-    row.rho[:] = row.fluid.density
-    # i = 0 
-    # for T,P in zip(row.T,row.P):
-    #     row.rho[i] = P/(T*row.R)
-    #     i+=1
-    return row
+    if fluid:
+        Tm = row.T.mean()
+        Pm = row.P.mean()
+        fluid.TP = Tm,Pm
+        row.Cp = fluid.cp
+        row.Cv = fluid.cv
+        row.R = row.Cp-row.Cv
+        row.gamma = row.Cp/row.Cv
+    # Use Ideal Gas 
+    row.rho = row.P/(row.T*row.R)
+    row.mu = sutherland(row.T) # type: ignore

{turbo_design-1.1.4 → turbo_design-1.3.0}/turbodesign/coolant.py

@@ -3,8 +3,8 @@ from cantera import Solution
 
 @dataclass
 class Coolant:
-    fluid:Solution = field(default = Solution('air.yaml')) # cantera solution
     T0:float = field(default=900)                               # Kelvin
     P0:float = field(default=50*101325)                         # Pascal
-    massflow_percentage:float = field(default=0.03)     # Fraction of total massflow going through compressor 
+    massflow_percentage:float = field(default=0.03)     # Fraction of total massflow going through compressor
+    Cp:float = field(default=1000)                              # J/K
     

{turbo_design-1.1.4 → turbo_design-1.3.0}/turbodesign/inlet.py

@@ -16,57 +16,85 @@ class Inlet(BladeRow):
         (BladeRow): Defines the properties of the blade row
     """
     fun: interp1d
-    def __init__(self,M:float,T0:Union[float,List[float]],P0:Union[float,List[float]],percent_radii:Union[float,List[float]],fluid:Solution,axial_location:float=0,beta:Union[float,List[float]]=[0]):
+    
+    def __init__(self,M:float,T0:Union[float,List[float]],
+                 P0:Union[float,List[float]],
+                 location:float=0,
+                 beta:Union[float,List[float]]=[0],
+                 percent_radii:Union[float,List[float]]=[0.5]):
         """Initializes the inlet station. 
             Uses the beta and exit mach number to predict a value for Vm
 
         Args:
             M (float): Mach number at the inlet plane
-            beta (Union[float,List[float]]): exit relative flow angle
             T0 (Union[float,List[float]]): Total Temperature Array
             P0 (Union[float,List[float]]): Total Pressure Array
             percent_radii (Union[float,List[float]]): Radius where total pressure and temperature are defined
-            fluid (ct.Solution): Cantera mixture
-            axial_location (float): Axial Location as a percentage of hub length
+            location (float): Location as a percentage of hub length
             beta (Union[float,List[float]], optional): Inlet flow angle in relative direction. Defaults to [].
+
         """
-        super().__init__(row_type=RowType.Inlet,axial_location=axial_location,stage_id=-1)
-        self.loss_function = None
+        super().__init__(row_type=RowType.Inlet,location=location,stage_id=-1)
         self.beta1 = convert_to_ndarray(beta)
         self.M = convert_to_ndarray(M)
         self.T0 = convert_to_ndarray(T0)
         self.P0 = convert_to_ndarray(P0)
         self.percent_hub_shroud = convert_to_ndarray(percent_radii)
+        
+    
+    def initialize_fluid(self,fluid:Solution=None,R:float=287.15,gamma:float=1.4,Cp:float=1024):
+        """Initialize the inlet using the fluid. This function should be called by a class that inherits from spool
+
+        Args:
+            fluid (Solution, optional): Cantera fluid object. Defaults to None.
+            R (float, optional): Ideal Gas Constant. Defaults to 287.15 J/(Kg K) for air
+            gamma (float, optional): _description_. Defaults to 1.4.
+            Cp (float, optional): _description_. Defaults to 1024 J/(Kg K).
+        
+        """
+        self.loss_function = None
+        
         # if it's inlet alpha and beta are the same, relative flow angle = absolute. 
-        self.beta2 = np.radians(convert_to_ndarray(beta))
-        self.alpha1 = np.radians(convert_to_ndarray(beta))
-        fluid.TP = self.T0.mean(),self.P0.mean()
-        self.gamma = fluid.cp/fluid.cv
+        self.beta2 = np.radians(convert_to_ndarray(self.beta1))
+        self.alpha1 = np.radians(convert_to_ndarray(self.beta1))
         
-        self.T = self.T0 * 1/(1 + (self.gamma-1) * self.M**2)
-        self.P = self.P0 * 1/(1 + (self.gamma-1) * self.M**2)**(self.gamma/(self.gamma-1))
-        fluid.TP = self.T.mean(),self.P.mean()
-        self.rho = convert_to_ndarray([fluid.density])
-        self.fluid = fluid
+        if fluid:
+            fluid.TP = self.T0.mean(),self.P0.mean()
+            self.gamma = fluid.cp/fluid.cv
+            self.T = self.T0 * 1/(1 + (self.gamma-1) * self.M**2)
+            self.P = self.P0 * 1/(1 + (self.gamma-1) * self.M**2)**(self.gamma/(self.gamma-1))
+            fluid.TP = self.T.mean(),self.P.mean()
+            self.rho = convert_to_ndarray([fluid.density])
+        else:
+            self.Cp = Cp
+            self.gamma = gamma
+            self.R = R
+            self.T = self.T0 * 1/(1 + (self.gamma-1) * self.M**2)
+            self.P = self.P0 * 1/(1 + (self.gamma-1) * self.M**2)**(self.gamma/(self.gamma-1))
+            self.rho = self.P/(self.R*self.T)
+
         self.rpm = 0
-        
         self.beta1_metal = [0] 
         self.beta2_metal = [0]
-        self.P0_fun = interp1d(self.percent_hub_shroud,P0)
-        self.T0_fun = interp1d(self.percent_hub_shroud,T0)
+        self.P0_fun = interp1d(self.percent_hub_shroud,self.P0)
+        self.T0_fun = interp1d(self.percent_hub_shroud,self.T0)
         self.mprime = [0]
-
         
     def initialize_velocity(self,passage:Passage,num_streamlines:int):
         """Initialize velocity calculations. Assumes streamlines and inclination angles have been calculated 
-     
+            Call this before performing calculations
+            
+        Args:
+            passage (Passage): Passage object
+            num_streamlines (int): number of streamlines
+        
         """
         # Perform Calculations on Velocity 
         Vm_prev = 0; Vm_err = 0 
         t,x,radius = passage.get_streamline(self.percent_hub_shroud)
         radius = radius[0]
 
-        cutline,_,_ = passage.get_cutting_line(self.axial_location)
+        cutline,_,_ = passage.get_cutting_line(self.location)
         self.x,self.r = cutline.get_point(np.linspace(0,1,num_streamlines))
         for _ in range(10):
             T0_T = (1+(self.gamma-1)/2 * self.M**2)
@@ -84,7 +112,7 @@ class Inlet(BladeRow):
             self.V = np.sqrt(self.Vm**2 + self.Vt**2)        
             self.Vr = self.Vm * np.sin(self.phi) 
             
-            self = compute_gas_constants(self)
+            compute_gas_constants(self)
             rho_mean = self.rho.mean()
             for i in range(len(self.massflow)-1):    
                 tube_massflow = self.massflow[i+1]-self.massflow[i]

{turbo_design-1.1.4 → turbo_design-1.3.0}/turbodesign/outlet.py

@@ -12,7 +12,7 @@ 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):
+    def __init__(self,P:Union[float,List[float]],percent_radii:List[float],num_streamlines:int=3,location:float=1):
         """Initialize the outlet
 
         Args:
@@ -26,6 +26,7 @@ class Outlet(BladeRow):
         self.P_fun = interp1d(self.percent_hub_shroud,self.P)
         self.row_type = RowType.Outlet
         self.loss_function = None
+        self.location = location
     
     
     def transfer_quantities(self,upstream:BladeRow):

{turbo_design-1.1.4 → turbo_design-1.3.0}/turbodesign/passage.py

@@ -1,7 +1,7 @@
 from typing import List, Tuple
 import numpy as np
 import numpy.typing as npt
-from scipy.interpolate import PchipInterpolator
+from scipy.interpolate import PchipInterpolator, interp1d
 from pyturbo.helper import line2D
 from .enums import PassageType
 from scipy.optimize import minimize_scalar
@@ -142,7 +142,31 @@ class Passage:
             
         return phi, rm, r
         
-    def get_cutting_line(self, t_hub:float) -> line2D:
+    def get_area(self,t_hub:float) -> float:
+        """Get Area
+
+        Args:
+            t_hub (float): Percent arc length along the hub 
+
+        Returns:
+            float: Area
+        """
+        n = 100
+        line = self.get_cutting_line(t_hub)[0]
+        x,r = line.get_point(np.linspace(0,1,n))
+        total_area = 0 
+        for j in range(1,n):
+            if np.abs((x[-1]-x[0]))<1E-12: # Axial Machines
+                total_area += np.pi*(r[j]**2-r[j-1]**2)
+            else:   # Radial Machines
+                dx = x[j]-x[j-1]
+                S = (r[j]-r[j-1])
+                C = np.sqrt(1+((r[j]-r[j-1])/dx)**2)
+                area = 2*np.pi*C*(S/2*dx**2+r[j-1]*dx)
+                total_area += area
+        return total_area
+        
+    def get_cutting_line(self, t_hub:float) -> Tuple[line2D,float,float]:
         """Gets the cutting line perpendicular to hub and shroud 
 
         Args:
@@ -188,17 +212,18 @@ class Passage:
         rshroud = self.rshroud(t_shroud)
         return line2D([xhub,rhub],[xshroud,rshroud]), t_hub, t_shroud
     
-    def get_xr_slice(self,t_span:float,axial_location:Tuple[float,float]):
+    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
             
         Args:
             t_span (float): _description_
-            axial_location (float): _description_
+            meridional_location (float): _description_
+            resolution (int): number of points to resolve 
 
         Returns:
             np.NDArray: _description_
         """
-        t_hub = np.linspace(axial_location[0],axial_location[1],100)
+        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()
@@ -209,8 +234,39 @@ class Passage:
         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
-        
+    
+    def get_m(self,t_span:float,resolution:int=100) -> npt.NDArray:
+        """Meridional cooridnates
+
+        Args:
+            t_span (float): _description_
+            resolution (int, optional): _description_. Defaults to 100.
+
+        Returns:
+            npt.NDArray: _description_
+        """
+        xr = self.get_xr_slice(t_span,(0,1),resolution)
+        dx = np.diff(xr[:,0])
+        dr = np.diff(xr[:,1])
+        m = np.concat([[0],np.cumsum(np.sqrt(dx**2 + dr**2))])
+        return m
+    
+    def get_dm(self,t_span:float,location:float,resolution:int=1000) -> float:
+        """return the derivative in the meridional direction at a particular point
+
+        Args:
+            t_span (float): percent span 
+            location (float): hub location of the blade
+            resolution (int, optional): number of points to represent the hub curve. Defaults to 1000.
+
+        Returns:
+            (float) : returns the derivative 
+        """
+        m = self.get_m(t_span,resolution)
+        return PchipInterpolator(np.linspace(0,1,resolution),np.diff(m))(location)
+    
     @property
     def hub_length(self):
         """returns the computed length of the hub 

{turbo_design-1.1.4 → turbo_design-1.3.0}/turbodesign/radeq.py

@@ -1,11 +1,12 @@
-from scipy.interpolate import interp1d
+from scipy.interpolate import interp1d,PchipInterpolator
 from scipy.integrate import odeint
-import numpy as np 
+import numpy as np  
+import numdifftools as nd 
 from .bladerow import BladeRow
 from .enums import RowType
 
 
-def radeq(row:BladeRow,upstream:BladeRow) -> BladeRow:
+def radeq(row:BladeRow,upstream:BladeRow,downstream:BladeRow=None) -> BladeRow:
     """Solves the radial equilibrium equation for axial machines and returns the convergence. 
 
     Note:
@@ -14,7 +15,8 @@ def radeq(row:BladeRow,upstream:BladeRow) -> BladeRow:
     Args:
         row (BladeRow): Current row
         upstream (BladeRow): Previous row
-
+        downstream (BladeRow): Next row
+        
     Returns:
         BladeRow: current row with T0, P0, and Vm calculated
     """
@@ -57,8 +59,30 @@ def radeq(row:BladeRow,upstream:BladeRow) -> BladeRow:
         # 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)
-
+        # dVr_dr = dVm_dr*np.sin(phi)
+        
+        up_Vm = interp1d(row_radius, upstream.Vm)(r)
+        if downstream:
+            if downstream.row_type == RowType.Outlet:
+                down_Vm = Vm
+            else:
+                down_Vm = interp1d(row_radius, downstream.Vm)(r)
+        else:
+            down_Vm = Vm
+        up_m = interp1d(row_radius, upstream.m)(r)
+        
+        # Get a rough guess of dVm/dm
+        if downstream!=None:
+            down_m = interp1d(row_radius, downstream.m)(r)
+            row_m = interp1d(row_radius, row.m)(r)
+            if down_m != row_m:
+                func_Vm_m = PchipInterpolator([up_m, row_m, down_m],[up_Vm, Vm, down_Vm])
+            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)
+        
         # 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
@@ -79,7 +103,12 @@ def radeq(row:BladeRow,upstream:BladeRow) -> BladeRow:
             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))
-        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
+        
+        epsilon = 1e-10  # or another small threshold
+        if abs(rm) > epsilon:
+            dVm_dr = Cp*T0/(Vm*A*(1+np.tan(alpha)**2)) * (rho*(Vt**2/r + Vm**2/rm * np.cos(phi) - Vr*dVm_dm) - B*dP0_dr) + Vm/(2*T0) *dT0_dr  # Eqn 6
+        else:
+            dVm_dr = Cp*T0/(Vm*A*(1+np.tan(alpha)**2)) * (rho*(Vt**2/r - Vr*dVm_dm) - B*dP0_dr) + Vm/(2*T0) *dT0_dr  # Eqn 6
         
         ydot = np.array([dP0_dr,dT0_dr,dVm_dr])
 

{turbo_design-1.1.4 → turbo_design-1.3.0}/turbodesign/solve_radeq.py

@@ -18,7 +18,8 @@ def adjust_streamlines(blade_rows:List[BladeRow],passage:Passage):
         passage (Passage): passage object describing the hub and shroud 
 
     """
-    for _,row in enumerate(blade_rows):
+    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
@@ -26,13 +27,13 @@ def adjust_streamlines(blade_rows:List[BladeRow],passage:Passage):
         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)
+        cut_line, thub,_ = passage.get_cutting_line(row.percent_hub)
         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))
-            row.x[i] = float(interp1d(t_streamline,x_streamline)(row.axial_location))
+            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))

{turbo_design-1.1.4 → turbo_design-1.3.0}/turbodesign/spool.py

@@ -1,7 +1,7 @@
 # type: ignore[arg-type, reportUnknownArgumentType]
 from dataclasses import field
 import json
-from typing import Dict, List, Union
+from typing import Dict, List, Union, Optional
 import matplotlib.pyplot as plt
 from .bladerow import BladeRow
 import numpy as np
@@ -34,7 +34,7 @@ class Spool:
     def __init__(self,passage:Passage,
                  massflow:float,rows=List[BladeRow],
                  num_streamlines:int=3,
-                 fluid:Solution=Solution('air.yaml'),
+                 fluid:Solution=None,
                  rpm:float=-1,
                  massflow_constraint:MassflowConstraint=MassflowConstraint.MatchMassFlow):
         """Initializes a Spool
@@ -50,7 +50,7 @@ class Spool:
             massflow (float): massflow at spool inlet 
             rows (List[BladeRow], optional): List of blade rows. Defaults to List[BladeRow].
             num_streamlines (int, optional): number of streamlines. Defaults to 3.
-            gas (ct.Solution, optional): cantera gas solution. Defaults to ct.Solution('air.yaml').
+            fluid (ct.Solution, optional): cantera gas solution. Defaults to None, fluid is set by bladerow cp
             rpm (float, optional): RPM for the entire spool Optional, you can also set rpm of the blade rows individually. Defaults to -1.
             massflow_constraint (MassflowConstraint, optional): MatchMassflow - Matches the massflow defined in the spool. BalanceMassflow - Balances the massflow between BladeRows, matches the lowest massflow.
         """
@@ -70,13 +70,12 @@ class Spool:
                 2. Counter Rotation: We either use the RPM already persecribed for each blade row.
             '''    
             if (type(self.blade_rows[i]) != Inlet) and (type(self.blade_rows[i]) != Outlet):
-                self.blade_rows[i].fluid = self.fluid
                 self.blade_rows[i].rpm = rpm
-                self.blade_rows[i].axial_chord = self.blade_rows[i].axial_location * self.passage.hub_length
+                self.blade_rows[i].axial_chord = self.blade_rows[i].location * self.passage.hub_length
             
 
     @property
-    def fluid(self):
+    def fluid(self) -> Optional[Solution]:
         return self._fluid
 
     @fluid.setter
@@ -159,13 +158,15 @@ class Spool:
             row.phi = np.zeros((self.num_streamlines,))
             row.rm = np.zeros((self.num_streamlines,))
             row.r = np.zeros((self.num_streamlines,))
+            row.m = np.zeros((self.num_streamlines,))
             
             t_radial = np.linspace(0,1,self.num_streamlines)
             self.calculate_streamline_curvature(row,t_radial)
-                
+            
             # Set the loss function if it's not set
-            if (row.loss_function == None):  
-                row.loss_function = TD2()
+            if (type(row)!= Inlet and type(row) != Outlet):  
+                if row.loss_function == None:
+                    row.loss_function = TD2()
             
     def calculate_streamline_curvature(self,row:BladeRow,t_radial:Union[List[float],npt.NDArray]):
         """Called to calculate new streamline curvature
@@ -177,9 +178,10 @@ class Spool:
         for i,tr in enumerate(t_radial):
             t_streamline, x_streamline, r_streamline = self.passage.get_streamline(tr)                
             phi, rm, r = self.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.phi[i] = float(interp1d(t_streamline,phi)(row.location))
+            row.rm[i] = float(interp1d(t_streamline,rm)(row.location))
+            row.r[i] = float(interp1d(t_streamline,r)(row.location))
+            row.m[i] = float(interp1d(t_streamline,self.passage.get_m(tr,resolution=len(t_streamline)))(row.location))
           
     def solve(self):
         raise NotImplementedError('Solve is not implemented')
@@ -214,10 +216,10 @@ class Spool:
             else:  # i>0
                 upstream = self.blade_rows[i-1]
                 if upstream.row_type== RowType.Inlet:
-                    cut_line1,_,_ = self.passage.get_cutting_line((row.axial_location*hub_length +(0.5*row.blade_to_blade_gap*row.axial_chord) - row.axial_chord)/hub_length)
+                    cut_line1,_,_ = self.passage.get_cutting_line((row.location*hub_length +(0.5*row.blade_to_blade_gap*row.axial_chord) - row.axial_chord)/hub_length)
                 else:
-                    cut_line1,_,_ = self.passage.get_cutting_line((upstream.axial_location*hub_length)/hub_length)
-                cut_line2,_,_ = self.passage.get_cutting_line((row.axial_location*hub_length-(0.5*row.blade_to_blade_gap*row.axial_chord))/hub_length)
+                    cut_line1,_,_ = self.passage.get_cutting_line((upstream.location*hub_length)/hub_length)
+                cut_line2,_,_ = self.passage.get_cutting_line((row.location*hub_length-(0.5*row.blade_to_blade_gap*row.axial_chord))/hub_length)
                 
             if self.blade_rows[i].row_type == RowType.Stator:
                 x1,r1 = cut_line1.get_point(np.linspace(0,1,10))