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

turbodesign/isentropic.py

@@ -1,8 +1,19 @@
+from typing import Union
 import numpy as np
+import numpy.typing as npt
 import math
 
+ArrayLike = Union[float, npt.NDArray[np.float64]]
 
-def IsenP(M:np.ndarray,gamma:float) -> float:
+
+def _maybe_return_scalar(result: npt.NDArray[np.float64], *inputs: object) -> ArrayLike:
+    """Return a float when all driving inputs were scalar, else an ndarray."""
+    if all(np.isscalar(inp) for inp in inputs):
+        return float(np.asarray(result))
+    return np.asarray(result, dtype=float)
+
+
+def IsenP(M:ArrayLike,gamma:float) -> ArrayLike:
     """Computes the ratio P0/Ps
 
     Args:
@@ -12,10 +23,12 @@ def IsenP(M:np.ndarray,gamma:float) -> float:
     Returns:
         float: P0/P ratio 
     """
-    return np.power((1+(gamma-1)/2.0 * M*M),gamma/(gamma-1))
+    M_arr = np.asarray(M, dtype=float)
+    result = np.power((1+(gamma-1)/2.0 * M_arr*M_arr),gamma/(gamma-1))
+    return _maybe_return_scalar(result, M)
 
 
-def FindMachP0P(P0_P:np.ndarray,gamma:float) -> float:
+def FindMachP0P(P0_P:ArrayLike,gamma:float) -> ArrayLike:
     """Finds the mach number given a P0/P ratio
 
     Args:
@@ -26,14 +39,14 @@ def FindMachP0P(P0_P:np.ndarray,gamma:float) -> float:
         float: [description]
     """
     n = (gamma-1)/gamma
-    c = 2.0/(gamma-1) * (np.power(P0_P,n) - 1.0)
-
+    P0_P_arr = np.asarray(P0_P, dtype=float)
+    c = 2.0/(gamma-1) * (np.power(P0_P_arr,n) - 1.0)
     M = np.sqrt(c)
-    return M # Subsonic and supersonic solution
+    return _maybe_return_scalar(M, P0_P)
     
 
 
-def IsenT(M:np.ndarray,gamma:float) -> float:
+def IsenT(M:ArrayLike,gamma:float) -> ArrayLike:
     """Computes T0/Ts
 
     Args:
@@ -43,10 +56,12 @@ def IsenT(M:np.ndarray,gamma:float) -> float:
     Returns:
         float: Ratio of T0/Ts
     """
-    return (1.0+(gamma-1.0)/2.0 *M*M)
+    M_arr = np.asarray(M, dtype=float)
+    result = (1.0+(gamma-1.0)/2.0 *M_arr*M_arr)
+    return _maybe_return_scalar(result, M)
 
 
-def A_As(M:np.ndarray,gamma:float) -> float:
+def A_As(M:ArrayLike,gamma:float) -> ArrayLike:
     """Computes the ratio of Area to Throat Area give a given mach number and gamma 
 
     Args:
@@ -58,11 +73,13 @@ def A_As(M:np.ndarray,gamma:float) -> float:
     """
     a = (gamma+1.0)/(2.0*(gamma-1.0))
     temp1 = np.power((gamma+1.0)/2.0,a)
-    temp2 = np.power((1+(gamma-1)/2*M*M),-a)/M
-    return temp1*temp2
+    M_arr = np.asarray(M, dtype=float)
+    temp2 = np.power((1+(gamma-1)/2*M_arr*M_arr),-a)/M_arr
+    result = temp1*temp2
+    return _maybe_return_scalar(result, M)
 
 
-def Massflow(P0:float,T0:float,A:float,M:float,gamma:float,R:float=287):
+def Massflow(P0:ArrayLike,T0:ArrayLike,A:ArrayLike,M:ArrayLike,gamma:float,R:float=287) -> ArrayLike:
     """Massflow rate calculation
     
     Args:
@@ -76,7 +93,34 @@ def Massflow(P0:float,T0:float,A:float,M:float,gamma:float,R:float=287):
     Returns:
         float: Nusselt Number
     """
