engcalc 0.1.0__py3-none-any.whl

engcalc/__init__.py

@@ -0,0 +1,3 @@
+"""engcalc — Mechanical Engineering calculations in Python."""
+
+__version__ = "0.1.0"

engcalc/cycles.py

@@ -0,0 +1,148 @@
+"""Thermodynamic cycle efficiency calculations.
+
+Reference: Cengel & Boles, "Thermodynamics: An Engineering Approach"
+All temperatures must be in Kelvin (K).
+Efficiency is returned as a fraction between 0 and 1 (multiply by 100 for %).
+"""
+
+
+def carnot_efficiency(T_hot: float, T_cold: float) -> float:
+    """Carnot cycle thermal efficiency.
+
+    The Carnot cycle is the most efficient cycle operating between
+    two thermal reservoirs.
+
+    Formula:
+        eta = 1 - T_cold / T_hot
+
+    Args:
+        T_hot: Hot reservoir temperature in Kelvin (K).
+        T_cold: Cold reservoir temperature in Kelvin (K).
+
+    Returns:
+        Thermal efficiency as a fraction (0 to 1).
+
+    Raises:
+        ValueError: If T_hot <= T_cold or T_hot <= 0.
+
+    Example:
+        >>> carnot_efficiency(T_hot=800, T_cold=300)
+        0.625
+    """
+    if T_hot <= 0:
+        raise ValueError("T_hot must be positive (Kelvin).")
+    if T_cold <= 0:
+        raise ValueError("T_cold must be positive (Kelvin).")
+    if T_hot <= T_cold:
+        raise ValueError("T_hot must be greater than T_cold.")
+
+    return 1 - (T_cold / T_hot)
+
+
+def otto_efficiency(compression_ratio: float, gamma: float = 1.4) -> float:
+    """Otto cycle thermal efficiency (petrol engine).
+
+    Formula:
+        eta = 1 - 1 / r^(gamma - 1)
+
+    where:
+        r = compression ratio (V1/V2)
+        gamma = specific heat ratio (Cp/Cv), default 1.4 for air
+
+    Args:
+        compression_ratio: Compression ratio r (> 1).
+        gamma: Specific heat ratio, default 1.4 for air.
+
+    Returns:
+        Thermal efficiency as a fraction (0 to 1).
+
+    Raises:
+        ValueError: If compression_ratio <= 1 or gamma <= 1.
+
+    Example:
+        >>> otto_efficiency(compression_ratio=8)
+        0.5647...
+    """
+    if compression_ratio <= 1:
+        raise ValueError("Compression ratio must be greater than 1.")
+    if gamma <= 1:
+        raise ValueError("Gamma must be greater than 1.")
+
+    return 1 - 1 / (compression_ratio ** (gamma - 1))
+
+
+def diesel_efficiency(
+    compression_ratio: float,
+    cutoff_ratio: float,
+    gamma: float = 1.4,
+) -> float:
+    """Diesel cycle thermal efficiency.
+
+    Formula:
+        eta = 1 - (1 / r^(gamma-1)) * (rc^gamma - 1) / (gamma * (rc - 1))
+
+    where:
+        r = compression ratio
+        rc = cutoff ratio (V3/V2)
+        gamma = specific heat ratio
+
+    Args:
+        compression_ratio: Compression ratio r (> 1).
+        cutoff_ratio: Cutoff ratio rc (> 1).
+        gamma: Specific heat ratio, default 1.4 for air.
+
+    Returns:
+        Thermal efficiency as a fraction (0 to 1).
+
+    Raises:
+        ValueError: If inputs are out of valid range.
+
+    Example:
+        >>> diesel_efficiency(compression_ratio=18, cutoff_ratio=2)
+        0.631...
+    """
+    if compression_ratio <= 1:
+        raise ValueError("Compression ratio must be greater than 1.")
+    if cutoff_ratio <= 1:
+        raise ValueError("Cutoff ratio must be greater than 1.")
+    if gamma <= 1:
+        raise ValueError("Gamma must be greater than 1.")
+
+    r = compression_ratio
+    rc = cutoff_ratio
+
+    term1 = 1 / (r ** (gamma - 1))
+    term2 = (rc**gamma - 1) / (gamma * (rc - 1))
+
+    return 1 - term1 * term2
+
+
+def brayton_efficiency(pressure_ratio: float, gamma: float = 1.4) -> float:
+    """Brayton cycle thermal efficiency (gas turbine).
+
+    Formula:
+        eta = 1 - 1 / rp^((gamma-1)/gamma)
+
+    where:
+        rp = pressure ratio (P2/P1)
+
+    Args:
+        pressure_ratio: Pressure ratio rp (> 1).
+        gamma: Specific heat ratio, default 1.4 for air.
+
+    Returns:
+        Thermal efficiency as a fraction (0 to 1).
+
+    Raises:
+        ValueError: If inputs are out of valid range.
+
+    Example:
+        >>> brayton_efficiency(pressure_ratio=10)
+        0.482...
+    """
+    if pressure_ratio <= 1:
+        raise ValueError("Pressure ratio must be greater than 1.")
+    if gamma <= 1:
+        raise ValueError("Gamma must be greater than 1.")
+
+    return 1 - 1 / (pressure_ratio ** ((gamma - 1) / gamma))

