turbo-design 1.3.5__tar.gz → 1.3.7__tar.gz

{turbo_design-1.3.5 → turbo_design-1.3.7}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: turbo-design
-Version: 1.3.5
+Version: 1.3.7
 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,8 @@ 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
+Classifier: Programming Language :: Python :: 3.14
 Requires-Dist: cantera
 Requires-Dist: findiff
 Requires-Dist: matplotlib

{turbo_design-1.3.5 → turbo_design-1.3.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "turbo-design"
-version = "1.3.5"
+version = "1.3.7"
 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.5 → turbo_design-1.3.7}/turbodesign/bladerow.py

@@ -1,5 +1,5 @@
 from dataclasses import field, Field
-from typing import Any, Callable, List, Optional, Tuple, Union
+from typing import Any, Callable, List, Optional, Sequence, Tuple, Union
 from .enums import RowType, PowerType
 import numpy as np 
 import numpy.typing as npt
@@ -9,7 +9,7 @@ from cantera import Solution, composite
 from .coolant import Coolant
 from pyturbo.helper import line2D
 from pyturbo.aero.airfoil2D import Airfoil2D
-from .loss import LossBaseClass
+from .loss import LossBaseClass, CompositeLossModel
 from .passage import Passage
     
 
@@ -406,19 +406,25 @@ class BladeRow:
         return self.loss_function
     
     @loss_model.setter
-    def loss_model(self, model:Callable[[Any], Any]):
-        """Add in custom loss model
+    def loss_model(self, model:Union[LossBaseClass, Sequence[LossBaseClass]]):
+        """Assign one or more loss models that inherit :class:`LossBaseClass`.
 
         Args:
