turbo-design 1.1.3__py3-none-any.whl → 1.2.1__py3-none-any.whl

{turbo_design-1.1.3.dist-info → turbo_design-1.2.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.1
 Name: turbo-design
-Version: 1.1.3
+Version: 1.2.1
 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.1.3.dist-info → turbo_design-1.2.1.dist-info}/RECORD

@@ -1,11 +1,11 @@
 turbodesign/__init__.py,sha256=N8Nu0I1vrlEHYJZZ7yhhg-FtbNbLyrgjy7hoicygUqg,325
 turbodesign/arrayfuncs.py,sha256=GHIlTyLfeNsNCQQoh5m1aXK3iyvU6RjdYQipkqpU_ps,519
-turbodesign/bladerow.py,sha256=I0KYtw7c5cy32vxq1D54TrIkfsdbRlDWsnoCIADtCUA,24582
+turbodesign/bladerow.py,sha256=M28spmHMwPc_3jVxzjzPwY-mbn4aeX5GrBEf4UomqYA,24857
 turbodesign/cantera_gas/co2.yaml,sha256=M2o_RzxV9B9rDkgkXJC-l3voKraFZguTZuKKt4F7S_c,887
 turbodesign/compressorspool.py,sha256=z8ZVczJ-EdZvIqqZArC6UdwC5MbU2SZh_MT2CGq5avY,2600
-turbodesign/coolant.py,sha256=nuj7ryUXuBhuOPt2jHjHwtEM_LVno7A8Wm14P0lJn-8,436
+turbodesign/coolant.py,sha256=evDtUFOYhfZKTVAsDWzxRzUX20gTvfjj0uybaWg4CsI,427
 turbodesign/enums.py,sha256=T4aFrGMnx9fgZkrExMBIY2IbCueA0utqr_afk-TUe9Q,1188
-turbodesign/inlet.py,sha256=QeSvFi35JeOPevjQrz1TmAhoWkScXT9BRA_5oRTnDEE,6322
+turbodesign/inlet.py,sha256=9vAI0rf8O03SV5iI2Kf154cktlPFzyuW-LR2Xy2hWz0,7365
 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
@@ -20,14 +20,14 @@ turbodesign/loss/turbine/kackerokapuu.py,sha256=hUmZdyA1hAhN3_xbwBhka2dyk0Aq9rqq
 turbodesign/loss/turbine/traupel.py,sha256=aZxFE9JDcCfi1gy-fqS1SxjjlhuDG-H-g3LPurty1M0,4164
 turbodesign/lossinterp.py,sha256=B2KEobp-nD9jwD6UINgBmTlH9kKyWg3UNvXxqfUsr-k,6198
 turbodesign/outlet.py,sha256=SwTwoL6XnWlsrE5A6wLxu3qXkydDDUsdKKeBbJm4mrQ,2069
-turbodesign/passage.py,sha256=a3DMc-QdlFEdjOEL1cockcTUFu_1iT1PSDrGo1qKN9s,9659
-turbodesign/radeq.py,sha256=RCsiQzcHvR5dozK6XG0eysAhXYewF0BY_qX0f1knURo,10091
+turbodesign/passage.py,sha256=63ScNtLXd6T8flIre6dLsdSzjeS17PvH1atZhHdarEU,10788
+turbodesign/radeq.py,sha256=gD-UYRuS1372GuxuOlhV13nEDqvFAVSf05fnZiF31Mo,10300
 turbodesign/rotor.py,sha256=tHl9o5H4aQ6Etd4gqa8Ime1UK7k0de4GLt5Yb1sJdGs,1376
-turbodesign/solve_radeq.py,sha256=2VGzFSVkyN0rTPFHaCQiD3v166cdEs39x7x7RuzLgmw,1886
-turbodesign/spool.py,sha256=h4m--HR5g8o01Kkhl4Mbvx7WORQez3YpncDE7XxbNaw,14172
+turbodesign/solve_radeq.py,sha256=CK8uuvhs5jv0v0G90aUjKz0f_SOU16whnJWEiFCeUUA,1971
+turbodesign/spool.py,sha256=kopByiu36urGuAfvDx9EI0DtMTt5leW3c2jUL3j4QhA,14216
 turbodesign/stage.py,sha256=UP45sDKDLsAkO_WfDWJ6kqXU7cYKh_4QO01QZnSN1oQ,166