-    mdot = A * P0/np.sqrt(T0) * np.sqrt(gamma/R) * M \
-        *np.power(1.0+(gamma-1.0)/2.0 * M*M, -(gamma+1.0)/(2.0*(gamma-1.0)))
+    P0_arr = np.asarray(P0, dtype=float)
+    T0_arr = np.asarray(T0, dtype=float)
+    A_arr = np.asarray(A, dtype=float)
+    M_arr = np.asarray(M, dtype=float)
+    gamma_val = float(gamma)
+    R_val = float(R)
+    mdot = A_arr * P0_arr/np.sqrt(T0_arr) * np.sqrt(gamma_val/R_val) * M_arr \
+        *np.power(1.0+(gamma_val-1.0)/2.0 * M_arr*M_arr, -(gamma_val+1.0)/(2.0*(gamma_val-1.0)))
+    return _maybe_return_scalar(mdot, P0, T0, A, M)
+
+
+def solve_for_mach(M: float, massflow: float, P0: float, T0: float, area: float, gamma: float, R: float) -> float:
+    """Residual between desired and estimated massflow for a guessed Mach number.
+
+    Args:
+        M (float): Mach number guess (dimensionless).
+        massflow (float): Target massflow [kg/s].
+        P0 (float): Total pressure [Pa].
+        T0 (float): Total temperature [K].
+        area (float): Flow area [m^2].
+        gamma (float): Specific heat ratio Cp/Cv [-].
+        R (float): Gas constant [J/(kg·K)].
+
+    Returns:
+        float: Absolute massflow residual [kg/s].
+    """
+    expo = -(gamma + 1.0) / (2.0 * (gamma - 1.0))
     
-    return mdot
+    estimate = area* P0/np.sqrt(T0)*np.sqrt(gamma / R)*M*np.power(1.0 + (gamma - 1.0) / 2.0 * M * M, expo)
+    residual = np.abs(massflow - estimate)
+    return residual

turbodesign/loss/__init__.py

@@ -1 +1,3 @@
-from .losstype import LossType, LossBaseClass, CompositeLossModel
+from .losstype import LossType, LossBaseClass
+from .fixedpressureloss import FixedPressureLoss
+from .fixedpolytropic import FixedPolytropicEfficiency

turbodesign/loss/compressor/OTAC_README.md

@@ -0,0 +1,39 @@
+OTAC compressor loss models
+===========================
+
+The classes in `otac.py` mirror the legacy OTAC `*.int` loss models. They are
+currently placeholders that return zeros and emit a warning so the loss API can
+be wired without failing.
+
+When you translate an OTAC model, these mappings are a good starting point:
+
+- `Fl_IR` → upstream `BladeRow` (inlet to the current row)
+- `Fl_OR` → current `BladeRow` (outlet of the current row)
+- `V`, `W`, `U`, `Vz`, `Vr`, `Vtheta` → `row.V`, `row.W`, `row.U`, `row.Vx`, `row.Vr`, `row.Vt`
+- `alpha`, `beta` (flow angles) → `row.alpha1/alpha2` (absolute), `row.beta1/beta2` (relative)
+- `ts`, `Tt`, `T` → static temperature `row.T`, total temperature `row.T0`
+- `Ps`, `Pt`, `P` → static pressure `row.P`, total pressure `row.P0`
+- `rho`, `rhos`, `rhot` → density `row.rho`
+- `mu` → dynamic viscosity `row.mu`
+- `ht` (total enthalpy) → `row.Cp * row.T0`
+- `MN`, `M` → Mach number `row.M` (absolute) or `row.M_rel` (relative)
+- `radius`, `radiusTipInlet`, `radiusExit` → `row.r` entries (`row.r[0]` hub, `row.r[-1]` tip)
+- `bwidth`, `pitch`, `chord`, `throat` → `row.pitch`, `row.chord`, `row.throat`
+
+Most OTAC models assume enthalpy loss; set the loss type accordingly in the
+class `__init__`. If a model clamps the loss (e.g., to 25–50% of the available
+enthalpy rise), keep those guards to avoid runaway penalties.
+
+Recommended workflow:
+
+1. Pick a model, open the matching `otac/*.int` file, and translate `calculate`
+   into a vectorized NumPy computation inside the corresponding class in
+   `otac.py`.
+2. Replace the base class with `LossBaseClass` directly once implemented
+   (remove `_OTACStub` inheritance) and drop the warning.
+3. Use `row`/`upstream` attributes from `BladeRow` for inputs; add any new
+   geometry fields you need to `BladeRow` with sensible defaults.
+4. Return an array shaped like `row.r` (use `np.full_like(row.r, value)` when
+   the loss is a scalar).
+
+This file is intentionally brief; keep notes here as you refine the mappings.

turbodesign/loss/compressor/__init__.py