-            model (function): custom loss function. Input will be of the format blade row
-
-        Example:
-        
-        def mylossfunction(row:BladeRow) -> float
-            code to do something with machine learning
-            return pressure loss
+            model: Either a single loss model or a sequence of models.
         """
-        self.loss_function = model # type: ignore
+        if isinstance(model, LossBaseClass):
+            self.loss_function = model
+            return
+
+        if isinstance(model, Sequence):
+            if len(model) == 0:
+                raise ValueError("At least one loss model must be provided.")
+            if not all(isinstance(m, LossBaseClass) for m in model):
+                raise TypeError("All entries must inherit LossBaseClass.")
+            self.loss_function = CompositeLossModel(model)
+            return
+
+        raise TypeError("Loss models must inherit LossBaseClass.")
     
     @property
     def te_pitch(self):
@@ -631,4 +637,4 @@ def compute_gas_constants(row:BladeRow,fluid:Optional[Solution]=None) -> None:
         row.gamma = row.Cp/row.Cv
     # Use Ideal Gas 
     row.rho = row.P/(row.T*row.R)
-    row.mu = sutherland(row.T) # type: ignore
+    row.mu = sutherland(row.T) # type: ignore

turbo_design-1.3.7/turbodesign/loss/__init__.py

@@ -0,0 +1 @@
+from .losstype import LossType, LossBaseClass, CompositeLossModel

turbo_design-1.3.7/turbodesign/loss/losstype.py

@@ -0,0 +1,55 @@
+from abc import ABC, abstractmethod
+from typing import Any, Dict, Iterable, Tuple
+from ..lossinterp import LossInterp
+import os 
+from ..enums import LossType
+
+class LossBaseClass(ABC):  
+    data: Dict[str,LossInterp]
+    _loss_type:LossType
+    
+    def __init__(self,lossType:LossType):
+        # Make the environment directory 
+        default_home = os.path.join(os.path.expanduser("~"), ".cache")
+        os.environ['TD3_HOME'] = os.path.join(default_home,'TD3_LossModels')
+        os.makedirs(os.environ['TD3_HOME'],exist_ok=True)
+        
+        self._loss_type = lossType
+
+    @abstractmethod
+    def __call__(self, row:Any, upstream:Any) -> float:
+        """Evaluate the loss for the supplied blade row."""
+        raise NotImplementedError
+
+    
+    
+    @property
+    def loss_type(self):
+        return self._loss_type
+
+
+class CompositeLossModel(LossBaseClass):
+    """Combines multiple loss models of the same type."""
+
+    def __init__(self, models: Iterable[LossBaseClass]):
+        models_tuple: Tuple[LossBaseClass, ...] = tuple(models)
+        if not models_tuple:
+            raise ValueError("CompositeLossModel requires at least one loss model.")
+
+        loss_type = models_tuple[0].loss_type
+        for model in models_tuple[1:]:
+            if model.loss_type != loss_type:
+                raise ValueError("All loss models must share the same LossType.")
+
+        super().__init__(loss_type)
+        self._models: Tuple[LossBaseClass, ...] = models_tuple
+
+    def __call__(self, row: Any, upstream: Any) -> float:
+        total_loss = 0.0
+        for model in self._models:
+            total_loss += float(model(row, upstream))
+        return total_loss
+
+    @property
+    def models(self) -> Tuple[LossBaseClass, ...]:
+        return self._models

{turbo_design-1.3.5 → turbo_design-1.3.7}/turbodesign/loss/turbine/ainleymathieson.py

@@ -69,7 +69,7 @@ class AinleyMathieson(LossBaseClass):
             beta1 = -np.abs(np.radians(row.beta1_metal))
             alpha2 = np.abs(row.alpha2)
             if row.M<0.5:
-                alpha2 = self.data['Fig05'](np.degrees(np.cos(row.throat/row.pitch)))
+                alpha2 = self.data['Fig05'](float(np.degrees(np.cos(row.throat/row.pitch))))
             elif row.M<0.95:
                 X = 0.7
                 alpha2 = np.arctan( 
@@ -88,7 +88,7 @@ class AinleyMathieson(LossBaseClass):
             beta1 = np.abs(np.radians(row.beta1_metal))
             alpha2 = -np.abs(row.beta2)
             if row.M_rel<0.5:
-                alpha2 = self.data['Fig05'](np.degrees(np.cos(row.throat/row.pitch)))
+                alpha2 = self.data['Fig05'](float(np.degrees(np.cos(row.throat/row.pitch))))
             elif row.M_rel<0.95:
                 X = 1.35 # Shrouded Blade
                 alpha2 = np.arctan( 
@@ -106,18 +106,18 @@ class AinleyMathieson(LossBaseClass):
         ID = (upstream.r[-1]+row.r[-1])/2; OD = (upstream.r[-1]+row.r[-1])/2
         A1 = np.pi*(upstream.r[-1]**2 - upstream.r[0]**2)*np.cos(beta1)
         A2 = np.pi*(row.r[-1]**2 - row.r[0]**2)*np.cos(alpha2)
-        lam = self.data['Fig08']((A2/A1)**2/(1+ID/OD)) # Eqn but using Figure 8
+        lam = self.data['Fig08'](float((A2/A1)**2/(1+ID/OD))) # Eqn but using Figure 8
         alpha_m = np.arctan((np.tan(alpha1) - np.tan(alpha2))/2)
         Cl_s_c = 2*(np.tan(alpha1)-np.tan(alpha2))*np.cos(alpha_m)
         # calculated but not used 
         Y_secondary_clearance = (lam + B * k/h) * (Cl_s_c)**2 * (np.cos(alpha2)/np.cos(alpha_m)) # Eqn 6
         
         
-        Yp_beta0 = self.data['Fig04a'](s_c, np.degrees(alpha2))
-        Yp_beta1_eq_alpha2 = self.data['Fig04b'](s_c, np.degrees(alpha2))
+        Yp_beta0 = self.data['Fig04a'](float(s_c), float(np.degrees(alpha2)))
+        Yp_beta1_eq_alpha2 = self.data['Fig04b'](float(s_c), float(np.degrees(alpha2)))
         
         Yp_i0 = (Yp_beta0 + (beta1/alpha2)**2 *(Yp_beta1_eq_alpha2 - Yp_beta0)) *(t_c/0.2)**(-beta1/alpha2) # Fig 4 and Eqn 5
         
         Yt = Yp_i0 + Y_secondary_clearance 
         return Yt   # Profile loss at zero incidence 
-        
+        

{turbo_design-1.3.5 → turbo_design-1.3.7}/turbodesign/loss/turbine/craigcox.py

@@ -116,58 +116,58 @@ class CraigCox(LossBaseClass):
             
             asin_os = np.degrees(np.arcsin(currentRow.throat/currentRow.pitch))
             
-            N_pr = self.data['Fig03'](Re,0.05) # use a good finish for the geometry
+            N_pr = self.data['Fig03'](float(Re), 0.05) # use a good finish for the geometry
             if (inlet_flow_angle-imin < 10):
                 Fl = 13
             else:
-                Fl = self.data['Fig04'](outlet_flow_angle,inlet_flow_angle-imin)
+                Fl = self.data['Fig04'](float(outlet_flow_angle), float(inlet_flow_angle-imin))
             
             x = 1-np.sin(np.radians(outlet_flow_angle))/np.sin(np.radians(inlet_flow_angle))
-            contraction_ratio = self.data['Fig07'](x,s_b) # contraction ratio
+            contraction_ratio = self.data['Fig07'](float(x), float(s_b)) # contraction ratio
 
-            X_pb = self.data['Fig05'](Fl*s_b,contraction_ratio)
-            delta_X_pt = self.data['Fig06_delta_Xpt'](currentRow.te_pitch)
-            N_pt = self.data['Fig06_Npt'](currentRow.te_pitch,outlet_flow_angle)
-            delta_Xpm = self.data['Fig08'](M_out,np.degrees(np.arcsin((currentRow.throat+te)/currentRow.pitch)))
-            delta_Xp_se = self.data['Fig09'](e_s,M_out) 
+            X_pb = self.data['Fig05'](float(Fl*s_b), float(contraction_ratio))
+            delta_X_pt = self.data['Fig06_delta_Xpt'](float(currentRow.te_pitch))
+            N_pt = self.data['Fig06_Npt'](float(currentRow.te_pitch), float(outlet_flow_angle))
+            delta_Xpm = self.data['Fig08'](float(M_out), float(np.degrees(np.arcsin((currentRow.throat+te)/currentRow.pitch))))
+            delta_Xp_se = self.data['Fig09'](float(e_s), float(M_out)) 
             
-            Fi = self.data['Fig15'](blade_inlet_angle,s_b)
+            Fi = self.data['Fig15'](float(blade_inlet_angle), float(s_b))
             # Incidence Effects 
             if currentRow.beta1_fixed:
                 if incidence_angle>0: # Positive incidence
-                    stall_incidence_angle = self.data['Fig11'](currentRow.beta1.mean(),asin_os)
+                    stall_incidence_angle = self.data['Fig11'](float(currentRow.beta1.mean()), float(asin_os))
                     
                     incidence_ratio = (incidence_angle - imin)/(stall_incidence_angle-imin)
 
-                    i_plus_istall_sb = self.data['Fig12_sb'](s_b,asin_os)
-                    i_plus_istall_cor = self.data['Fig12_cr'](contraction_ratio,asin_os)
+                    i_plus_istall_sb = self.data['Fig12_sb'](float(s_b), float(asin_os))
+                    i_plus_istall_cor = self.data['Fig12_cr'](float(contraction_ratio), float(asin_os))
                     
                     if blade_inlet_angle<=90:
-                        i_plus_istall_basic = self.data['Fig11'](inlet_flow_angle,asin_os)
+                        i_plus_istall_basic = self.data['Fig11'](float(inlet_flow_angle), float(asin_os))
                         i_plus_istall = i_plus_istall_basic + i_plus_istall_sb + i_plus_istall_cor # Eqn 5 
                     else:
-                        i_plus_istall_basic = self.data["Fig14_i+istall"](blade_inlet_angle,asin_os)
+                        i_plus_istall_basic = self.data["Fig14_i+istall"](float(blade_inlet_angle), float(asin_os))
                         i_plus_istall = i_plus_istall_basic + (1-(blade_inlet_angle-90)/(90-asin_os))*(i_plus_istall_sb + i_plus_istall_cor) # Eqn 7 
                 else:
-                    i_minus_istall_sb = self.data['Fig13'](s_b,asin_os)
+                    i_minus_istall_sb = self.data['Fig13'](float(s_b), float(asin_os))
 
                     if blade_inlet_angle<=90: 
-                        i_minus_istall_basic = self.data['Fig13_alpha1'](s_b,asin_os)
+                        i_minus_istall_basic = self.data['Fig13_alpha1'](float(s_b), float(asin_os))
                         i_minus_istall = i_minus_istall_basic + i_minus_istall_sb # Eqn 6
                     else:
-                        i_minus_istall_basic = self.data["Fig14_i-istall"](blade_inlet_angle,asin_os)
+                        i_minus_istall_basic = self.data["Fig14_i-istall"](float(blade_inlet_angle), float(asin_os))
                         i_minus_istall = i_minus_istall_basic + (1-(blade_inlet_angle - 90)/(90-asin_os)) * i_minus_istall_sb   # Eqn 8 
                         
                 imin = (i_plus_istall + Fi * (i_minus_istall))/(1+Fi) # type: ignore # Eqn 9
-                N_pi = self.data['Fig10'](imin,incidence_ratio)
+                N_pi = self.data['Fig10'](float(imin), float(incidence_ratio))
             else:
                 N_pi = 1 # No effect
             
             Xp = X_pb*N_pr*N_pi*N_pt + delta_X_pt + delta_Xp_se + delta_Xpm # Eqn 10
             
             # Secondary Loss 
-            Ns_hb = self.data['Fig17'](1/currentRow.aspect_ratio)
-            x_sb = self.data['Fig18']((V_inlet/V)**2,s_b*Fl)
+            Ns_hb = self.data['Fig17'](float(1/currentRow.aspect_ratio))
+            x_sb = self.data['Fig18'](float((V_inlet/V)**2), float(s_b*Fl))
                 
             Nsr = 1 # N_pr # I have no clue about this. Craig Cox doesn't describe. setting it to 1 for now.
             Xs = Nsr*Ns_hb*x_sb 
@@ -192,4 +192,4 @@ class CraigCox(LossBaseClass):
         # According to Equation 3, Group 1 loss is an enthalpy loss Cp*T0. Need to convert to Pressure Loss
         eta_total = (upstream.T0.mean() - row.T0.mean())/(upstream.T0.mean()-(row.T0.mean()-T0_Loss))
         return eta_total
-        
+        

turbo_design-1.3.7/turbodesign/loss/turbine/kackerokapuu.py

@@ -0,0 +1,166 @@
+import pickle, os
+from typing import Dict
+from ...bladerow import BladeRow, sutherland
+from ...lossinterp import LossInterp
+from ...enums import RowType, LossType
+import numpy as np
+import pathlib
+from ..losstype import LossBaseClass
+import requests
+
+
+def _mean_value(value):
+    """Return the mean of an array-like as a Python float."""
+    return float(np.asarray(value).mean())
+
+class KackerOkapuu(LossBaseClass):
+    UseCFM:bool = False
+    def __init__(self,UseCFM:bool=False):
+        """KackerOkapuu model is an improvement to the Ainley Mathieson model. 
+        
+        Limitations:
+            - Doesn't factor incidence loss 
+            - For steam turbines and impulse turbines
+        
+        Args:
+            UseCFM (bool): Factor in supersonic drag rise. Authors state in AMDC loss that this is not accurate. It's a multplier to pressure loss. 
+            
+        Reference:
+            Kacker, S. C., and U. Okapuu. "A mean line prediction method for axial flow turbine efficiency." (1982): 111-119.
+            
+        """
+        super().__init__(LossType.Pressure)
+        path = pathlib.Path(os.path.join(os.environ['TD3_HOME'],"kackerokapuu"+".pkl"))
+        
+        if not path.exists():
+            url = "https://github.com/nasa/turbo-design/raw/main/references/Turbines/KackerOkapuu/kackerokapuu.pkl"
+            response = requests.get(url, stream=True)
+            with open(path.absolute(), mode="wb") as file:
+                for chunk in response.iter_content(chunk_size=10 * 1024):
+                    file.write(chunk)
+        
+        with open(path.absolute(),'rb') as f:
+            self.data = pickle.load(f) # type: ignore
+        self.UseCFM = UseCFM
+        
+    
+    def __call__(self,row:BladeRow, upstream:BladeRow) -> float:
+        """Kacker Okapuu is an updated version of Ainley Mathieson and Dunham Came. This tool uses the pressure loss definition. 
+
+        Note: 
+            All equation numbers are from the Kacker Okapuu paper
+        
+        Reference:
+            Kacker, S. C., and U. Okapuu. "A mean line prediction method for axial flow turbine efficiency." (1982): 111-119.
+        
+        Args:
+            upstream (BladeRow): Upstream blade row
+            row (BladeRow): downstream blade row
+
+        Returns:
+            float: Pressure Loss 
+        """
+        # Get the Inlet incoming mach number relative to the blade
+        c = row.chord
+        b = row.axial_chord
+        if row.row_type == RowType.Stator:
+            beta1_rad = np.abs(_mean_value(np.radians(row.beta1_metal))) # Metal angle from fig 3
+            alpha1_rad = np.abs(_mean_value(row.alpha1)) # Flow angle
+            alpha2_rad = np.abs(_mean_value(row.alpha2)) # Flow angle at exit which is metal angle
+            beta2_rad = alpha2_rad                  
+            alpham_rad = (alpha1_rad + alpha2_rad)*0.5
+            M1 = _mean_value(upstream.M)
+            M2 = _mean_value(row.M)
+            h = 0
+            Rec = _mean_value(row.V*row.rho*row.chord / sutherland(row.T))
+            
+            beta1_deg = np.abs(np.degrees(beta1_rad))
+            alpha2_deg = np.abs(np.degrees(alpha2_rad))
+            Yp_beta0 = self.data['Fig01_beta0'](float(row.pitch_to_chord), alpha2_deg)  # when beta1 = 0 
+            Yp_beta1_alpha2 = self.data['Fig02'](float(row.pitch_to_chord), alpha2_deg) # When beta1 = alpha2
+            t_max_c = self.data['Fig04'](beta1_deg+alpha2_deg)
+        else:
+            h = row.tip_clearance * (row.r[-1]-row.r[0])
+            alpha1_rad = np.abs(_mean_value(row.beta1))
+            beta1_rad = np.abs(_mean_value(np.radians(row.beta1_metal))) # metal angles are stored as degrees 
+            beta2_rad = np.abs(_mean_value(np.radians(row.beta2_metal)))
+            alpha2_rad = np.abs(_mean_value(row.beta2))
+            alpham_rad = (beta1_rad + beta2_rad)*0.5
+            M1 = _mean_value(upstream.M_rel) 
+            M2 = _mean_value(row.M_rel)
+            Rec = _mean_value(row.W*row.rho*row.chord / sutherland(row.T))
+
+            beta1_deg = np.abs(np.degrees(beta1_rad))
+            alpha2_deg = np.abs(np.degrees(beta2_rad))
+            Yp_beta0 = self.data['Fig01_beta0'](float(row.pitch_to_chord), alpha2_deg)  # when beta1 = 0 
+            Yp_beta1_alpha2 = self.data['Fig02'](float(row.pitch_to_chord), alpha2_deg) # When beta1 = alpha2
+            t_max_c = self.data['Fig04'](beta1_deg+alpha2_deg)
+        
+        ratio = beta1_rad / alpha2_rad
+        Yp_amdc = (Yp_beta0 + np.abs(ratio) * ratio * (Yp_beta1_alpha2-Yp_beta0)) * ((t_max_c)/0.2)**(ratio) # Eqn 2, AMDC = Ainley Mathieson Dunham Came
+        
+        # Shock Loss
+        if M1>=0.4: # You'll have imaginary numbers if M1<0.4
+            dP_q1_hub = 0.75*(M1-0.4)**1.75 # Eqn 4, this is at the hub
+            dP_q1_shock = row.r[-1]/row.r[0] * dP_q1_hub # Eqn 5
+            Y_shock = dP_q1_shock * upstream.P/row.P * (1-(1+(upstream.gamma-1)/2*M1**2))/(1-(1+(row.gamma-1)/2*M2**2)) # Eqn 6
+            Y_shock = _mean_value(Y_shock)
+        else:
+            Y_shock = 0
+        
+        if M2 <= 0.2:
+            K1 = 1
+        else:
+            K1 = 1-1.25*(M2-0.2)
+        K2 = (M1/M2)**2 
+        Kp = 1-K2*(1-K1)
+        
+        if (M2>1) and (self.UseCFM is True):
+            CFM = 1+60*(M2-1)**2    # Eqn 9 
+        else:
+            CFM = 1
+        
+        Yp = 0.914 * (2/3*Yp_amdc*Kp + Y_shock) # Eqn 8 Subsonic regime 
+        if M2>1:
+            Yp = Yp*CFM
+        
+        f_ar = (1-0.25*np.sqrt(2-h/c)) / (h/c) if h/c<=2 else 1/(h/c)
+        alpham = np.arctan(0.5*(np.tan(alpha1_rad) - np.tan(alpha2_rad)))
+        Cl_sc = 2*(np.tan(alpha1_rad)+np.tan(alpha2_rad))*np.cos(alpham)
+        Ys_amdc = 0.0334 *f_ar *np.cos(alpha2_rad)/np.cos(beta1_rad) * (Cl_sc)**2 * np.cos(alpha2_rad)**2 / np.cos(alpham)**3
+        # Secondary Loss
+        if h>0: # h is calculated from tip clearance. When h is 0 there is no tip clearance  
+            K3 = 1/(h/(b))**2       # Fig 13, it's actually bx in the picture which is the axial chord; h is 0 this causes nan
+            Ks = 1-K3*(1-Kp)        # Eqn 15
+            Ys = 1.2*Ys_amdc*Ks     # Eqn 16
+        else:
+            K3 = 0
+            Ks = 0 
+            Ys = 0 
+        
+        # Trailing Edge
+        if np.abs(beta1_deg-np.degrees(beta2_rad))<5: # impulse turbine the inlet and exit angles are the same
+            delta_phi2 = self.data['Fig14_Impulse'](float(row.te_pitch*row.pitch / row.throat))
+        else:
+            delta_phi2 = self.data['Fig14_Axial_Entry'](float(row.te_pitch*row.pitch / row.throat))
+        
+        Ytet = (1-(row.gamma-1)/2 * M2**2 * (1/(1-delta_phi2)-1)) **(-row.gamma/(row.gamma-1)) - 1 # Equation 18
+        Ytet = Ytet / (1-(1+(row.gamma-1)/2*M2**2)**(-row.gamma/(row.gamma-1)))
+        
+        # Tip Clearance
+        if h > 0:
+            kprime = row.tip_clearance/(3)**0.42 # Number of seals 
+            Ytc = 0.37*c/h * (kprime/c)**0.78 * Cl_sc**2 * np.cos(alpha2_rad)**2 / np.cos(alpham)**3
+        else:
+            Ytc = 0 
+            
+        if Rec <= 2E5:
+            f_re = (Rec/2E5)**-0.4 
+        elif Rec<1E6:
+            f_re = 1 
+        else:
+            f_re = (Rec/1E6)**-0.2
+        
+        Yt = Yp*f_re + Ys + Ytet + Ytc 
+        return Yt
+        

{turbo_design-1.3.5 → turbo_design-1.3.7}/turbodesign/loss/turbine/traupel.py

@@ -45,21 +45,21 @@ class Traupel(LossBaseClass):
 
         if row.row_type == RowType.Rotor:
             turning = np.abs(np.degrees(upstream.beta2-row.beta2).mean())
-            F = self.data['Fig06']((upstream.W/row.W).mean(),turning) # Inlet velocity
+            F = self.data['Fig06'](float((upstream.W/row.W).mean()), float(turning)) # Inlet velocity
         else:
             turning = np.abs(np.degrees(upstream.alpha2-row.alpha2).mean())
-            F = self.data['Fig06']((upstream.V/row.V).mean(),turning) # Inlet velocity
+            F = self.data['Fig06'](float((upstream.V/row.V).mean()), float(turning)) # Inlet velocity
 
-        H = self.data['Fig07'](alpha1-beta2,alpha2-beta3)
+        H = self.data['Fig07'](float(alpha1-beta2), float(alpha2-beta3))
         
         zeta_s = F*g/h_stator  # (h1-h1s)/(0.5*c1s**2) # no idea what h1s or h2s is
         zeta_r = F*g/h_rotor # (h2-h2s)/(0.5*w2s**2)
-        x_p_stator = self.data['Fig01'](alpha1,alpha2) # not sure if this is the right figure
-        x_p_rotor = self.data['Fig01'](beta2,beta3) # not sure if this is the right figure
-        zeta_p_stator = self.data['Fig02'](alpha1,alpha2)
-        x_m_stator = self.data['Fig03_0'](upstream.M)
-        zeta_p_rotor = self.data['Fig02'](beta2,beta3)
-        x_m_rotor = self.data['Fig03_0'](row.M_rel)
+        x_p_stator = self.data['Fig01'](float(alpha1), float(alpha2)) # not sure if this is the right figure
+        x_p_rotor = self.data['Fig01'](float(beta2), float(beta3)) # not sure if this is the right figure
+        zeta_p_stator = self.data['Fig02'](float(alpha1), float(alpha2))
+        x_m_stator = self.data['Fig03_0'](float(np.mean(upstream.M)))
+        zeta_p_rotor = self.data['Fig02'](float(beta2), float(beta3))
+        x_m_rotor = self.data['Fig03_0'](float(np.mean(row.M_rel)))
         
         
         e_te = upstream.te_pitch * g
@@ -67,10 +67,10 @@ class Traupel(LossBaseClass):
         ssen_alpha2 = e_te/o # Thickness of Trailing edge divide by throat 
         ssen_beta2 = row.te_pitch*g / row.throat
         
-        x_delta_stator = self.data['Fig05'](ssen_alpha2,alpha2)
-        zeta_delta_stator = self.data['Fig04'](ssen_alpha2,alpha2)
-        x_delta_rotor = self.data['Fig05'](ssen_beta2,beta3)
-        zeta_delta_rotor = self.data['Fig04'](ssen_beta2,beta3)
+        x_delta_stator = self.data['Fig05'](float(ssen_alpha2), float(alpha2))
+        zeta_delta_stator = self.data['Fig04'](float(ssen_alpha2), float(alpha2))
+        x_delta_rotor = self.data['Fig05'](float(ssen_beta2), float(beta3))
+        zeta_delta_rotor = self.data['Fig04'](float(ssen_beta2), float(beta3))
         
         Dm = 2* (upstream.r[-1] + upstream.r[0])/2 # Is this the mean diameter? I dont know
         zeta_f = 0.5 * (h_stator/Dm)**2
@@ -85,7 +85,7 @@ class Traupel(LossBaseClass):
         if row.row_type == RowType.Stator:
             zeta_cl = 0 
         else:
-            zeta_cl = self.data['Fig08'](row.tip_clearance) # For simplicity assume unshrouded blade 
+            zeta_cl = self.data['Fig08'](float(row.tip_clearance)) # For simplicity assume unshrouded blade 
             
         zeta_z = 0 # Do not factor this in, a bit complicated
         # 1 - (internal) - (external) 
@@ -97,4 +97,4 @@ class Traupel(LossBaseClass):
         
         
         
-        
+        

{turbo_design-1.3.5 → turbo_design-1.3.7}/turbodesign/passage.py

@@ -6,7 +6,8 @@ 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,xr_to_mprime
+from pyturbo.helper import convert_to_ndarray, xr_to_mprime
+
 import matplotlib.pyplot as plt 
 
 class Passage:
@@ -50,10 +51,13 @@ class Passage:
         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)
+        if len(xhub) < 10:
+            self.n = 10
+        else:
+            self.n = len(xhub)
         
-        self.xhub_pts = convert_to_ndarray(xhub)
-        self.rhub_pts = convert_to_ndarray(rhub)
+        self.xhub_pts = convert_to_ndarray(xhub) # type: ignore
+        self.rhub_pts = convert_to_ndarray(rhub) # type: ignore
         self.xshroud_pts = convert_to_ndarray(xshroud)
         self.rshroud_pts = convert_to_ndarray(rshroud)
         
@@ -114,6 +118,7 @@ class Passage:
     
         d_dx = FinDiff(0,x_streamline[indices[0]:indices[-1]],1)
         d2_dx2 = FinDiff(0,x_streamline[indices[0]:indices[-1]],2)
+        
         dr_dx = d_dx(r_streamline[indices[0]:indices[-1]])
         d2r_dx2 = d2_dx2(r_streamline[indices[0]:indices[-1]])    
             

{turbo_design-1.3.5 → turbo_design-1.3.7}/turbodesign/td_math.py

@@ -271,6 +271,26 @@ def rotor_calc(row:BladeRow,upstream:BladeRow,calculate_vm:bool=True):
         row (BladeRow): Rotor Row
         upstream (BladeRow): Stator Row or Rotor Row
     """