-turbodesign/td_math.py,sha256=GjJdH9Mym1_vMSDT7lxilzSLVHBM5-Z5UE0wfsH2hr4,16153
-turbodesign/turbinespool.py,sha256=U_TMv5XNTlRWP9NJWTaaFWfNeTEGEuSVWt3HDi8QyFI,26124
-turbo_design-1.1.3.dist-info/METADATA,sha256=F1sI0aDeah1bWEhX57xeQTvt5aMMwHR9bkWyV7VFa-M,734
-turbo_design-1.1.3.dist-info/WHEEL,sha256=IYZQI976HJqqOpQU6PHkJ8fb3tMNBFjg-Cn-pwAbaFM,88
-turbo_design-1.1.3.dist-info/RECORD,,
+turbodesign/td_math.py,sha256=ZZmyCCAqha548bb5pkzqlhiGtvhtw8JO9qBAePNaleU,16098
+turbodesign/turbinespool.py,sha256=xRqUmwyzNP5Hm5V9iLj_hcq8gWXpS_6-V90ev9VFZ5g,26619
+turbo_design-1.2.1.dist-info/METADATA,sha256=ez_QBe7YfLBUE67nJZKrqVFpDnL-fDkB3dQ3Nxb_v_M,683
+turbo_design-1.2.1.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
+turbo_design-1.2.1.dist-info/RECORD,,

{turbo_design-1.1.3.dist-info → turbo_design-1.2.1.dist-info}/WHEEL

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

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]
@@ -437,7 +436,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):
         
@@ -463,10 +462,10 @@ class BladeRow:
             "Vx":self.Vx.tolist(),
             "Vr":self.Vr.tolist(),
             "Vt":self.Vt.tolist(),
+            "U":self.U.tolist(),
             "V":self.V.tolist(),
             "M":self.M.tolist(),
             "M_rel":self.M_rel.tolist(),
-            "U":self.U.tolist(),
             "W":self.W.tolist(),
             "Wt":self.Wt.tolist(),
             "omega":self.omega,
@@ -488,6 +487,10 @@ class BladeRow:
             "aspect_ratio":self.aspect_ratio,
             "num_blades":self.num_blades,
             "area": self.area,
+            "radius":self.r.tolist(),
+            "x":self.x.tolist(),
+            "dx":self.x[-1]-self.x[0],
+            "dr":self.r[-1]-self.r[0],
             "mprime":self.mprime[-1],
             "Reynolds":self.Reynolds,
             "axial_chord":self.axial_chord
@@ -605,21 +608,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 = row.fluid.cp
+        row.Cv = row.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

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
     

turbodesign/inlet.py

@@ -16,50 +16,78 @@ 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]],
+                 axial_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
             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
         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 
@@ -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]

turbodesign/passage.py

@@ -1,22 +1,22 @@
 from typing import List, Tuple
 import numpy as np
 import numpy.typing as npt
-from scipy.interpolate import interp1d
+from scipy.interpolate import PchipInterpolator
 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 
+from pyturbo.helper import convert_to_ndarray,xr_to_mprime
 import matplotlib.pyplot as plt 
 
 class Passage:
-    xhub:interp1d
-    rhub:interp1d
+    xhub:PchipInterpolator
+    rhub:PchipInterpolator
     xhub_pts:npt.NDArray
     rhub_pts:npt.NDArray
     
-    xshroud:interp1d
-    rshroud:interp1d
+    xshroud:PchipInterpolator
+    rshroud:PchipInterpolator
     xshroud_pts:npt.NDArray
     rshroud_pts:npt.NDArray
     
@@ -25,6 +25,7 @@ class Passage:
 
     x_streamlines:npt.NDArray
     r_streamlines:npt.NDArray
+    hub_arc_len:float 
     
     def __init__(self,xhub:List[float],rhub:List[float],
                  xshroud:List[float],rshroud:List[float],
@@ -41,12 +42,15 @@ class Passage:
         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"
 
+        hub_arc_len = xr_to_mprime(np.vstack([xhub,rhub]).transpose())[1]
+        self.hub_arc_len = hub_arc_len[-1]
+        
+        self.xhub = PchipInterpolator(hub_arc_len/hub_arc_len[-1],xhub)         # Get the xhub,rhub in terms of the hub arc len
+        self.rhub = PchipInterpolator(hub_arc_len/hub_arc_len[-1],rhub)
+        self.xshroud = PchipInterpolator(hub_arc_len/hub_arc_len[-1],xshroud)
+        self.rshroud = PchipInterpolator(hub_arc_len/hub_arc_len[-1],rshroud)
+        
         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)