engcalc/data/materials.json

@@ -0,0 +1,122 @@
+{
+  "steel_AISI_1018": {
+    "name": "AISI 1018 Carbon Steel",
+    "category": "steel",
+    "density": 7870,
+    "youngs_modulus": 205e9,
+    "poisson_ratio": 0.29,
+    "thermal_conductivity": 51.9,
+    "specific_heat": 486,
+    "thermal_expansion": 11.7e-6,
+    "yield_strength": 370e6,
+    "ultimate_strength": 440e6
+  },
+  "steel_AISI_1040": {
+    "name": "AISI 1040 Carbon Steel",
+    "category": "steel",
+    "density": 7850,
+    "youngs_modulus": 200e9,
+    "poisson_ratio": 0.29,
+    "thermal_conductivity": 50.7,
+    "specific_heat": 490,
+    "thermal_expansion": 11.3e-6,
+    "yield_strength": 415e6,
+    "ultimate_strength": 620e6
+  },
+  "steel_AISI_4140": {
+    "name": "AISI 4140 Alloy Steel",
+    "category": "steel",
+    "density": 7850,
+    "youngs_modulus": 205e9,
+    "poisson_ratio": 0.29,
+    "thermal_conductivity": 42.6,
+    "specific_heat": 473,
+    "thermal_expansion": 12.2e-6,
+    "yield_strength": 655e6,
+    "ultimate_strength": 1020e6
+  },
+  "steel_SS_304": {
+    "name": "Stainless Steel 304",
+    "category": "steel",
+    "density": 8000,
+    "youngs_modulus": 193e9,
+    "poisson_ratio": 0.29,
+    "thermal_conductivity": 16.2,
+    "specific_heat": 500,
+    "thermal_expansion": 17.3e-6,
+    "yield_strength": 215e6,
+    "ultimate_strength": 505e6
+  },
+  "steel_SS_316": {
+    "name": "Stainless Steel 316",
+    "category": "steel",
+    "density": 8000,
+    "youngs_modulus": 193e9,
+    "poisson_ratio": 0.27,
+    "thermal_conductivity": 16.3,
+    "specific_heat": 500,
+    "thermal_expansion": 16.0e-6,
+    "yield_strength": 205e6,
+    "ultimate_strength": 515e6
+  },
+  "aluminum_6061_T6": {
+    "name": "Aluminum 6061-T6",
+    "category": "aluminum",
+    "density": 2700,
+    "youngs_modulus": 68.9e9,
+    "poisson_ratio": 0.33,
+    "thermal_conductivity": 167,
+    "specific_heat": 896,
+    "thermal_expansion": 23.6e-6,
+    "yield_strength": 276e6,
+    "ultimate_strength": 310e6
+  },
+  "aluminum_7075_T6": {
+    "name": "Aluminum 7075-T6",
+    "category": "aluminum",
+    "density": 2810,
+    "youngs_modulus": 71.7e9,
+    "poisson_ratio": 0.33,
+    "thermal_conductivity": 130,
+    "specific_heat": 960,
+    "thermal_expansion": 23.6e-6,
+    "yield_strength": 503e6,
+    "ultimate_strength": 572e6
+  },
+  "copper_C11000": {
+    "name": "Copper C11000 (ETP)",
+    "category": "copper",
+    "density": 8940,
+    "youngs_modulus": 117e9,
+    "poisson_ratio": 0.34,
+    "thermal_conductivity": 401,
+    "specific_heat": 385,
+    "thermal_expansion": 17.0e-6,
+    "yield_strength": 69e6,
+    "ultimate_strength": 220e6
+  },
+  "titanium_Ti_6Al_4V": {
+    "name": "Titanium Ti-6Al-4V",
+    "category": "titanium",
+    "density": 4430,
+    "youngs_modulus": 113.8e9,
+    "poisson_ratio": 0.342,
+    "thermal_conductivity": 6.7,
+    "specific_heat": 526,
+    "thermal_expansion": 8.6e-6,
+    "yield_strength": 880e6,
+    "ultimate_strength": 950e6
+  },
+  "cast_iron_gray": {
+    "name": "Gray Cast Iron",
+    "category": "cast_iron",
+    "density": 7200,
+    "youngs_modulus": 100e9,
+    "poisson_ratio": 0.29,
+    "thermal_conductivity": 52,
+    "specific_heat": 490,
+    "thermal_expansion": 10.8e-6,
+    "yield_strength": null,
+    "ultimate_strength": 150e6
+  }
+}

engcalc/fluids.py