+    def _log_rotor_failure(reason:str):
+        def _fmt(val):
+            try:
+                return np.array2string(np.asarray(val), precision=5)
+            except Exception:
+                return str(val)
+
+        print(f"[RotorCalc] Failure detected: {reason}")
+        print(f"    row.T0R: {_fmt(row.T0R)}")
+        print(f"    row.T: {_fmt(row.T)}")
+        print(f"    row.W: {_fmt(row.W)}")
+        print(f"    row.M: {_fmt(getattr(row,'M', np.nan))}")
+        print(f"    row.M_rel: {_fmt(getattr(row,'M_rel', np.nan))}")
+        print(f"    row.Yp: {_fmt(getattr(row,'Yp', np.nan))}")
+        if np.any(row.T >= row.T0R):
+            print("    Note: T should be less than T0R.")
+        yp_val = getattr(row,'Yp', None)
+        if yp_val is not None and np.any(yp_val > 0.3):
+            print("    Note: row.Yp exceeded 0.3 which may indicate an issue with the design or loss model.")
+
     row.P0_stator_inlet = upstream.P0_stator_inlet
     ## P0_P is assumed 
     # row.P = row.P0_stator_inlet*1/row.P0_P
@@ -303,9 +323,18 @@ def rotor_calc(row:BladeRow,upstream:BladeRow,calculate_vm:bool=True):
     row.T = (row.T0R/T0R_T)     # Exit static temperature
     if calculate_vm:    # Calculates the T0 at the exit
         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)):