@@ -137,6 +141,30 @@ class Passage:
         r = r_streamline
             
         return phi, rm, r
+    
+    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) -> line2D:
         """Gets the cutting line perpendicular to hub and shroud 
@@ -148,7 +176,7 @@ class Passage:
             (Tuple) containing:
         
                 cut (line2D): line from hub to shroud
-                t_hub (float): t corresponding to xhub location
+                t_hub (float): Percentage along hub arc length
                 t_shroud (float): t corresponding to intersection of bisector of hub 
                                 
         """
@@ -195,6 +223,7 @@ class Passage:
             np.NDArray: _description_
         """
         t_hub = np.linspace(axial_location[0],axial_location[1],100)
+        t_hub = convert_to_ndarray(t_hub)*self.hub_length
         
         shroud_pts_cyl = np.vstack([self.xshroud(t_hub),self.rshroud(t_hub)]).transpose()
         hub_pts_cyl = np.vstack([self.xhub(t_hub),self.rhub(t_hub)]).transpose()

turbodesign/radeq.py

@@ -79,7 +79,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 = 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
+        else:
+            dVm_dr = 1/(2*Vm*A) * (rho*(Vt/r - Vr*dVr_dr) - dP0_dr*B) + 1/(2*T0) *dT0_dr  # Eqn 6
         
         ydot = np.array([dP0_dr,dT0_dr,dVm_dr])
 

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

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
@@ -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
             
 
     @property
-    def fluid(self):
+    def fluid(self) -> Optional[Solution]:
         return self._fluid
 
     @fluid.setter
@@ -164,8 +163,9 @@ class Spool:
             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

turbodesign/td_math.py

@@ -6,6 +6,7 @@ from .bladerow import BladeRow, compute_gas_constants
 from .enums import RowType, LossType
 from scipy.integrate import trapezoid
 from .passage import Passage
+from .isentropic import IsenP
 
 def T0_coolant_weighted_average(row:BladeRow) -> float:
     """Calculate the new weighted Total Temperature array considering coolant