@@ -0,0 +1,182 @@
+"""Fluid mechanics calculations.
+
+Reference: Munson et al., "Fundamentals of Fluid Mechanics"
+All values in SI units unless stated otherwise.
+"""
+
+import math
+
+
+def reynolds_number(
+    rho: float,
+    velocity: float,
+    diameter: float,
+    mu: float,
+) -> float:
+    """Reynolds number for pipe flow.
+
+    Formula:
+        Re = (rho * v * D) / mu
+
+    Args:
+        rho: Fluid density (kg/m^3).
+        velocity: Flow velocity (m/s).
+        diameter: Pipe inner diameter (m).
+        mu: Dynamic viscosity (Pa·s).
+
+    Returns:
+        Reynolds number (dimensionless).
+
+    Raises:
+        ValueError: If mu <= 0 or any input is negative.
+
+    Example:
+        >>> reynolds_number(rho=1000, velocity=2, diameter=0.05, mu=0.001)
+        100000.0
+    """
+    if rho < 0 or velocity < 0 or diameter < 0:
+        raise ValueError("rho, velocity, diameter must be non-negative.")
+    if mu <= 0:
+        raise ValueError("Dynamic viscosity must be positive.")
+    return (rho * velocity * diameter) / mu
+
+
+def flow_regime(Re: float) -> str:
+    """Classify flow regime based on Reynolds number.
+
+    Args:
+        Re: Reynolds number.
+
+    Returns:
+        "laminar" (Re < 2300), "transitional" (2300 ≤ Re < 4000),
+        or "turbulent" (Re ≥ 4000).
+
+    Example:
+        >>> flow_regime(1500)
+        'laminar'
+        >>> flow_regime(5000)
+        'turbulent'
+    """
+    if Re < 2300:
+        return "laminar"
+    elif Re < 4000:
+        return "transitional"
+    else:
+        return "turbulent"
+
+
+def bernoulli_pressure(
+    P1: float,
+    v1: float,
+    h1: float,
+    v2: float,
+    h2: float,
+    rho: float,
+    g: float = 9.81,
+) -> float:
+    """Bernoulli equation: find P2 given state 1 and velocity/elevation at state 2.
+
+    Formula (incompressible, no losses):
+        P1 + 0.5*rho*v1^2 + rho*g*h1 = P2 + 0.5*rho*v2^2 + rho*g*h2
+
+    Args:
+        P1: Pressure at point 1 (Pa).
+        v1: Velocity at point 1 (m/s).
+        h1: Elevation at point 1 (m).
+        v2: Velocity at point 2 (m/s).
+        h2: Elevation at point 2 (m).
+        rho: Fluid density (kg/m^3).
+        g: Gravitational acceleration (m/s^2), default 9.81.
+
+    Returns:
+        Pressure at point 2 (Pa).
+
+    Raises:
+        ValueError: If rho <= 0.
+
+    Example:
+        >>> bernoulli_pressure(P1=101325, v1=0, h1=0, v2=5, h2=0, rho=1000)
+        88825.0
+    """
+    if rho <= 0:
+        raise ValueError("Density must be positive.")
+    return (
+        P1
+        + 0.5 * rho * (v1**2 - v2**2)
+        + rho * g * (h1 - h2)
+    )
+
+
+def darcy_weisbach_head_loss(
+    f: float,
+    L: float,
+    D: float,
+    velocity: float,
+    g: float = 9.81,
+) -> float:
+    """Darcy-Weisbach head loss in a pipe.
+
+    Formula:
+        h_f = f * (L/D) * (v^2 / (2*g))
+
+    Args:
+        f: Darcy friction factor (dimensionless).
+        L: Pipe length (m).
+        D: Pipe inner diameter (m).
+        velocity: Flow velocity (m/s).
+        g: Gravitational acceleration (m/s^2), default 9.81.
+
+    Returns:
+        Head loss (m).
+
+    Raises:
+        ValueError: If D <= 0 or f < 0.
+
+    Example:
+        >>> darcy_weisbach_head_loss(f=0.02, L=100, D=0.05, velocity=2)
+        8.154...
+    """
+    if D <= 0:
+        raise ValueError("Diameter must be positive.")
+    if f < 0:
+        raise ValueError("Friction factor must be non-negative.")
+    return f * (L / D) * (velocity**2 / (2 * g))
+
+
+def pump_power(
+    rho: float,
+    g: float,
+    Q: float,
+    head: float,
+    efficiency: float = 1.0,
+) -> float:
+    """Hydraulic power required by a pump.
+
+    Formula:
+        P_hydraulic = rho * g * Q * H
+        P_shaft = P_hydraulic / efficiency
+
+    Args:
+        rho: Fluid density (kg/m^3).
+        g: Gravitational acceleration (m/s^2).
+        Q: Volumetric flow rate (m^3/s).
+        head: Pump head (m).
+        efficiency: Pump efficiency (0 < eta <= 1), default 1.0.
+
+    Returns:
+        Shaft power required (W).
+
+    Raises:
+        ValueError: If efficiency not in (0, 1] or inputs invalid.
+
+    Example:
+        >>> pump_power(rho=1000, g=9.81, Q=0.01, head=10, efficiency=0.8)
+        1226.25
+    """
+    if rho <= 0 or g <= 0 or Q < 0 or head < 0:
+        raise ValueError("Invalid input: rho, g must be positive; Q, head non-negative.")
+    if not (0 < efficiency <= 1):
+        raise ValueError("Efficiency must be in (0, 1].")
+
+    P_hydraulic = rho * g * Q * head
+    return P_hydraulic / efficiency