+        nan_in_velocity = np.isnan(np.sum(row.W))
+        temp_issue = np.any(row.T >= row.T0R)
+        high_loss = np.any(getattr(row,'Yp',0) > 0.3)
+        if nan_in_velocity:
             # Need to adjust T
-            raise ValueError(f'nan detected: check flow path. Turbine inlet cut should be horizontal')
+            reason = "nan detected in relative velocity"
+            if temp_issue:
+                reason += "; T >= T0R shouldn't happen because of T-s diagram'"
+            if high_loss:
+                reason += "; Yp > 0.3 This could be a problem with the loss model;"
+            _log_rotor_failure(reason)
+            raise ValueError(f'nan detected')
         row.Vr = row.W*np.sin(row.phi)
         row.Vm = row.W*np.cos(row.beta2)
         row.Wt = row.W*np.sin(row.beta2)
@@ -378,4 +407,4 @@ def inlet_calc(row:BladeRow):
         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}")
+        print(f"Unusually slow flow:{iter} Mach:{avg_mach}")

turbo_design-1.3.5/turbodesign/loss/__init__.py

@@ -1 +0,0 @@
-from .losstype import LossType, LossBaseClass

turbo_design-1.3.5/turbodesign/loss/losstype.py

@@ -1,25 +0,0 @@
-from typing import Any, Dict
-from ..lossinterp import LossInterp
-import os 
-from ..enums import LossType
-
-class LossBaseClass:  
-    data: Dict[str,LossInterp]
-    _loss_type:LossType
-    
-    def __init__(self,lossType:LossType):
-        # Make the environment directory 
-        default_home = os.path.join(os.path.expanduser("~"), ".cache")
-        os.environ['TD3_HOME'] = os.path.join(default_home,'TD3_LossModels')
-        os.makedirs(os.environ['TD3_HOME'],exist_ok=True)
-        
-        self._loss_type = lossType
-
-    def __call__(self, row:Any, upstream:Any):
-        raise Exception("Method needs to be overridden")
-
-    
-    
-    @property
-    def loss_type(self):
-        return self._loss_type