@@ -1 +1,55 @@
+from .otac import (
+    AxialCompressorAungier,
+    AxialCompressorEntropy,
+    AxialCompressorWrightMiller,
+    AxialTurbineAinleyMathiesonOTAC,
+    AxialTurbineKackerOkapuuOTAC,
+    DiffuserVanelessStanitz,
+    ImpellerBladeLoadingAungier,
+    ImpellerBladeLoadingCoppage,
+    ImpellerClearanceJansen,
+    ImpellerDiscFrictionDaily,
+    ImpellerIncidenceAungier,
+    ImpellerIncidenceConrad,
+    ImpellerLeakageAungier,
+    ImpellerMixingAungier,
+    ImpellerMixingJohnston,
+    ImpellerPrescribed,
+    ImpellerRecirculationAungier,
+    ImpellerRecirculationOh,
+    ImpellerSkinFrictionCoppage,
+    ImpellerSkinFrictionJansen,
+    ImpellerVarious,
+    NASA23B20,
+    NASA74A,
+    RadialInput,
+)
+from .diffusion import DiffusionLoss
 
+__all__ = [
+    "AxialCompressorAungier",
+    "AxialCompressorEntropy",
+    "AxialCompressorWrightMiller",
+    "AxialTurbineAinleyMathiesonOTAC",
+    "AxialTurbineKackerOkapuuOTAC",
+    "DiffuserVanelessStanitz",
+    "ImpellerBladeLoadingAungier",
+    "ImpellerBladeLoadingCoppage",
+    "ImpellerClearanceJansen",
+    "ImpellerDiscFrictionDaily",
+    "ImpellerIncidenceAungier",
+    "ImpellerIncidenceConrad",
+    "ImpellerLeakageAungier",
+    "ImpellerMixingAungier",
+    "ImpellerMixingJohnston",
+    "ImpellerPrescribed",
+    "ImpellerRecirculationAungier",
+    "ImpellerRecirculationOh",
+    "ImpellerSkinFrictionCoppage",
+    "ImpellerSkinFrictionJansen",
+    "ImpellerVarious",
+    "NASA23B20",
+    "NASA74A",
+    "RadialInput",
+    "DiffusionLoss",
+]

turbodesign/loss/compressor/diffusion.py

@@ -0,0 +1,61 @@
+from typing import Optional, TYPE_CHECKING
+
+import numpy as np
+import numpy.typing as npt
+
+from ..losstype import LossBaseClass
+from ...enums import LossType, RowType
+
+if TYPE_CHECKING:
+    from ...bladerow import BladeRow  # for type hints only
+
+
+class DiffusionLoss(LossBaseClass):
+    """Pressure-loss model based on diffusion factor.
+
+    Computes a spanwise diffusion factor and maps it to a pressure-loss
+    coefficient Yp via a simple linear ramp above a threshold.
+    """
+
+    def __init__(self, df_limit: float = 0.45, df_knee: float = 0.6, df_max: float = 0.9, yp_at_max: float = 0.08):
+        """
+        Args:
+            df_limit: Diffusion factor below which loss is negligible.
+            df_knee: Diffusion factor where loss starts ramping up noticeably.
+            df_max: Diffusion factor at which Yp reaches ``yp_at_max``.
+            yp_at_max: Pressure-loss coefficient when ``df_max`` is reached.
+        """
+        super().__init__(LossType.Pressure)
+        self.df_limit = df_limit
+        self.df_knee = df_knee
+        self.df_max = df_max
+        self.yp_at_max = yp_at_max
+
+    def __call__(self, row: "BladeRow", upstream: "BladeRow") -> npt.NDArray:
+        """Return pressure-loss coefficient Yp based on diffusion factor."""
+        # Choose absolute vs relative velocities depending on row type
+        if row.row_type == RowType.Rotor:
+            V1 = upstream.W
+            V2 = row.W
+            Vt1 = upstream.Wt
+            Vt2 = row.Wt
+            U = upstream.U
+        else:
+            V1 = upstream.V
+            V2 = row.V
+            Vt1 = upstream.Vt
+            Vt2 = row.Vt
+            U = 0.0
+
+        V1_mag = np.maximum(np.abs(V1), 1e-6)
+        V2_mag = np.abs(V2)
+        dVt = Vt2 - Vt1
+
+        df = 1.0 - V2_mag / V1_mag + dVt / np.maximum(np.abs(U), 1e-6)
+
+        # Map diffusion factor to Yp
+        Yp = np.zeros_like(row.percent_hub_shroud, dtype=float)
+        ramp = (df - self.df_limit) / max(self.df_knee - self.df_limit, 1e-6)
+        ramp = np.clip(ramp, 0.0, 1.0)
+        Yp = ramp * (self.yp_at_max * np.clip((df - self.df_limit) / max(self.df_max - self.df_limit, 1e-6), 0.0, 1.0))
+        return Yp

turbodesign/loss/compressor/lieblein.py

@@ -0,0 +1 @@
+# Profile Loss Lieblein