engcalc/heat.py

@@ -0,0 +1,152 @@
+"""Heat transfer calculations.
+
+Reference: Incropera et al., "Fundamentals of Heat and Mass Transfer"
+All values in SI units.
+"""
+
+
+def conduction_rate(
+    k: float,
+    A: float,
+    dT: float,
+    L: float,
+) -> float:
+    """Fourier's law of conduction through a plane wall.
+
+    Formula:
+        Q = k * A * dT / L
+
+    Args:
+        k: Thermal conductivity (W/(m·K)).
+        A: Cross-sectional area (m^2).
+        dT: Temperature difference (K).
+        L: Wall thickness (m).
+
+    Returns:
+        Heat transfer rate (W).
+
+    Raises:
+        ValueError: If L <= 0 or k < 0 or A < 0.
+
+    Example:
+        >>> conduction_rate(k=50, A=2, dT=100, L=0.1)
+        100000.0
+    """
+    if L <= 0:
+        raise ValueError("Thickness L must be positive.")
+    if k < 0 or A < 0:
+        raise ValueError("k and A must be non-negative.")
+    return k * A * dT / L
+
+
+def convection_rate(
+    h: float,
+    A: float,
+    T_surface: float,
+    T_fluid: float,
+) -> float:
+    """Newton's law of cooling for convection.
+
+    Formula:
+        Q = h * A * (T_surface - T_fluid)
+
+    Args:
+        h: Convective heat transfer coefficient (W/(m^2·K)).
+        A: Surface area (m^2).
+        T_surface: Surface temperature (K or °C).
+        T_fluid: Fluid temperature (K or °C).
+
+    Returns:
+        Heat transfer rate (W).
+
+    Raises:
+        ValueError: If h < 0 or A < 0.
+
+    Example:
+        >>> convection_rate(h=25, A=2, T_surface=350, T_fluid=300)
+        2500.0
+    """
+    if h < 0 or A < 0:
+        raise ValueError("h and A must be non-negative.")
+    return h * A * (T_surface - T_fluid)
+
+
+def radiation_rate(
+    emissivity: float,
+    A: float,
+    T_surface: float,
+    T_surroundings: float,
+    sigma: float = 5.67e-8,
+) -> float:
+    """Stefan-Boltzmann law for radiation heat transfer.
+
+    Formula:
+        Q = emissivity * sigma * A * (T_surface^4 - T_surroundings^4)
+
+    Args:
+        emissivity: Surface emissivity (0 to 1).
+        A: Surface area (m^2).
+        T_surface: Surface temperature (K).
+        T_surroundings: Surrounding temperature (K).
+        sigma: Stefan-Boltzmann constant (W/(m^2·K^4)), default 5.67e-8.
+
+    Returns:
+        Net radiation heat transfer rate (W).
+
+    Raises:
+        ValueError: If emissivity not in [0, 1], or temperatures negative.
+
+    Example:
+        >>> radiation_rate(emissivity=0.9, A=1, T_surface=500, T_surroundings=300)
+        2892.9...
+    """
+    if not (0 <= emissivity <= 1):
+        raise ValueError("Emissivity must be between 0 and 1.")
+    if T_surface < 0 or T_surroundings < 0:
+        raise ValueError("Temperatures must be non-negative (Kelvin).")
+    return emissivity * sigma * A * (T_surface**4 - T_surroundings**4)
+
+
+def lmtd(
+    T_hot_in: float,
+    T_hot_out: float,
+    T_cold_in: float,
+    T_cold_out: float,
+) -> float:
+    """Log Mean Temperature Difference for heat exchangers.
+
+    Formula:
+        dT1 = T_hot_in - T_cold_out
+        dT2 = T_hot_out - T_cold_in
+        LMTD = (dT1 - dT2) / ln(dT1 / dT2)
+
+    If dT1 ≈ dT2, returns dT1 (limit case).
+
+    Args:
+        T_hot_in: Hot fluid inlet temperature.
+        T_hot_out: Hot fluid outlet temperature.
+        T_cold_in: Cold fluid inlet temperature.
+        T_cold_out: Cold fluid outlet temperature.
+
+    Returns:
+        LMTD in same units as inputs.
+
+    Raises:
+        ValueError: If dT1 <= 0 or dT2 <= 0 (invalid exchanger).
+
+    Example:
+        >>> lmtd(T_hot_in=400, T_hot_out=350, T_cold_in=300, T_cold_out=330)
+        59.44...
+    """
+    dT1 = T_hot_in - T_cold_out
+    dT2 = T_hot_out - T_cold_in
+
+    if dT1 <= 0 or dT2 <= 0:
+        raise ValueError("Temperature differences must be positive.")
+
+    # Handle equal case (limit)
+    if abs(dT1 - dT2) < 1e-9:
+        return dT1
+
+    import math
+    return (dT1 - dT2) / math.log(dT1 / dT2)

engcalc/ideal_gas.py