@@ -17,11 +18,12 @@ def T0_coolant_weighted_average(row:BladeRow) -> float:
     Returns:
         float: Total Temperature drop
     """
-    row.coolant.fluid.TP = row.coolant.T0, row.coolant.P0
+    
     massflow = row.massflow
     total_massflow_no_coolant = row.total_massflow_no_coolant
     Cp = row.Cp
-    Cpc = row.coolant.fluid.cp
+    
+    Cpc = row.coolant.Cp
     T0c = row.coolant.T0
     massflow_coolant = row.coolant.massflow_percentage*total_massflow_no_coolant*row.massflow[1:]/row.massflow[-1] 
     if massflow_coolant.mean()>0:
@@ -35,8 +37,9 @@ def T0_coolant_weighted_average(row:BladeRow) -> float:
         else:
             T0R = row.T0R
             T0R_new = T0R.copy()
+            Cp = row.Cp
             T0R_new[1:] = (massflow[1:]*Cp*T0R[1:] + massflow_coolant*Cpc*T0c) \
-                        /(massflow[1:]*row.fluid.cp + massflow_coolant*Cpc)
+                        /(massflow[1:]*Cp + massflow_coolant*Cpc)
             T0R_new[0] = T0R_new[1]
             
             T = T0R_new - row.W**2/(2*Cp)   # Dont change the velocity triangle but adjust the static temperature 
@@ -61,7 +64,7 @@ def compute_massflow(row:BladeRow) -> None:
     for j in range(1,len(row.percent_hub_shroud)):
         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
+        if np.abs((row.x[j]-row.x[j-1]))<1E-5: # 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]
         else:   # Radial Machines
@@ -77,6 +80,7 @@ def compute_massflow(row:BladeRow) -> None:
         massflow += massflow_fraction*row.coolant.massflow_percentage*row.total_massflow_no_coolant    # Take into account the coolant massflow
     row.massflow = massflow
     row.calculated_massflow = massflow[-1]
+    row.total_massflow = massflow[-1]
     row.area = total_area
 
 def compute_reynolds(rows:List[BladeRow],passage:Passage):
@@ -125,11 +129,14 @@ def compute_power(row:BladeRow,upstream:BladeRow) -> None:
         row.T_is = 0 
         row.T0_is = 0
     else:
-        row.T_is = row.T0R*(row.P/upstream.P0R)**((row.gamma-1)/row.gamma)
-        row.T0_is = row.T_is*(1+(row.gamma-1)/2*row.M**2)
+        P0_P = (upstream.P0/row.P).mean()
+        row.T_is = upstream.T0 * (1/P0_P)**((row.gamma-1)/row.gamma)
+        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.eta_static = row.power/ (row.massflow[-1]*row.Cp*(upstream.T0.mean()-row.T0_is.mean()))
-        row.eta_total = row.power / (row.massflow[-1]*row.Cp * (upstream.T0.mean()-row.T0_is.mean()))
+        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
         row.euler_power = row.massflow[-1]* (upstream.U*upstream.Vt - row.U*row.Vt).mean()
     
@@ -150,7 +157,7 @@ def compute_quantities(row:BladeRow,upstream:BladeRow):
     if row.row_type == RowType.Rotor:
         Cp_avg = (row.Cp+upstream.Cp)/2
         # Factor any coolant added and changes in streamline radius
-        row.T0R = upstream.T0R - T0_coolant_weighted_average(row) - (upstream.U**2-row.U**2)/(2*Cp_avg) 
+        row.T0R = upstream.T0R - T0_coolant_weighted_average(row) # - (upstream.U**2-row.U**2)/(2*Cp_avg) 
         row.P = upstream.P0_stator_inlet/row.P0_P
         
         if row.loss_function.loss_type == LossType.Pressure: 
@@ -232,13 +239,13 @@ def stator_calc(row:BladeRow,upstream:BladeRow,downstream:BladeRow=None,calculat
     if calculate_vm:
         row.M = ((row.P0/row.P)**((row.gamma-1)/row.gamma) - 1) * 2/(row.gamma-1)
         row.M = np.sqrt(row.M)
-        T0_T = (1+(row.gamma-1)/2 * row.M.mean()**2)
+        T0_T = (1+(row.gamma-1)/2 * row.M**2)
         row.T0 = upstream.T0 - T0_coolant_weighted_average(row)
         row.T = row.T0/T0_T
         row.V = row.M*np.sqrt(row.gamma*row.R*row.T)
+        row.Vm = row.V*np.cos(row.alpha2)
         row.Vx = row.Vm*np.cos(row.phi)
-        row.Vr = row.V*np.sin(row.phi)
-        row.Vm = np.sqrt(row.Vx**2+row.Vr**2)
+        row.Vr = row.Vm*np.sin(row.phi)
         row.Vt = row.Vm*np.tan(row.alpha2)
     else: # We know Vm, P0, T0, P
         row.Vx = row.Vm*np.cos(row.phi)
@@ -289,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 - T0_coolant_weighted_average(row) # (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
@@ -297,7 +304,7 @@ def rotor_calc(row:BladeRow,upstream:BladeRow,calculate_vm:bool=True):
         row.W = np.sqrt(2*row.Cp*(row.T0R-row.T)) #! nan popups here a lot for radial machines 
         if np.isnan(np.sum(row.W)):
             # Need to adjust T
-            print(f'nan detected: check flow path. Turbine inlet cut should be horizontal')
+            raise ValueError(f'nan detected: check flow path. Turbine inlet cut should be horizontal')
         row.Vr = row.W*np.sin(row.phi)
         row.Vm = row.W*np.cos(row.beta2)
         row.Wt = row.W*np.sin(row.beta2)
@@ -327,11 +334,6 @@ def rotor_calc(row:BladeRow,upstream:BladeRow,calculate_vm:bool=True):
     
     row.M_rel = row.W/np.sqrt(row.gamma*row.R*row.T)
     row.T0 = row.T+row.V**2/(2*row.Cp)
-    
-    T3_is = upstream.T0 * (1/row.P0_P)**((row.gamma-1)/row.gamma)
-    a = np.sqrt(row.gamma*row.R*T3_is)
-    T03_is = T3_is * (1+(row.gamma-1)/2*(row.V/a)**2)
-    row.eta_total = (upstream.T0.mean() - row.T0.mean())/(upstream.T0.mean()-T03_is.mean())
 
 def inlet_calc(row:BladeRow):
     """Calculates the conditions for the Inlet 
