turbo-design 1.3.7__py3-none-any.whl → 1.3.9__py3-none-any.whl

{turbo_design-1.3.7.dist-info → turbo_design-1.3.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: turbo-design
-Version: 1.3.7
+Version: 1.3.9
 Summary: TurboDesign is a library used to design turbines and compressors using radial equilibrium.
 Author: Paht Juangphanich
 Author-email: paht.juangphanich@nasa.gov
@@ -20,3 +20,4 @@ Requires-Dist: pandas
 Requires-Dist: plot3d
 Requires-Dist: pyturbo-aero
 Requires-Dist: scipy
+Requires-Dist: shapely

turbo_design-1.3.9.dist-info/RECORD

@@ -0,0 +1,46 @@
+turbodesign/__init__.py,sha256=VcHpQZK84kYvhgStDWg559mq78Npr9aw2qIH1YzwXls,2798
+turbodesign/agf.py,sha256=3JIPPJ-Jlsq-SPFwbHBaKh5Ul40qKlFQB5EHkPhymTE,11745
+turbodesign/arrayfuncs.py,sha256=wU_dMJfbk3U_X4p9gUXrtlIIYkIDInQE0DmM3B94ykc,1587
+turbodesign/bladerow.py,sha256=NEv9VQchC8cyDCoqwbFjR1PlEdi5JdHiatsbjCkPSaQ,29243
+turbodesign/cantera_gas/co2.yaml,sha256=M2o_RzxV9B9rDkgkXJC-l3voKraFZguTZuKKt4F7S_c,887
+turbodesign/compressor_math.py,sha256=FT0_Hha98op9HmgzenbrcbCeDmAZ14OC2tZV6HezyJE,17557
+turbodesign/compressor_spool.py,sha256=7Z0SP70wDhtfX5YCCyb99IQjpQf400tByk6ATQ5yOO4,35817
+turbodesign/coolant.py,sha256=z5ypCSVw4OaQq41a62cgZM4O7z6_JG8GepLPU3o38iA,596
+turbodesign/deviation/__init__.py,sha256=RBKMk1rtC2glLpZBaGWLnD8fI6Vlme21eCD_qjvAgP0,208
+turbodesign/deviation/axial_compressor.py,sha256=hGPF0-qej7qMOW-VPhqsO46BwASO_3i4CD5Omp1_Lzk,77
+turbodesign/deviation/carter_deviation.py,sha256=SduHA5NHXbZmJSC_dSgiRdjzuErRsA7bT5Axkda9ARE,3339
+turbodesign/deviation/deviation_base.py,sha256=UMgIS7KRnd26R6HPpVpGuGQYTUCVj06_gRitGTMgs30,699
+turbodesign/deviation/fixed_deviation.py,sha256=JsKV40Xz4Uno4-it1a30wXJa3iyt0Wkj8mBnNA7AMIE,1630
+turbodesign/enums.py,sha256=blP0A5xS1yi54Pqvy9ujMdzTSWHou13nQc_STqqZSos,1019
+turbodesign/flow_math.py,sha256=HHqox2-9mFb8MqSC0n2o3Q5GpC81zmYsMJQOX8BJ43E,7200
+turbodesign/inlet.py,sha256=HIJCE3c3y8G-ESvIqX7m7kiqEae688MNesOZGzYzaAM,11602
+turbodesign/isentropic.py,sha256=PcC8G463-zWzHcUmwgebZp-NDS_mxivufnvrQILqra8,3889
+turbodesign/loss/__init__.py,sha256=eABmmypEC-Nny0ctAiH-av_7E4-JK8aeUycFURgaJEE,150
+turbodesign/loss/compressor/OTAC_README.md,sha256=4pLkRobJh22A9Ds5X-bHYF7xVR0eNQl8VUQsAvWg_YU,2032
+turbodesign/loss/compressor/__init__.py,sha256=sslS1fkvCDDEAQqy7cnwITy5DHqh35Utx_YfoG20yXo,1493
+turbodesign/loss/compressor/diffusion.py,sha256=Mh0B69TYm4mDfDBpsDkWuHxpgwaqRddx22GgFKVNbd8,2177
+turbodesign/loss/compressor/lieblein.py,sha256=AVdQPyjVhKubX_XiOM-j6KHeYmJ5zs1zb30R6M0kWZQ,24
+turbodesign/loss/compressor/otac.py,sha256=6xB15-3y8cNRVSc2XsZi00abU3zIxiVCTSLzvJG6eVc,31232
+turbodesign/loss/compressor/references/schobeiri-2012-shock-loss-model-for-transonic-and-supersonic-axial-compressors-with-curved-blades.pdf,sha256=VwTYf6i1DskgEnKk2eCDluSQSixq2qVMkiH1RxCssCY,409616
+turbodesign/loss/fixedpolytropic.py,sha256=SdekAXL_F6HQ6ZSbN7lxNVAhu5A8Fb17JLSalWeDIAI,947
+turbodesign/loss/fixedpressureloss.py,sha256=WE0NqfqOD_myn_mo7qTNEp8MHHyLS_XbDQ2lo-Wy89w,1118
+turbodesign/loss/losstype.py,sha256=e_AGwsUFroTChVJirOJlte6Ymi-JVSi81S06OfR3IOA,860
+turbodesign/loss/turbine/TD2.py,sha256=brujJXTYd8D2lTa622IiI_MJx7x6OQ0i62Df5jWtHRg,4846
+turbodesign/loss/turbine/__init__.py,sha256=re58JgTpvkkviCICa0QNbHD6YTHEthrp9JsSkOmw4No,236
+turbodesign/loss/turbine/ainleymathieson.py,sha256=nQjvFyu2MSQwltHzqPwmFsrG6D7aoYe6nSs5CYHwD-k,6013
+turbodesign/loss/turbine/craigcox.py,sha256=IaF1_qh0CEoKz5VfppwfIBdX3AVeryWgfnqkVeeYmD4,10095
+turbodesign/loss/turbine/fixedefficiency.py,sha256=a0sJvJrINHrwJb5cBZGOHIbG3MVasifuRvsHB00SLfs,924
+turbodesign/loss/turbine/kackerokapuu.py,sha256=Gk_coaARFAxpvhr0vEHOwn1qtJ3jT06L-p6yS_B5Ys8,7388
+turbodesign/loss/turbine/traupel.py,sha256=M6t_Yme10eAA0bKfJnRj_xmrlwkM5tK1hG86_uthzGA,4487
+turbodesign/lossinterp.py,sha256=B2KEobp-nD9jwD6UINgBmTlH9kKyWg3UNvXxqfUsr-k,6198
+turbodesign/outlet.py,sha256=YigceKWqWzcyl6S4OacYJ6a-83tIDbZikHKqLvksrk0,4884
+turbodesign/passage.py,sha256=PBHjaGngprG3cNFEiWPFQ7Sw1lPZ0x9AdjRV52ilCZM,14491
+turbodesign/radeq.py,sha256=LEqYxZZocCZyVPhY09MNFTnAkEXM740-SR6QxXW8Ssg,6522
+turbodesign/row_factory.py,sha256=3q97xK6edrS8GERXw_Y6vrvpRqiNOZARnw4JThzegBs,4892
+turbodesign/solve_radeq.py,sha256=NqPjeVnWtI9ULd7f8wtm_g9QhCz8ZuAiXruxsJpmdGM,1948
+turbodesign/stage.py,sha256=UP45sDKDLsAkO_WfDWJ6kqXU7cYKh_4QO01QZnSN1oQ,166
+turbodesign/turbine_math.py,sha256=oNOyL5ecp1PLLnRuZFZI7fbN0rPAJGSQniaDKDslEkc,15935
+turbodesign/turbine_spool.py,sha256=zG6NQTTm0syFlLuuaQSSWUAEgH7SQ1vI6T8JXtuwx-k,43692
+turbo_design-1.3.9.dist-info/METADATA,sha256=ldJWFMHorhV-P1PyUaxjyaVR3UK1RJJljPx2exT8TZA,808
+turbo_design-1.3.9.dist-info/WHEEL,sha256=3ny-bZhpXrU6vSQ1UPG34FoxZBp3lVcvK0LkgUz6VLk,88
+turbo_design-1.3.9.dist-info/RECORD,,

{turbo_design-1.3.7.dist-info → turbo_design-1.3.9.dist-info}/WHEEL

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

turbodesign/__init__.py

@@ -1,9 +1,62 @@
-from .turbinespool import TurbineSpool
-from .compressorspool import CompressorSpool
+from .turbine_spool import TurbineSpool
 from .stage import Stage
-from .enums import LossType, RowType, PassageType, MassflowConstraint
+from .enums import LossType, RowType, PassageType
 from .inlet import Inlet
 from .bladerow import BladeRow
+from .coolant import Coolant
 from .lossinterp import LossInterp
 from .passage import Passage
-from .outlet import Outlet
+from .outlet import Outlet
+from .deviation import DeviationBaseClass, FixedDeviation
+from .row_factory import make_blade_row, make_rotor_row, make_stator_row
+from .agf import AGF_Setup, Inlet_bcs, Outlet_bcs, Settings, Clearance, Domain, read_agf, plot_airfoil_inputs, plot_airfoil_inputs_2D
+
+# turbodesign/__init__.py
+from importlib import import_module
+
+__all__ = [
+    "TurbineSpool", "Stage", "Inlet", "Outlet", "BladeRow", "Coolant",
+    "Passage", "RowType", "PassageType", "LossType",
+    "LossInterp", "DeviationBaseClass", "FixedDeviation",
+    "make_blade_row", "make_rotor_row", "make_stator_row",
+    "FixedPolytropicEfficiency",
+    "AGF_Setup", "Inlet_bcs", "Outlet_bcs", "Settings", "Clearance", "Domain", "read_agf",
+    "plot_airfoil_inputs", "plot_airfoil_inputs_2D",
+]
+
+_module_map = {
+    "TurbineSpool": ("turbodesign.turbine_spool", "TurbineSpool"),
+    "Stage": ("turbodesign.stage", "Stage"),
+    "Inlet": ("turbodesign.inlet", "Inlet"),
+    "Outlet": ("turbodesign.outlet", "Outlet"),
+    "BladeRow": ("turbodesign.bladerow", "BladeRow"),
+    "Coolant": ("turbodesign.coolant", "Coolant"),
+    "Passage": ("turbodesign.passage", "Passage"),
+    "LossType": ("turbodesign.enums", "LossType"),
+    "RowType": ("turbodesign.enums", "RowType"),
+    "PassageType": ("turbodesign.enums", "PassageType"),
+    "LossInterp": ("turbodesign.lossinterp", "LossInterp"),
+    "FixedPolytropicEfficiency": ("turbodesign.loss.fixedpolytropic", "FixedPolytropicEfficiency"),
+    "DeviationBaseClass": ("turbodesign.deviation", "DeviationBaseClass"),
+    "FixedDeviation": ("turbodesign.deviation", "FixedDeviation"),
+    "make_blade_row": ("turbodesign.row_factory", "make_blade_row"),
+    "make_rotor_row": ("turbodesign.row_factory", "make_rotor_row"),
+    "make_stator_row": ("turbodesign.row_factory", "make_stator_row"),
+    "AGF_Setup": ("turbodesign.agf", "AGF_Setup"),
+    "Inlet_bcs": ("turbodesign.agf", "Inlet_bcs"),
+    "Outlet_bcs": ("turbodesign.agf", "Outlet_bcs"),
+    "Settings": ("turbodesign.agf", "Settings"),
+    "Clearance": ("turbodesign.agf", "Clearance"),
+    "Domain": ("turbodesign.agf", "Domain"),
+    "read_agf": ("turbodesign.agf", "read_agf"),
+    "plot_airfoil_inputs": ("turbodesign.agf", "plot_airfoil_inputs"),
+    "plot_airfoil_inputs_2D": ("turbodesign.agf", "plot_airfoil_inputs_2D"),
+}
+
+def __getattr__(name: str):
+    try:
+        mod_name, attr = _module_map[name]
+    except KeyError:
+        raise AttributeError(name)
+    mod = import_module(mod_name)
+    return getattr(mod, attr)

turbodesign/agf.py

@@ -0,0 +1,346 @@
+"""AGF generation and parsing utilities."""
+
+from dataclasses import dataclass, asdict
+from typing import List
+
+import numpy as np
+import numpy.typing as npt
+import matplotlib.pyplot as plt
+
+
+@dataclass
+class Inlet_bcs:
+    ptin: float
+    ttin: float
+    pspan: float
+    machin: float
+    alpin: float
+    phiin: float
+
+
+@dataclass
+class Outlet_bcs:
+    rpm: float
+    gamma: float
+    psout: float
+    twall: float
+    molwt: float
+
+
+@dataclass
+class Domain:
+    xhup: float  # xhub upstream
+    rhup: float  # rhub upstream
+    xtup: float  # xtip upstream
+    rtup: float  # rtip upstream
+
+    xhdw: float  # xhub downwind
+    rhdw: float  # rhub downwind
+    xtdw: float  # xtip downwind
+    rtdw: float  # rtip downwind
+
+
+@dataclass
+class Settings:
+    nprof: int = 1  # number of spanwise points that define pitched average inlet profile
+    ifang: int = 10  # 0 - adiabatic wall, 1 - temperature wall
+    hbl: float = 1  # Inlet hub boundary layer thickness as percent span
+    tbl: float = 1  # Inlet tip boundary layer thickness as percent span
+
+    nblades: int = 8  # number of blades
+    npts: int = 300  # number of points per blade
+    nspans: int = 3  # number of spans/sections
+    ity: int = 5  # What format are the blades in.
+    # ITY 5 = x rth r
+    # ITY 7 = x1,theta1,r1,x2,theta2,r2
+    # ITY 10 = x1,y1,z1,x2,y2,z2
+    iym: int = 0  # 0 = do not flip airfoil along x-axis
+    tcls: int = 1  # 1 = has tip clearance
+    hcls: int = 0  # 0 = no hub clearance
+    lete: int = 10  # do not modify leading edge or trailing edge
+    isplit: int = 0  # no splitters
+
+    nht: int = 1  # Number of axial points defining the endwall
+
+
+@dataclass
+class Clearance:
+    tlecl: float  # tip leading edge clearance
+    tmccl: float  # tip mid clearance
+    ttecl: float  # tip te clearance
+    hlecl: float = 0  # hub le clearance
+    hmccl: float = 0  # hub mid clearance
+    htecl: float = 0  # hub te clearance
+
+
+class AGF_Setup:
+    def __init__(self, template_file: str = "template.agf", name="radial-turbine"):
+        self.agf_template = template_file
+        self.name = name
+        self.endwall: str = ""
+        self.sections: str = ""
+        self.clearance: Clearance
+        self.settings: Settings
+        self.domain: Domain
+        self.inlet: Inlet_bcs
+        self.outlet: Outlet_bcs
+
+    def add_passage(self, hub: npt.NDArray, shroud: npt.NDArray):
+        """Add passage hub/shroud geometry."""
+        domain = Domain(
+            xhup=hub[0, 0],
+            rhup=hub[0, 1],
+            xtup=shroud[0, 0],
+            rtup=shroud[0, 1],
+            xhdw=hub[-1, 0],
+            rhdw=hub[-1, 1],
+            xtdw=shroud[-1, 0],
+            rtdw=shroud[-1, 1],
+        )
+        endwall = []
+        for i in range(hub.shape[0]):
+            xl = hub[i, 0]
+            rl = hub[i, 1]
+            xu = shroud[i, 0]
+            ru = shroud[i, 1]
+            if i < hub.shape[0] - 1:
+                endwall.append(f"{xl:.4f}   {rl:.4f}   {xu:.4f}   {ru:.4f}\n")
+            else:
+                endwall.append(f"{xl:.4f}   {rl:.4f}   {xu:.4f}   {ru:.4f}")
+        self.endwall = "".join(endwall)
+        self.domain = domain
+        self.settings.nht = hub.shape[0]
+
+    def add_blade(self, ss: npt.NDArray, ps: npt.NDArray, IsDuct: bool = False):
+        """Add the blade geometry."""
+        sections = []
+        if IsDuct:
+            self.settings.nspans = 0
+        else:
+            self.settings.nspans = ss.shape[0]
+        section_indx = 1
+
+        for i in range(ss.shape[0]):
+            x = np.hstack([ss[i, :, 0], ps[i, 1:-1, 0]])
+            y = np.hstack([ss[i, :, 1], ps[i, 1:-1, 1]])
+            z = np.hstack([ss[i, :, 2], ps[i, 1:-1, 2]])
+            n = len(x)  # number of points
+            self.settings.npts = n
+            r = np.sqrt(y**2 + z**2)
+            th = np.arctan2(y, z)
+            rth = r * th
+            sections.append(f"*SECTION\t{section_indx}\n")
+            sections.append(f"- SECTION - {section_indx}\t{n}\n")
+            sections.append(">----RAD------XOFF------YOFF------ROTD----CONEANGLE----\n")
+            sections.append("0.0000\t0.0000\t0.0000\t0.0000\t0.0000\n")
+            sections.append("x       rth        r\n")
+            for j in range(len(x)):
+                sections.append(f"{x[j]:0.6f}    {rth[j]:0.6f}    {r[j]:0.6f}\n")
+            section_indx += 1
+
+        self.sections = "".join(sections)
+
+    def add_clearance(self, clearance: Clearance):
+        self.clearance = clearance
+
+    def add_settings(self, settings: Settings):
+        self.settings = settings
+
+    def add_inlet(self, inlet: Inlet_bcs):
+        self.inlet = inlet
+
+    def add_outlet(self, outlet: Outlet_bcs):
+        self.outlet = outlet
+
+    def build(self, output_filename: str = "stator.agf"):
+        with open(self.agf_template, "r") as file:
+            file_content = file.read()
+            file_content = file_content.replace("[name]", f"{self.name}")
+
+            domain_dict = asdict(self.domain)
+            clearance_dict = asdict(self.clearance)
+            settings_dict = asdict(self.settings)
+            inlet_dict = asdict(self.inlet)
+            outlet_dict = asdict(self.outlet)
+
+            with open(output_filename, "w") as f:
+                for k, v in domain_dict.items():
+                    file_content = file_content.replace(f"[{k}]", f"{v:0.4f}")
+
+                for k, v in clearance_dict.items():
+                    file_content = file_content.replace(f"[{k}]", f"{v}")
+
+                for k, v in settings_dict.items():
+                    file_content = file_content.replace(f"[{k}]", f"{v}")
+
+                for k, v in inlet_dict.items():
+                    file_content = file_content.replace(f"[{k}]", f"{v:0.4f}")
+
+                for k, v in outlet_dict.items():
+                    file_content = file_content.replace(f"[{k}]", f"{v:0.4f}")
+
+                if self.sections:
+                    file_content = file_content.replace("[sections]", self.sections)
+
+                file_content = file_content.replace("[endwall]", self.endwall)
+                f.write(file_content)
+
+
+def read_agf(file_path: str) -> dict:
+    """
+    Parse an AGF file and reconstruct the data classes used to build it.
+
+    Returns:
+        dict with keys:
+            settings (Settings)
+            clearance (Clearance)
+            domain (Domain)
+            inlet (Inlet_bcs)
+            outlet (Outlet_bcs)
+            hub (np.ndarray): shape (nht, 2) of x, r (hub)
+            shroud (np.ndarray): shape (nht, 2) of x, r (shroud)
+            sections (np.ndarray): shape (n_sections, npts, 3) of x, rth, r
+    """
+    with open(file_path, "r") as f:
+        lines = [ln.strip() for ln in f.readlines()]
+
+    def find_after(marker: str) -> List[str]:
+        for idx, ln in enumerate(lines):
+            if ln.startswith(marker):
+                return lines[idx + 1].split()
+        return []
+
+    # Settings and counts
+    nb_vals = find_after("*NBLADE")
+    nblades, npts, nspans, ity, iym, tcls, hcls, lete, isplit = [int(float(v)) for v in nb_vals]
+
+    units_vals = find_after("*UNITS")
+    _, nprof, ifang, hbl, tbl, tfree, lfree = units_vals
+    nprof = int(nprof)
+    ifang = int(ifang)
+
+    settings = Settings(
+        nprof=nprof,
+        ifang=ifang,
+        hbl=float(hbl),
+        tbl=float(tbl),
+        nblades=nblades,
+        npts=npts,
+        nspans=nspans,
+        ity=int(ity),
+        iym=int(iym),
+        tcls=int(tcls),
+        hcls=int(hcls),
+        lete=int(lete),
+        isplit=int(isplit),
+    )
+
+    rpm_vals = find_after("*RPMS")
+    rpm, gamma, psout, twall, molwt = [float(v) for v in rpm_vals]
+    outlet = Outlet_bcs(rpm=rpm, gamma=gamma, psout=psout, twall=twall, molwt=molwt)
+
+    pspan_vals = find_after("*PSPAN")
+    pspan, machin, ptin, ttin, alpin, phiin = [float(v) for v in pspan_vals]
+    inlet = Inlet_bcs(ptin=ptin, ttin=ttin, pspan=pspan, machin=machin, alpin=alpin, phiin=phiin)
+
+    xhup_vals = find_after("*XHUP")
+    xhup, rhup, xtup, rtup = [float(v) for v in xhup_vals]
+    xhdw_vals = find_after("*XHDW")
+    xhdw, rhdw, xtdw, rtdw = [float(v) for v in xhdw_vals]
+    domain = Domain(xhup=xhup, rhup=rhup, xtup=xtup, rtup=rtup, xhdw=xhdw, rhdw=rhdw, xtdw=xtdw, rtdw=rtdw)
+
+    tlecl_vals = find_after("*TLECL")
+    hlecl_vals = find_after("*HLECL")
+    clearance = Clearance(
+        tlecl=float(tlecl_vals[0]) if tlecl_vals else 0.0,
+        tmccl=float(tlecl_vals[1]) if len(tlecl_vals) > 1 else 0.0,
+        ttecl=float(tlecl_vals[2]) if len(tlecl_vals) > 2 else 0.0,
+        hlecl=float(hlecl_vals[0]) if hlecl_vals else 0.0,
+        hmccl=float(hlecl_vals[1]) if len(hlecl_vals) > 1 else 0.0,
+        htecl=float(hlecl_vals[2]) if len(hlecl_vals) > 2 else 0.0,
+    )
+
+    nht_vals = find_after("*NHT")
+    if nht_vals:
+        settings.nht = int(float(nht_vals[0]))
+
+    # Endwall parsing
+    hub_pts: List[List[float]] = []
+    shroud_pts: List[List[float]] = []
+    if "*ENDWALL" in lines:
+        start = lines.index("*ENDWALL") + 2  # skip header and column line
+        idx = start
+        while idx < len(lines) and not lines[idx].startswith("*SECTION"):
+            parts = [p for p in lines[idx].split() if p]
+            if len(parts) == 4:
+                xl, rl, xu, ru = [float(p) for p in parts]
+                hub_pts.append([xl, rl])
+                shroud_pts.append([xu, ru])
+            idx += 1
+    hub_arr = np.array(hub_pts) if hub_pts else np.zeros((0, 2))
+    shroud_arr = np.array(shroud_pts) if shroud_pts else np.zeros((0, 2))
+
+    # Sections parsing
+    sections: List[np.ndarray] = []
+    idx = 0
+    while idx < len(lines):
+        line = lines[idx]
+        if line.startswith("*SECTION"):
+            idx += 1  # - SECTION - line
+            section_info = lines[idx].split()
+            npts_section = int(section_info[-1])
+            idx += 3  # skip offset/cone headers to column header
+            idx += 1  # column header line
+            pts = []
+            for _ in range(npts_section):
+                parts = lines[idx].split()
+                if len(parts) >= 3:
+                    pts.append([float(parts[0]), float(parts[1]), float(parts[2])])
+                idx += 1
+            sections.append(np.array(pts))
+            continue
+        idx += 1
+
+    sections_arr = np.array(sections) if sections else np.zeros((0, 0, 3))
+
+    return {
+        "settings": settings,
+        "clearance": clearance,
+        "domain": domain,
+        "inlet": inlet,
+        "outlet": outlet,
+        "hub": hub_arr,
+        "shroud": shroud_arr,
+        "sections": sections_arr,
+    }
+
+
+def plot_airfoil_inputs(nsections: int, npts: int):
+    xthr = np.zeros(shape=(nsections, npts, 3))  # section_num x theta r
+    with open("AIRFOIL.INPUTS", "r") as f:
+        [f.readline() for _ in range(4)]  # skip first 4 lines
+        for i in range(nsections):
+            for j in range(npts):
+                line = f.readline()
+                temp = [float(p) for p in line.split(" ") if p]
+                xthr[i, j, 0] = temp[0]
+
+
+def plot_airfoil_inputs_2D(nsections: int, npts: int):
+    xthr = np.zeros(shape=(nsections, npts, 3))
+    with open("AIRFOIL.INPUTS", "r") as f:
+        [f.readline() for _ in range(4)]
+        for i in range(nsections):
+            for j in range(npts):
+                line = f.readline()
+                temp = [float(p) for p in line.split(" ") if p]
+                xthr[i, j, 0] = temp[0]
+                xthr[i, j, 1] = temp[1]
+                xthr[i, j, 2] = temp[2]
+            [f.readline() for _ in range(2)]
+    for i in range(nsections):
+        plt.plot(xthr[i, :, 0], xthr[i, :, 1], "r", label=f"section {i}")
+    plt.axis("equal")
+    plt.xlabel("x-axial")
+    plt.ylabel("y")
+    plt.show()

turbodesign/arrayfuncs.py

@@ -12,8 +12,38 @@ def convert_to_ndarray(t) -> np.ndarray:
     Returns:
         np.ndarray: variable as an array
     """
+    if hasattr(t, "default_factory"):
+        try:
+            t = t.default_factory()
+        except Exception:
+            t = np.array([0.0])
     if type(t) is not np.ndarray and type(t) is not list: # Scalar
         t = np.array([t],dtype=float)
     elif (type(t) is list):
         t = np.array(t,dtype=float)
-    return t
+    return t
+
+
+def safe_interpolate(values, src_r, dst_r, default: float = 0.0, radians: bool = False, interp_func=None):
+    """Safely convert, default, and interpolate quantities onto target radii."""
+    from .bladerow import interpolate_quantities  # local import to avoid cycles
+
+    arr = convert_to_ndarray(values)
+    if hasattr(arr, "default_factory"):
+        arr = arr.default_factory()
+    if arr.size == 0:
+        arr = np.array([default], dtype=float)
+    src = convert_to_ndarray(src_r)
+    dst = convert_to_ndarray(dst_r)
+    if src.size == 0:
+        src = np.linspace(0, 1, len(arr))
+    if arr.size > 1 and src.size != arr.size:
+        src = np.linspace(0, 1, len(arr))
+    if arr.size == 1:
+        arr = arr[0] * np.ones_like(dst)
+    else:
+        f = interp_func if interp_func is not None else interpolate_quantities
+        arr = f(arr, src, dst)
+    if radians:
+        arr = np.radians(arr)
+    return arr