@@ -0,0 +1,36 @@
+"""Ideal gas law calculations.
+
+The ideal gas law: PV = nRT
+where:
+    P = pressure (Pa)
+    V = volume (m^3)
+    n = amount of substance (mol)
+    R = universal gas constant (8.314 J/(mol·K))
+    T = absolute temperature (K)
+"""
+
+# Universal gas constant in SI units: J/(mol·K)
+R = 8.314462618
+
+
+def pressure(n: float, T: float, V: float) -> float:
+    """Calculate pressure using ideal gas law: P = nRT/V.
+
+    Args:
+        n: Amount of substance in moles (mol).
+        T: Absolute temperature in Kelvin (K).
+        V: Volume in cubic meters (m^3).
+
+    Returns:
+        Pressure in Pascals (Pa).
+
+    Raises:
+        ValueError: If V is zero or negative.
+
+    Example:
+        >>> pressure(n=1, T=300, V=0.024)
+        103930.782725
+    """
+    if V <= 0:
+        raise ValueError("Volume must be positive.")
+    return (n * R * T) / V

engcalc/materials.py

@@ -0,0 +1,133 @@
+"""Material property database for engineering calculations.
+
+Data is loaded from a bundled JSON file. Properties are typical
+textbook values — verify against manufacturer datasheets before
+critical design use.
+
+All values in SI units:
+    density             : kg/m^3
+    youngs_modulus      : Pa
+    poisson_ratio       : dimensionless
+    thermal_conductivity: W/(m·K)
+    specific_heat       : J/(kg·K)
+    thermal_expansion   : 1/K
+    yield_strength      : Pa
+    ultimate_strength   : Pa
+"""
+
+import json
+from pathlib import Path
+from typing import Any
+
+# Load material data once at import time
+_DATA_FILE = Path(__file__).parent / "data" / "materials.json"
+
+with open(_DATA_FILE, encoding="utf-8") as f:
+    _MATERIALS: dict[str, dict[str, Any]] = json.load(f)
+
+
+def list_materials() -> list[str]:
+    """Return a sorted list of all available material keys.
+
+    Returns:
+        List of material IDs.
+
+    Example:
+        >>> "steel_AISI_1040" in list_materials()
+        True
+    """
+    return sorted(_MATERIALS.keys())
+
+
+def get(material: str, property_name: str) -> float:
+    """Get a single property of a material.
+
+    Args:
+        material: Material key (see list_materials()).
+        property_name: Property name, e.g. "density", "youngs_modulus".
+
+    Returns:
+        Property value in SI units.
+
+    Raises:
+        KeyError: If material or property does not exist.
+        ValueError: If property value is None (not available).
+
+    Example:
+        >>> get("steel_AISI_1040", "density")
+        7850
+    """
+    if material not in _MATERIALS:
+        raise KeyError(
+            f"Unknown material: '{material}'. "
+            f"Use list_materials() to see available options."
+        )
+
+    props = _MATERIALS[material]
+
+    if property_name not in props:
+        raise KeyError(
+            f"Material '{material}' has no property '{property_name}'. "
+            f"Available: {sorted(props.keys())}"
+        )
+
+    value = props[property_name]
+
+    if value is None:
+        raise ValueError(
+            f"Property '{property_name}' is not available for '{material}'."
+        )
+
+    return value
+
+
+def get_all(material: str) -> dict[str, Any]:
+    """Get all properties of a material as a dictionary.
+
+    Args:
+        material: Material key.
+
+    Returns:
+        Dictionary of all properties.
+
+    Raises:
+        KeyError: If material does not exist.
+
+    Example:
+        >>> props = get_all("aluminum_6061_T6")
+        >>> props["density"]
+        2700
+    """
+    if material not in _MATERIALS:
+        raise KeyError(f"Unknown material: '{material}'.")
+
+    return dict(_MATERIALS[material])
+
+
+def search(category: str) -> list[str]:
+    """Find all materials in a given category.
+
+    Args:
+        category: Category name, e.g. "steel", "aluminum".
+
+    Returns:
+        List of material keys in that category.
+
+    Example:
+        >>> search("aluminum")
+        ['aluminum_6061_T6', 'aluminum_7075_T6']
+    """
+    return sorted(
+        key for key, props in _MATERIALS.items()
+        if props.get("category") == category
+    )
+
+
+def list_categories() -> list[str]:
+    """Return a sorted list of all unique material categories.
+
+    Example:
+        >>> "steel" in list_categories()
+        True
+    """
+    return sorted({props["category"] for props in _MATERIALS.values()})

engcalc/units.py

