turbo-design 1.3.6__py3-none-any.whl → 1.3.8__py3-none-any.whl

{turbo_design-1.3.6.dist-info → turbo_design-1.3.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: turbo-design
-Version: 1.3.6
+Version: 1.3.8
 Summary: TurboDesign is a library used to design turbines and compressors using radial equilibrium.
 Author: Paht Juangphanich
 Author-email: paht.juangphanich@nasa.gov
@@ -11,6 +11,7 @@ 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.6.dist-info → turbo_design-1.3.8.dist-info}/RECORD

@@ -1,33 +1,33 @@
 turbodesign/__init__.py,sha256=N8Nu0I1vrlEHYJZZ7yhhg-FtbNbLyrgjy7hoicygUqg,325
 turbodesign/arrayfuncs.py,sha256=GHIlTyLfeNsNCQQoh5m1aXK3iyvU6RjdYQipkqpU_ps,519
-turbodesign/bladerow.py,sha256=351FMt9UtbFMAKtU-mDkJ12hmIdaaa4qF6K6Q-ZYkBM,25063
+turbodesign/bladerow.py,sha256=Uad3UUnaRqCaEQBV1mHD04eU_lkz-BWr4n1vjFsX-eA,25472
 turbodesign/cantera_gas/co2.yaml,sha256=M2o_RzxV9B9rDkgkXJC-l3voKraFZguTZuKKt4F7S_c,887
 turbodesign/compressorspool.py,sha256=z8ZVczJ-EdZvIqqZArC6UdwC5MbU2SZh_MT2CGq5avY,2600
 turbodesign/coolant.py,sha256=evDtUFOYhfZKTVAsDWzxRzUX20gTvfjj0uybaWg4CsI,427
 turbodesign/enums.py,sha256=WC6VPmHw3UF1zR1SLjj8z00gIWSNso66MShFGoYRY4U,1164
 turbodesign/inlet.py,sha256=5uja906IA-_gca4FJykZvFLJ1he6HRy5pZDNQE1D2_g,7945
 turbodesign/isentropic.py,sha256=YLTmNx69e_M5fTuLOmk_KvaQ6ABv0aZsityfBihJOmI,2003
-turbodesign/loss/__init__.py,sha256=ZJomzXa6ElduFruURukCrFwJQXMWS2aW8JSaVQ-M2r8,46
+turbodesign/loss/__init__.py,sha256=jltNIIbUntGKq2IfX3EKUNEajIcHdOB7pWuj5tLtmGw,66
 turbodesign/loss/compressor/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-turbodesign/loss/losstype.py,sha256=Vzj3UPk1_5IA3DtL56Eb5Z7LkYyMQ97DGZvgfki8ByA,708
+turbodesign/loss/losstype.py,sha256=ViUf1ue3DZ3qFAhLUP3ps2fyygNH6udekAr53vEzrY8,1776
 turbodesign/loss/turbine/TD2.py,sha256=evyTG4K6s56NGdjxrZFD3G7zsB8_2lJTBOxT3Ju2uG8,5207
 turbodesign/loss/turbine/__init__.py,sha256=d1UrbiIicO60FhDlOemo_irYW2asUaYoqlXUz-UG9zk,285
-turbodesign/loss/turbine/ainleymathieson.py,sha256=8UbugNmxI12I68HGctJe2lQpqjKZN1b40UOTzqU6hQQ,5861
-turbodesign/loss/turbine/craigcox.py,sha256=TrbNdpGdyD5kTRFKfNmbRDhCOjA0-GT5xoluLQpO1gA,9664
+turbodesign/loss/turbine/ainleymathieson.py,sha256=uTl1wXcJZmNjeerGTYDYCs0vJhyMPjG_0C9xlvSKYqY,5911
+turbodesign/loss/turbine/craigcox.py,sha256=2dydHVvxTKhmJsRHO7Vf2JFKM6xaUSeT_CPxf8PCtWs,9942
 turbodesign/loss/turbine/fixedefficiency.py,sha256=JJv4GUS5q9pvuf3akjBtlcHOykRYmRVFfDDrdWqH6S4,774
 turbodesign/loss/turbine/fixedpressureloss.py,sha256=sgkm6uQwz6Qz2LDCEmir46aJRSPLAdCKpDyR1hNdgQ8,682