@@ -339,12 +341,13 @@ def inlet_calc(row:BladeRow):
     Args:
         row (BladeRow): _description_
     """
+    
     area = row.Vm.copy()*0
     # Estimate the density
     row.T = row.T0
-    row.P = row.P0 
+    row.P = row.P0
     row.rho = row.P/(row.T*row.R)
-    total_area = 0 
+    total_area = 0
     for iter in range(5): # Lets converge the Mach and Total and Static pressures
         for j in range(1,len(row.percent_hub_shroud)):
             rho = row.rho[j]
@@ -361,9 +364,9 @@ def inlet_calc(row:BladeRow):
                 row.Vm[j] = tube_massflow/(rho*area[j])
         avg_mach = np.mean(row.M)
         if np.mean(row.M)>0.5:
-            print(f"High inlet mach can lead to errors iter:{iter} Mach:{avg_mach}")
+            raise ValueError(f"High inlet mach can lead to errors iter:{iter} Mach:{avg_mach}")
         if np.mean(row.M)<0.01:
-            print(f"Unusually slow flow:{iter} Mach:{avg_mach}")
+            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)

turbodesign/turbinespool.py

@@ -10,17 +10,18 @@ import numpy as np
 import numpy.typing as npt
 from .td_math import inlet_calc,rotor_calc, stator_calc, compute_massflow, compute_power, compute_gas_constants, compute_reynolds
 from .solve_radeq import adjust_streamlines, radeq
-from scipy.optimize import minimize_scalar, minimize, fmin_slsqp
+from scipy.optimize import minimize_scalar, differential_evolution, fmin_slsqp
 from .inlet import Inlet
 from .outlet import Outlet
 
 class TurbineSpool(Spool):
+    
     def __init__(self,passage:Passage,
                  massflow:float,rows:List[BladeRow],
                  num_streamlines:int=3,
                  fluid:Solution=Solution('air.yaml'),
                  rpm:float=-1,
-                massflow_constraint:MassflowConstraint=MassflowConstraint.MatchMassFlow):
+                 massflow_constraint:MassflowConstraint=MassflowConstraint.MatchMassFlow):
         """Initializes a Turbine Spool
 
         Args:
@@ -45,21 +46,22 @@ class TurbineSpool(Spool):
         # Inlet
         W0 = self.massflow
         inlet = self.blade_rows[0]
-        if self.blade_rows[0].row_type == RowType.Inlet:
-            self.blade_rows[0].massflow = np.linspace(0,1,self.num_streamlines)*W0
-            self.blade_rows[0].total_massflow = W0 
-            self.blade_rows[0].total_massflow_no_coolant = W0 
+        if self.fluid:
+            inlet.initialize_fluid(self.fluid)
+        else:
+            inlet.initialize_fluid(R=self.blade_rows[1].R,
+                                    gamma=self.blade_rows[1].gamma,
+                                    Cp=self.blade_rows[1].Cp)
+        
+            inlet.total_massflow = W0 
+            inlet.total_massflow_no_coolant = W0
+            inlet.massflow = np.linspace(0,1,self.num_streamlines)*W0
             