@@ -0,0 +1,253 @@
+"""Unit conversion utilities for engineering calculations.
+
+A pure-Python alternative to heavier libraries like `pint`, focused on
+the units most commonly used in Mechanical Engineering.
+
+Most categories work by defining a linear factor to a base unit:
+    value_in_base = value * factor
+
+Temperature is special (has an offset), so it uses its own logic.
+
+Example:
+    >>> from engcalc import units
+    >>> units.convert(100, "cm", "m")
+    1.0
+    >>> units.convert(1, "atm", "psi")
+    14.695948775513449
+    >>> units.convert(100, "degC", "K")
+    373.15
+"""
+
+# ---------------------------------------------------------------------------
+# Linear conversion tables
+# Each category's first entry is the base unit with factor 1.0.
+# factor = how many base units in one of this unit
+# ---------------------------------------------------------------------------
+
+_LINEAR_UNITS: dict[str, dict[str, float]] = {
+    "length": {
+        "m": 1.0,
+        "mm": 1e-3,
+        "cm": 1e-2,
+        "km": 1e3,
+        "in": 0.0254,
+        "ft": 0.3048,
+        "yd": 0.9144,
+        "mile": 1609.344,
+    },
+    "mass": {
+        "kg": 1.0,
+        "g": 1e-3,
+        "mg": 1e-6,
+        "lb": 0.45359237,
+        "oz": 0.028349523125,
+        "ton": 1000.0,
+    },
+    "time": {
+        "s": 1.0,
+        "ms": 1e-3,
+        "us": 1e-6,
+        "min": 60.0,
+        "h": 3600.0,
+        "day": 86400.0,
+    },
+    "pressure": {
+        "Pa": 1.0,
+        "kPa": 1e3,
+        "MPa": 1e6,
+        "bar": 1e5,
+        "atm": 101325.0,
+        "psi": 6894.757293168361,
+        "mmHg": 133.322387415,
+        "torr": 133.322368421,
+    },
+    "energy": {
+        "J": 1.0,
+        "kJ": 1e3,
+        "MJ": 1e6,
+        "cal": 4.184,
+        "kcal": 4184.0,
+        "BTU": 1055.05585262,
+        "kWh": 3.6e6,
+        "eV": 1.602176634e-19,
+    },
+    "power": {
+        "W": 1.0,
+        "kW": 1e3,
+        "MW": 1e6,
+        "hp": 745.6998715822702,
+        "BTU/h": 0.2930710701722222,
+    },
+    "force": {
+        "N": 1.0,
+        "kN": 1e3,
+        "lbf": 4.4482216152605,
+        "kgf": 9.80665,
+        "dyne": 1e-5,
+    },
+    "area": {
+        "m^2": 1.0,
+        "mm^2": 1e-6,
+        "cm^2": 1e-4,
+        "km^2": 1e6,
+        "in^2": 0.00064516,
+        "ft^2": 0.09290304,
+        "acre": 4046.8564224,
+    },
+    "volume": {
+        "m^3": 1.0,
+        "L": 1e-3,
+        "mL": 1e-6,
+        "cm^3": 1e-6,
+        "in^3": 1.6387064e-5,
+        "ft^3": 0.028316846592,
+        "gal_US": 3.785411784e-3,
+    },
+    "velocity": {
+        "m/s": 1.0,
+        "km/h": 1.0 / 3.6,
+        "mph": 0.44704,
+        "ft/s": 0.3048,
+        "knot": 0.5144444444444444,
+    },
+    "angle": {
+        "rad": 1.0,
+        "deg": 3.141592653589793 / 180.0,
+        "grad": 3.141592653589793 / 200.0,
+        "turn": 2.0 * 3.141592653589793,
+    },
+}
+
+_TEMPERATURE_UNITS = ("K", "degC", "degF", "degR")
+
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+def _find_category(unit: str) -> str:
+    """Find which category a unit belongs to. Raises KeyError if not found."""
+    if unit in _TEMPERATURE_UNITS:
+        return "temperature"
+    for category, table in _LINEAR_UNITS.items():
+        if unit in table:
+            return category
+    raise KeyError(f"Unknown unit: '{unit}'.")
+
+
+def _to_kelvin(value: float, unit: str) -> float:
+    """Convert a temperature value to Kelvin."""
+    if unit == "K":
+        return value
+    if unit == "degC":
+        return value + 273.15
+    if unit == "degF":
+        return (value - 32.0) * 5.0 / 9.0 + 273.15
+    if unit == "degR":
+        return value * 5.0 / 9.0
+    raise KeyError(f"Unknown temperature unit: '{unit}'.")
+
+
+def _from_kelvin(value: float, unit: str) -> float:
+    """Convert a Kelvin value to another temperature unit."""
+    if unit == "K":
+        return value
+    if unit == "degC":
+        return value - 273.15
+    if unit == "degF":
+        return (value - 273.15) * 9.0 / 5.0 + 32.0
+    if unit == "degR":
+        return value * 9.0 / 5.0
+    raise KeyError(f"Unknown temperature unit: '{unit}'.")
+
+
+# ---------------------------------------------------------------------------
+# Public API
+# ---------------------------------------------------------------------------
+
+def convert(value: float, from_unit: str, to_unit: str) -> float:
+    """Convert a value from one unit to another.
+
+    Args:
+        value: Numeric value to convert.
+        from_unit: Source unit symbol.
+        to_unit: Target unit symbol.
+
+    Returns:
+        Converted value.
+
+    Raises:
+        KeyError: If either unit is unknown.
+        ValueError: If the two units belong to different categories.
+
+    Example:
+        >>> convert(100, "cm", "m")
+        1.0
+        >>> convert(100, "degC", "K")
+        373.15
+        >>> convert(1, "atm", "psi")
+        14.695948775513449
+    """
+    cat_from = _find_category(from_unit)
+    cat_to = _find_category(to_unit)
+
+    if cat_from != cat_to:
+        raise ValueError(
+            f"Cannot convert between '{from_unit}' ({cat_from}) and "
+            f"'{to_unit}' ({cat_to})."
+        )
+
+    if cat_from == "temperature":
+        return _from_kelvin(_to_kelvin(value, from_unit), to_unit)
+
+    factor_from = _LINEAR_UNITS[cat_from][from_unit]
+    factor_to = _LINEAR_UNITS[cat_from][to_unit]
+    return value * factor_from / factor_to
+
+
+def list_categories() -> list[str]:
+    """Return a sorted list of all supported unit categories.
+
+    Example:
+        >>> "length" in list_categories()
+        True
+    """
+    return sorted(list(_LINEAR_UNITS.keys()) + ["temperature"])
+
+
+def list_units(category: str) -> list[str]:
+    """Return all units in a given category.
+
+    Args:
+        category: Category name (see list_categories()).
+
+    Returns:
+        List of unit symbols.
+
+    Raises:
+        KeyError: If category is unknown.
+
+    Example:
+        >>> "m" in list_units("length")
+        True
+        >>> "degC" in list_units("temperature")
+        True
+    """
+    if category == "temperature":
+        return list(_TEMPERATURE_UNITS)
+    if category not in _LINEAR_UNITS:
+        raise KeyError(
+            f"Unknown category: '{category}'. "
+            f"Available: {list_categories()}"
+        )
+    return list(_LINEAR_UNITS[category].keys())
+
+
+def find_category(unit: str) -> str:
+    """Return the category of a given unit.
+
+    Example:
+        >>> find_category("psi")
+        'pressure'
+    """
+    return _find_category(unit)