-turbodesign/loss/turbine/kackerokapuu.py,sha256=hUmZdyA1hAhN3_xbwBhka2dyk0Aq9rqq62S2ghuKSOk,5071
-turbodesign/loss/turbine/traupel.py,sha256=aZxFE9JDcCfi1gy-fqS1SxjjlhuDG-H-g3LPurty1M0,4164
+turbodesign/loss/turbine/kackerokapuu.py,sha256=TQkTKG6ZdpsdEp1-qJfacQR8EEZSQ1qjUmOTf3t7mws,7263
+turbodesign/loss/turbine/traupel.py,sha256=8KDjalPgBW3GoZUL7jgsyPFoDwNfcQhzmeRNrsZA0XA,4369
 turbodesign/lossinterp.py,sha256=B2KEobp-nD9jwD6UINgBmTlH9kKyWg3UNvXxqfUsr-k,6198
 turbodesign/outlet.py,sha256=MaZJ-mDuLvh19AashnMQLx2XlR-Rk1r0HQS4kE0OxeI,2191
 turbodesign/passage.py,sha256=RZ8giKMcpJI7EnO4SEnbGYcPFmKdGyzWC0UZTXHnS6g,12181
-turbodesign/radeq.py,sha256=KiZybA8EtOKMzszstdlaR-sF5KI9nUBgYOGZYLU1x4I,6516
+turbodesign/radeq.py,sha256=LEqYxZZocCZyVPhY09MNFTnAkEXM740-SR6QxXW8Ssg,6522
 turbodesign/rotor.py,sha256=tHl9o5H4aQ6Etd4gqa8Ime1UK7k0de4GLt5Yb1sJdGs,1376
 turbodesign/solve_radeq.py,sha256=nLYlRtXElPgHaoUP9jwMulRmYKTJs_uQ1eCulk2V59I,1938
 turbodesign/spool.py,sha256=81UFbBi5JKm0RJ_hjB40bKWeCXx0V2lt0b2VAwOtTDU,14376
 turbodesign/stage.py,sha256=UP45sDKDLsAkO_WfDWJ6kqXU7cYKh_4QO01QZnSN1oQ,166
-turbodesign/td_math.py,sha256=qlLlAMB3kHUMdkvr9sOKl-rPShDx-XQCqG9DHOr7Vis,16268
-turbodesign/turbinespool.py,sha256=vpmrNmZ23k2wU7b9GAZrT3dOpX3otkpTtjAlfCY92sQ,25271
-turbo_design-1.3.6.dist-info/METADATA,sha256=T0hurxrmU0EtnW6pWQzml9KF7o22etumb68C3wWU0gA,734
-turbo_design-1.3.6.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-turbo_design-1.3.6.dist-info/RECORD,,
+turbodesign/td_math.py,sha256=aL5lbRl7nB8hQA6HyyFTtNpAbJ1ybn1s8iybXIfqiO8,17549
+turbodesign/turbinespool.py,sha256=REA5QmpRE58o-3cf4dtVS1ChCoriCcQmzCOssv9CYvc,25259
+turbo_design-1.3.8.dist-info/METADATA,sha256=9XmBcAOWQZPo5yR2zQVkL-rVxLK8YKjkOQI-CGtaFjU,785
+turbo_design-1.3.8.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+turbo_design-1.3.8.dist-info/RECORD,,

{turbo_design-1.3.6.dist-info → turbo_design-1.3.8.dist-info}/WHEEL

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

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

turbodesign/loss/__init__.py

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

turbodesign/loss/losstype.py