-            interpolate_streamline_radii(self.blade_rows[0],self.passage,self.num_streamlines)
+            inlet.initialize_velocity(self.passage,self.num_streamlines)    
+            interpolate_streamline_radii(inlet,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()
-            self.blade_rows[0].Cp = self.blade_rows[0].fluid.cp
-            self.blade_rows[0].Cv = self.blade_rows[0].fluid.cv
-            self.blade_rows[0].R = self.blade_rows[0].Cp-self.blade_rows[0].Cv
-            self.blade_rows[0].gamma = self.blade_rows[0].Cp/self.blade_rows[0].Cv
-            self.blade_rows[0].rho[:] = self.blade_rows[0].fluid.density
-            inlet_calc(self.blade_rows[0])
+            compute_gas_constants(inlet,self.fluid)
+            inlet_calc(inlet)
         
         for row in self.blade_rows:
             interpolate_streamline_radii(row,self.passage,self.num_streamlines)
@@ -83,10 +85,10 @@ class TurbineSpool(Spool):
             
             row = self.blade_rows[i]
             if (row.coolant is not None):
-                T0c = self.blade_rows[i].coolant.fluid.T
-                P0c = self.blade_rows[i].coolant.fluid.P
+                T0c = self.blade_rows[i].coolant.T0
+                P0c = self.blade_rows[i].coolant.P0
                 W0c = self.blade_rows[i].coolant.massflow_percentage * self.massflow
-                Cpc = self.blade_rows[i].coolant.fluid.cp
+                Cpc = self.blade_rows[i].coolant.Cp
             else:
                 T0c = 100
                 P0c = 0
@@ -133,9 +135,9 @@ class TurbineSpool(Spool):
         self.initialize_quantities()
         
         if self.massflow_constraint ==MassflowConstraint.MatchMassFlow:
-            self.__match_massflow()
+            self.__match_massflow()  # Matches massflow by changing turning angle
         elif self.massflow_constraint == MassflowConstraint.BalanceMassFlow:
-            self.__balance_massflow()
+            self.__balance_massflow()   # Balances massflow by changing row exit static pressure
 
     
     def __match_massflow(self):
@@ -169,8 +171,8 @@ class TurbineSpool(Spool):
                         elif row.row_type == RowType.Stator:
                             row.alpha2[j] = np.radians(res.x)
                             row.alpha2[0] = 1/(len(row.alpha2)-1)*row.alpha2[1:].sum()
-                    upstream = compute_gas_constants(upstream)
-                    row = compute_gas_constants(row)
+                    compute_gas_constants(upstream,self.fluid)
+                    compute_gas_constants(row,self.fluid)
                 
                     
             # Step 3: Adjust streamlines to evenly divide massflow
@@ -198,7 +200,7 @@ class TurbineSpool(Spool):
             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)
-                    
+                
                 sign = 1
                 for s in stage_ids:
                     for row in blade_rows:
@@ -232,9 +234,10 @@ class TurbineSpool(Spool):
             Returns:
                 _type_: _description_
             """
+            blade_rows_backup = copy.deepcopy(blade_rows)
             # try:
             if balance_mean_pressure:
-                for j in range(self.num_streamlines):                
+                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]
@@ -243,10 +246,14 @@ class TurbineSpool(Spool):
                 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)
+            try:  
+                calculate_massflows(blade_rows,True)
+                print(x0)
+                return calculate_error(blade_rows)
+            except:
+                blade_rows = blade_rows_backup
+                return np.inf # Return a high error
+            
             # except:
             #     for i in range(1,len(blade_rows)-1):
             #         for j in range(self.num_streamlines):
@@ -262,9 +269,10 @@ class TurbineSpool(Spool):
         
         print('Find average P in between stages')
         if len(outlet_P) == 1:
-            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 = balance_massflows(0.658,self.blade_rows[:-1],self.blade_rows[0].P0,self.blade_rows[-1].P)
+            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},method='bounded')
             x = res.x
+            print(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})
@@ -272,6 +280,8 @@ class TurbineSpool(Spool):
         
         # 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
+        self.blade_rows[0].total_massflow_no_coolant = self.blade_rows[1].total_massflow_no_coolant
+        self.blade_rows[0].total_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 
         
         if self.adjust_streamlines:
@@ -389,7 +399,7 @@ class TurbineSpool(Spool):
             json.dump(data, f, indent=4,cls=NumpyEncoder)
 
 
-def calculate_massflows(blade_rows:List[BladeRow],calculate_vm:bool=False):
+def calculate_massflows(blade_rows:List[BladeRow],calculate_vm:bool=False,fluid:Solution=None):
     """Calculates the massflow 
 
     Args:
@@ -421,15 +431,15 @@ def calculate_massflows(blade_rows:List[BladeRow],calculate_vm:bool=False):
                             rotor_calc(row,upstream,calculate_vm=True)
                             # Finds Equilibrium between Vm, P0, T0
                             row = radeq(row,upstream) 
-                            row = compute_gas_constants(row)
+                            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)
-                            row = compute_gas_constants(row)
+                            compute_gas_constants(row,fluid)
                             stator_calc(row,upstream,downstream,calculate_vm=False)