engcalc-0.1.0.dist-info/METADATA

@@ -0,0 +1,164 @@
+Metadata-Version: 2.5
+Name: engcalc
+Version: 0.1.0
+Summary: Mechanical Engineering calculations in Python
+Author-email: Ankita Das <ankidas687@gmail.com>
+License: MIT
+License-File: LICENSE
+Requires-Python: >=3.10
+Requires-Dist: numpy>=1.24
+Provides-Extra: dev
+Requires-Dist: build>=1.0; extra == 'dev'
+Requires-Dist: pytest>=7.0; extra == 'dev'
+Requires-Dist: twine>=4.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# engcalc
+
+> Mechanical Engineering calculations in Python — fast, tested, and easy to use.
+
+[![Python](https://img.shields.io/badge/python-3.10%2B-blue)](https://www.python.org/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Tests](https://github.com/ankidas687/engcalc/actions/workflows/tests.yml/badge.svg)](https://github.com/ankidas687/engcalc/actions/workflows/tests.yml)
+[![PyPI](https://img.shields.io/badge/PyPI-coming%20soon-orange)]()
+
+`engcalc` is a pure-Python library for common Mechanical Engineering
+calculations — thermodynamics, fluid mechanics, heat transfer,
+material properties, and unit conversions. Designed for students,
+engineers, and researchers who want clean, tested formulas without
+the spreadsheet mess.
+
+## Features
+
+- **Thermodynamics** — ideal gas law, Carnot, Otto, Diesel, Brayton cycles
+- **Fluid Mechanics** — Reynolds number, Bernoulli, Darcy-Weisbach, pump power
+- **Heat Transfer** — conduction, convection, radiation, LMTD
+- **Materials Database** — 10 common engineering materials (steel, aluminum, copper, titanium, cast iron) with 8 properties each
+- **Unit Conversions** — 60+ units across 12 categories (length, mass, time, temperature, pressure, energy, power, force, area, volume, velocity, angle)
+- **SI units** throughout — no unit confusion
+- **Zero heavy dependencies** — only NumPy
+- **Fully type-hinted** and tested (91 tests passing)
+
+## Installation
+
+```bash
+pip install engcalc
+```
+
+> ⚠️ Not yet on PyPI. Install from source for now:
+
+```bash
+git clone https://github.com/ankidas687/engcalc.git
+cd engcalc
+pip install -e .
+```
+
+## Quick Start
+
+```python
+from engcalc import ideal_gas, cycles, fluids, heat, materials, units
+
+# Ideal gas law: PV = nRT
+P = ideal_gas.pressure(n=1, T=300, V=0.024)
+print(f"Pressure: {P:.2f} Pa")            # 103930.78 Pa
+
+# Carnot cycle efficiency
+eta = cycles.carnot_efficiency(T_hot=800, T_cold=300)
+print(f"Carnot efficiency: {eta * 100:.2f}%")   # 62.50%
+
+# Reynolds number
+Re = fluids.reynolds_number(rho=1000, velocity=2, diameter=0.05, mu=0.001)
+print(f"Re = {Re:.0f} → {fluids.flow_regime(Re)}")   # 100000 → turbulent
+
+# Heat conduction through a wall
+Q = heat.conduction_rate(k=50, A=2, dT=100, L=0.1)
+print(f"Heat rate: {Q:.2f} W")            # 100000.00 W
+
+# Material property lookup
+rho = materials.get("steel_AISI_1040", "density")
+print(f"Steel density: {rho} kg/m^3")     # 7850 kg/m^3
+
+# Unit conversion
+temp_K = units.convert(100, "degC", "K")
+print(f"100 °C = {temp_K:.2f} K")         # 373.15 K
+```
+
+## Modules
+
+| Module | Functions | Description |
+|---|---|---|
+| `engcalc.ideal_gas` | `pressure`, `volume`, `temperature`, `moles` | Ideal gas law (PV = nRT) |
+| `engcalc.cycles` | `carnot_efficiency`, `otto_efficiency`, `diesel_efficiency`, `brayton_efficiency` | Thermodynamic cycle efficiencies |
+| `engcalc.fluids` | `reynolds_number`, `flow_regime`, `bernoulli_pressure`, `darcy_weisbach_head_loss`, `pump_power` | Fluid mechanics |
+| `engcalc.heat` | `conduction_rate`, `convection_rate`, `radiation_rate`, `lmtd` | Heat transfer |
+| `engcalc.materials` | `get`, `get_all`, `list_materials`, `search`, `list_categories` | Material property database |
+| `engcalc.units` | `convert`, `list_categories`, `list_units`, `find_category` | Unit conversion utilities |
+
+## Examples
+
+Check the [`examples/`](examples/) folder for complete demo scripts:
+
+- `examples/demo.py` — Ideal gas law
+- `examples/cycles_demo.py` — Thermodynamic cycles
+- `examples/fluids_demo.py` — Fluid mechanics
+- `examples/heat_demo.py` — Heat transfer
+- `examples/materials_demo.py` — Materials database
+- `examples/units_demo.py` — Unit conversions
+
+Run any demo:
+
+```bash
+python examples/cycles_demo.py
+```
+
+## Development
+
+```bash
+# Clone the repo
+git clone https://github.com/ankidas687/engcalc.git
+cd engcalc
+
+# Create virtual environment
+python -m venv venv
+venv\Scripts\Activate.ps1    # Windows
+# source venv/bin/activate   # macOS/Linux
+
+# Install with dev dependencies
+pip install -e ".[dev]"
+
+# Run tests
+pytest
+```
+
+## Contributing
+
+Contributions are welcome! If you find a bug or want to add a new
+calculation, feel free to:
+
+1. Fork the repo
+2. Create a feature branch (`git checkout -b feature/new-formula`)
+3. Commit your changes (`git commit -m "Add new formula"`)
+4. Push to the branch (`git push origin feature/new-formula`)
+5. Open a Pull Request
+
+## Roadmap
+
+- [x] Thermodynamics (ideal gas, cycles)
+- [x] Fluid mechanics
+- [x] Heat transfer
+- [x] Materials database
+- [x] Unit conversion utilities
+- [ ] Mechanics of materials (stress, strain, beam)
+- [ ] Publish to PyPI
+
+## License
+
+This project is licensed under the MIT License — see the [LICENSE](LICENSE) file for details.
+
+## Author
+
+**Ankita Das** — [@ankidas687](https://github.com/ankidas687)
+
+---
+
+⭐ If you find this useful, consider giving it a star!

engcalc-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+engcalc/__init__.py,sha256=4gpIB_W_693axfbDC9LMDHrlsce4EWxhDeQON4Cj4DQ,89
+engcalc/cycles.py,sha256=V2c_LOjNKnHlqz57nfz9kWlYC_peSZKg6RCKMMWzYgY,4145
+engcalc/fluids.py,sha256=pdL-tBQKmxHXIERiwOXvxlWwM9qN1I-T_FbZV-zcNbE,4590
+engcalc/heat.py,sha256=TFTV-6c8AQwW1Pm8tbX7P-OgzRnw4LtYykAn46A9sKw,3967
+engcalc/ideal_gas.py,sha256=i3x5Sq9BxADCVHbz-XMAmDF2-D4oGCFDHSCwv5x7HCI,878
+engcalc/materials.py,sha256=qTo02wPkqKkZJOuk2ZvE0MbhFnC02aaxDnKvOTdgkVE,3456
+engcalc/units.py,sha256=V1PNc01UdjiiaBrkayPY24CN29xExhb5pRSaHMUMhEc,6806
+engcalc/data/materials.json,sha256=VXMnFT5VrgE2yRdOTZ1mUvq_M2xnaxYi4OUKdrrCUiE,3316
+engcalc-0.1.0.dist-info/METADATA,sha256=LV3pBb4YTwBZWfvZNBTskYRqgfph6MDSFAdpUviY93E,5356
+engcalc-0.1.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+engcalc-0.1.0.dist-info/licenses/LICENSE,sha256=U49qDhKdNv6Acfgh5VY-t7aqwT-r1t6wIJ8JQN5In1o,1086
+engcalc-0.1.0.dist-info/RECORD,,

engcalc-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

engcalc-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ankita Das
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.