turbo_design-1.3.5/turbodesign/loss/turbine/kackerokapuu.py

@@ -1,129 +0,0 @@
-import pickle, os
-from typing import Dict
-from ...bladerow import BladeRow, sutherland
-from ...lossinterp import LossInterp
-from ...enums import RowType, LossType
-import numpy as np
-import pathlib
-from ..losstype import LossBaseClass
-import requests
-
-class KackerOkapuu(LossBaseClass):
-
-    def __init__(self):
-        """KackerOkapuu model is an improvement to the Ainley Mathieson model. 
-        
-        Limitations:
-            - Doesn't factor incidence loss 
-            - For steam turbines and impulse turbines
-            
-        Reference:
-            Kacker, S. C., and U. Okapuu. "A mean line prediction method for axial flow turbine efficiency." (1982): 111-119.
-            
-        """
-        super().__init__(LossType.Pressure)
-        path = pathlib.Path(os.path.join(os.environ['TD3_HOME'],"kackerokapuu"+".pkl"))
-        
-        if not path.exists():
-            url = "https://github.com/nasa/turbo-design/raw/main/references/Turbines/KackerOkapuu/kackerokapuu.pkl"
-            response = requests.get(url, stream=True)
-            with open(path.absolute(), mode="wb") as file:
-                for chunk in response.iter_content(chunk_size=10 * 1024):
-                    file.write(chunk)
-        
-        with open(path.absolute(),'rb') as f:
-            self.data = pickle.load(f) # type: ignore
-    
-        
-    
-    def __call__(self,row:BladeRow, upstream:BladeRow) -> float:
-        """Kacker Okapuu is an updated version of Ainley Mathieson and Dunham Came. This tool uses the pressure loss definition. 
-
-        Note: 
-            All equation numbers are from the Kacker Okapuu paper
-        
-        Reference:
-            Kacker, S. C., and U. Okapuu. "A mean line prediction method for axial flow turbine efficiency." (1982): 111-119.
-        
-        Args:
-            upstream (BladeRow): Upstream blade row
-            row (BladeRow): downstream blade row
-
-        Returns:
-            float: Pressure Loss 
-        """
-        if upstream.row_type == RowType.Stator:
-            M1 = upstream.M
-        else:
-            M1 = upstream.M_rel 
-        
-        c = row.chord
-        b = row.axial_chord
-        if row.row_type == RowType.Stator:
-            alpha1 = np.degrees(row.alpha1)
-            beta1 = np.degrees(row.beta1_metal)
-            alpha2 = np.degrees(row.alpha2)
-            M2 = row.M
-            h = 0
-            Rec = row.V*row.rho*row.chord / sutherland(row.T)
-        else:
-            h = row.tip_clearance * (row.r[-1]-row.r[0])
-            alpha1 = np.degrees(row.beta1)
-            beta1 = row.beta1_metal 
-            alpha2 = np.degrees(row.beta2)
-            M2 = row.M_rel
-            Rec = row.W*row.rho*row.chord / sutherland(row.T)
-            
-        Yp_beta0 = self.data['Fig01'](row.pitch_to_chord, alpha2)
-        Yp_beta1_alpha2 = self.data['Fig02'](row.pitch_to_chord, alpha2)
-        t_max_c = self.data['Fig04'](np.abs(beta1)+np.abs(alpha2))
-        
-        Yp_amdc = (Yp_beta0 + np.abs(beta1/alpha2) *beta1/alpha2 * (Yp_beta1_alpha2-Yp_beta0)) * ((t_max_c)/0.2)**(beta1/alpha2) # Eqn 2, AMDC = Ainley Mathieson Dunham Came
-        
-        # Shock Loss
-        dP_q1_hub = 0.75*(M1-0.4)**1.75 # Eqn 4, this is at the hub
-        dP_q1_shock = row.r[-1]/row.r[0] * dP_q1_hub # Eqn 5
-        Y_shock = dP_q1_shock * upstream.P/row.P * (1-(1+(upstream.gamma-1)/2*M1**2))/(1-(1+(row.gamma-1)/2*M2**2)) # Eqn 6
-        
-        K1 = self.data['Fig08_K1'](M2)
-        K2 = (M1/M2)**2 
-        Kp = 1-K2*(1-K1)
-        
-        CFM = 1+60*(M2-1)**2    # Eqn 9 
-        
-        Yp = 0.914 * (2/3*Yp_amdc *Kp + Y_shock) # Eqn 8 Subsonic regime 
-        if M2>1:
-            Yp = Yp*CFM
-        
-        f_ar = (1-0.25*np.sqrt(2-h/c)) / (h/c) if h/c<=2 else 1/(h/c)
-        alpham = np.arctan(0.5*(np.tan(alpha1) - np.tan(alpha2)))
-        Cl_sc = 2*(np.tan(alpha1)+np.tan(alpha2))*np.cos(alpham)
-        Ys_amdc = 0.0334 *f_ar *np.cos(alpha2)/np.cos(beta1) * (Cl_sc)**2 * np.cos(alpha2)**2 / np.cos(alpham)**3
-        # Secondary Loss 
-        K3 = 1/(h/(b))**2     # Fig 13, it's actually bx in the picture which is the axial chord
-        Ks = 1-K3*(1-Kp)        # Eqn 15
-        Ys = 1.2*Ys_amdc*Ks     # Eqn 16
-        
-        # Trailing Edge
-        if np.abs(alpha1-alpha2)<5:
-            delta_phi2 = self.data['Fig14_Impulse'](row.te_pitch*row.pitch / row.throat)
-        else:
-            delta_phi2 = self.data['Fig14_Axial_Entry'](row.te_pitch*row.pitch / row.throat)
-        
-        Ytet = (1-(row.gamma-1)/2 - M2**2 * (1/(1-delta_phi2)-1))**(-row.gamma/(row.gamma-1))-1
-        Ytet = Ytet / (1-(1+(row.gamma-1)/2*M2**2)**(-row.gamma/(row.gamma-1)))
-        
-        # Tip Clearance
-        kprime = row.tip_clearance/(3)**0.42 # Number of seals 
-        Ytc = 0.37*c/h * (kprime/c)**0.78 * Cl_sc**2 * np.cos(alpha2)**2 / np.cos(alpham)**3
-        
-        if Rec <= 2E5:
-            f_re = (Rec/2E5)**-0.4 
-        elif Rec<1E6:
-            f_re = 1 
-        else:
-            f_re = (Rec/1E6)**-0.2
-        
-        Yt = Yp*f_re + Ys + Ytet + Ytc 
-        return Yt
-