-                        row = compute_gas_constants(row)
+                        compute_gas_constants(row,fluid)
                         compute_massflow(row)
                         compute_power(row,upstream)
                         
@@ -442,7 +452,7 @@ def calculate_massflows(blade_rows:List[BladeRow],calculate_vm:bool=False):
                             row.Yp = Yp
                             rotor_calc(row,upstream,calculate_vm=True)
                             row = radeq(row,upstream)
-                            row = compute_gas_constants(row)
+                            compute_gas_constants(row,fluid)
                             rotor_calc(row,upstream,calculate_vm=False)
                             return abs(row.eta_total - eta_total)
                         
@@ -452,13 +462,13 @@ def calculate_massflows(blade_rows:List[BladeRow],calculate_vm:bool=False):
                         row.Yp = 0
                         stator_calc(row,upstream,downstream,calculate_vm=True)
                         row = radeq(row,upstream) 
-                        row = compute_gas_constants(row)
+                        row = compute_gas_constants(row,fluid)
                         stator_calc(row,upstream,downstream,calculate_vm=False)
-                    row = compute_gas_constants(row)
+                    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):
+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 
 
     Args:
@@ -483,8 +493,8 @@ def massflow_loss_function(exit_angle:float,index:int,row:BladeRow,upstream:Blad
             elif row.row_type == RowType.Stator:
                 row.alpha2[index] = np.radians(exit_angle)
                 stator_calc(row,upstream,downstream)
-            upstream = compute_gas_constants(upstream)
-            row = compute_gas_constants(row)
+            upstream = compute_gas_constants(upstream,fluid)
+            row = compute_gas_constants(row,fluid)
         elif row.loss_function.loss_type == LossType.Enthalpy:
             # Search for pressure loss that results in the correct total temperature drop
             if row.row_type == RowType.Rotor:
@@ -496,8 +506,8 @@ def massflow_loss_function(exit_angle:float,index:int,row:BladeRow,upstream:Blad
                 def find_yp(Yp):
                     row.Yp = Yp
                     rotor_calc(row,upstream)
-                    upstream = compute_gas_constants(upstream)
-                    row = compute_gas_constants(row)
+                    upstream = compute_gas_constants(upstream,fluid)
+                    row = compute_gas_constants(row,fluid)
                     return abs(row.T0.mean() - T0_target)
                 res = minimize_scalar(find_yp,bounds=[0,0.6])
                 row.Yp = res.x
@@ -505,8 +515,8 @@ def massflow_loss_function(exit_angle:float,index:int,row:BladeRow,upstream:Blad
                 row.Yp = 0
                 row.alpha2[index] = np.radians(exit_angle)
                 stator_calc(row,upstream,downstream)
-                upstream = compute_gas_constants(upstream)
-                row = compute_gas_constants(row)
+                upstream = compute_gas_constants(upstream,fluid)
+                row = compute_gas_constants(row,fluid)
         
 
     # if use_radeq:
@@ -516,12 +526,12 @@ def massflow_loss_function(exit_angle:float,index:int,row:BladeRow,upstream:Blad
     compute_power(row,upstream)
     
     if row.row_type!=RowType.Inlet:
-        if row.row_type == RowType.Rotor:
-            T3_is = upstream.T0 * (1/row.P0_P)**((row.gamma-1)/row.gamma)
-        else:
-            T3_is = upstream.T0 * (row.P0/row.P)**((row.gamma-1)/row.gamma)
+        # if row.row_type == RowType.Rotor:
+        T3_is = upstream.T0 * (1/row.P0_P)**((row.gamma-1)/row.gamma)
+        # else:
+        #     T3_is = upstream.T0 * (row.P0/row.P)**((row.gamma-1)/row.gamma)
         a = np.sqrt(row.gamma*row.R*T3_is)
-        T03_is = T3_is * (1+(row.gamma-1)/2*(row.Vm/a)**2)
+        T03_is = T3_is * (1+(row.gamma-1)/2*(row.V/a)**2)
         row.eta_total = (upstream.T0.mean() - row.T0.mean())/(upstream.T0.mean()-T03_is.mean())
         
     return np.abs(row.total_massflow*index/(len(row.massflow)-1) - row.massflow[index])