@@ -1,9 +1,10 @@
-from typing import Any, Dict
+from abc import ABC, abstractmethod
+from typing import Any, Dict, Iterable, Tuple
 from ..lossinterp import LossInterp
 import os 
 from ..enums import LossType
 
-class LossBaseClass:  
+class LossBaseClass(ABC):  
     data: Dict[str,LossInterp]
     _loss_type:LossType
     
@@ -15,11 +16,40 @@ class LossBaseClass:
         
         self._loss_type = lossType
 
-    def __call__(self, row:Any, upstream:Any):
-        raise Exception("Method needs to be overridden")
+    @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
+        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

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 
-        
+        

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
-        
+        

turbodesign/loss/turbine/kackerokapuu.py

@@ -8,14 +8,22 @@ import pathlib
 from ..losstype import LossBaseClass
 import requests
 
-class KackerOkapuu(LossBaseClass):
 
-    def __init__(self):
+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.
@@ -33,7 +41,7 @@ class KackerOkapuu(LossBaseClass):
         
         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:
@@ -52,71 +60,100 @@ class KackerOkapuu(LossBaseClass):
         Returns:
             float: Pressure Loss 
         """
-        if upstream.row_type == RowType.Stator:
-            M1 = upstream.M
-        else:
-            M1 = upstream.M_rel 
-        
+        # Get the Inlet incoming mach number relative to the blade
         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
+            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 = row.V*row.rho*row.chord / sutherland(row.T)
+            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 = 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))
+            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)
         
-        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
+        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
-        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
+        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
         
-        K1 = self.data['Fig08_K1'](M2)
+        if M2 <= 0.2:
+            K1 = 1
+        else:
+            K1 = 1-1.25*(M2-0.2)
         K2 = (M1/M2)**2 
         Kp = 1-K2*(1-K1)
         
-        CFM = 1+60*(M2-1)**2    # Eqn 9 
+        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 
+        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
+        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(alpha1-alpha2)<5:
-            delta_phi2 = self.data['Fig14_Impulse'](row.te_pitch*row.pitch / row.throat)
+        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'](row.te_pitch*row.pitch / row.throat)
+            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
+        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
-        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 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:
@@ -126,4 +163,4 @@ class KackerOkapuu(LossBaseClass):
         
         Yt = Yp*f_re + Ys + Ytet + Ytc 
         return Yt
-        
+        

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):
         
         
         
-        
+        

turbodesign/radeq.py

@@ -70,12 +70,13 @@ def radeq(row:BladeRow,upstream:BladeRow,downstream:Optional[BladeRow]=None) ->
                 down_Vm = interp1d(row_radius, downstream.Vm)(r)
         else:
             down_Vm = Vm
+        
+        row_m = interp1d(row_radius, row.m)(r)
         up_m = interp1d(row_radius, upstream.m)(r)
         
-        # Get a rough guess of dVm/dm
+        # Get a rough guess of dVm/dmv
         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:

turbodesign/td_math.py

@@ -1,6 +1,5 @@
-from typing import List, Optional, Tuple
+from typing import List, Optional
 import numpy as np
-import math
 import numpy.typing as npt
 from .bladerow import BladeRow, compute_gas_constants
 from .enums import RowType, LossType
@@ -271,6 +270,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 +322,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 +406,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}")

turbodesign/turbinespool.py

@@ -449,9 +449,9 @@ def calculate_massflows(blade_rows:List[BladeRow],calculate_vm:bool=False,fluid:
                     row.Yp = 0
                     stator_calc(row,upstream,downstream,calculate_vm=True)
                     row = radeq(row,upstream) 
-                    row = compute_gas_constants(row,fluid)
+                    compute_gas_constants(row,fluid)
                     stator_calc(row,upstream,downstream,calculate_vm=False)
-                row = compute_gas_constants(row,fluid)
+                compute_gas_constants(row,fluid)
                 compute_massflow(row)
                 compute_power(row,upstream)