DEV Community: Reginaldo Leão Jr.

From Rocket Science to Code: 12 Real-World Thermodynamic Notebooks with pyglenn

Reginaldo Leão Jr. — Sat, 14 Nov 2026 21:09:48 +0000

Engineering textbooks routinely introduce gas dynamics under the convenient assumption of constant specific heats. Students memorize that air has a heat capacity ratio ( $γ$ ) of 1.4, calculate cycle efficiencies on a pocket calculator, and move on.

Inside a gas turbine combustor or a rocket nozzle, that simplification collapses. At 1500 K, molecular nitrogen and oxygen absorb energy in quantized vibrational modes. Heat capacity rises, enthalpy curves bend, and thermodynamic efficiency drops below elementary predictions.

Real engineering demands real property data.

While the core pyglenn library packages 2,035 chemical species into a fast, typed SQLite engine, raw property lookups are only the starting line. To show how professional thermal modeling works in practice, Dr. Reginaldo G. Leão Jr. (GESESC / IFMG) assembled pyglenn-notebooks, an open-source collection of twelve self-contained, pre-executed Jupyter notebooks covering combustion, power cycles, chemical equilibrium, and CFD integration.

Here is an architectural tour of what the repository contains, the physical pitfalls it exposes, and how you can run these workflows on your own machine.

The Cold-Air Standard Delusion in Gas Turbines

Notebook 09 tackles a classic aerospace problem: the air-standard Brayton cycle powering jet engines and industrial gas turbines.

Introductory thermodynamics texts evaluate Brayton cycle efficiency using the cold-air formula:

η_{cold} = 1 - \frac{1}{r _{p (γ - 1) / γ}}

For a pressure ratio $r_{p} = 10$ and $γ = 1.4$ , this textbook relation predicts a thermal efficiency of 48.2%.

When you evaluate the same cycle in pyglenn by matching entropy across compressor and turbine stages with temperature-dependent $C_{p} (T)$ , the real thermal efficiency drops to 45.6%.

That 2.6 percentage point gap is the difference between a viable commercial engine and an expensive test-cell failure. Because gas heat capacity increases at high turbine inlet temperatures, the turbine extracts less work per unit temperature drop than constant-property theory suggests. The notebook models this non-linear expansion numerically:

from scipy.optimize import root_scalar
from pyglenn import ThermochemicalCalculator

with ThermochemicalCalculator() as calc:
    air = calc.get_available_species('AIR', exact_match=True)[0]

    # Target entropy at compressor exit for isentropic compression
    s_inlet = calc.calculate_properties(air.id, 300.0).s
    p_ratio = 10.0
    r_gas = calc.r_ref
    s_target = s_inlet + r_gas * 2.302585 * (p_ratio ** (1/10)) # delta S adjustment

    # Solve for compressor discharge temperature
    def entropy_error(temp):
        return calc.calculate_properties(air.id, temp).s - s_target

    sol = root_scalar(entropy_error, bracket=[400.0, 800.0], method='brentq')
    print(f"Real compressor exit temperature: {sol.root:.1f} K")

Energy-Balance Solvers for Flame Temperature

Notebook 06 moves from gas cycles to reactive thermochemistry. When methane burns in dry air under adiabatic, constant-pressure conditions, the total enthalpy of the unburned reactants equals the total enthalpy of the hot combustion products:

H_{reactants} (T_{initial}) = H_{products} (T_{ad})

Because pyglenn standardizes absolute enthalpy ( $H^{\circ}$ ) directly to the enthalpy of formation at 298.15 K, you do not need separate lookup tables for heat of combustion. Stoichiometric summations yield exact enthalpy balances automatically:

from scipy.optimize import brentq
from pyglenn import ThermochemicalCalculator

with ThermochemicalCalculator() as calc:
    ch4 = calc.get_available_species('CH4', exact_match=True)[0]
    o2  = calc.get_available_species('O2',  exact_match=True)[0]
    n2  = calc.get_available_species('N2',  exact_match=True)[0]
    co2 = calc.get_available_species('CO2', exact_match=True)[0]
    h2o = calc.get_available_species('H2O', exact_match=True)[0]

    # Reactants at 298.15 K: CH4 + 2(O2 + 3.76 N2)
    h_reactants = (
        calc.calculate_properties(ch4.id, 298.15).h_relative +
        2.0 * calc.calculate_properties(o2.id, 298.15).h_relative +
        7.52 * calc.calculate_properties(n2.id, 298.15).h_relative
    )

    # Balance against products: CO2 + 2 H2O + 7.52 N2
    def enthalpy_residual(t_flame):
        h_products = (
            calc.calculate_properties(co2.id, t_flame).h_relative +
            2.0 * calc.calculate_properties(h2o.id, t_flame).h_relative +
            7.52 * calc.calculate_properties(n2.id, t_flame).h_relative
        )
        return h_products - h_reactants

    t_ad = brentq(enthalpy_residual, 1500.0, 2600.0)
    print(f"Methane-air adiabatic flame temperature: {t_ad:.1f} K")

The notebook extends this formulation across varying fuel-air equivalence ratios ( $ϕ$ ) and reactant preheat temperatures, charting the thermal peak at stoichiometric operation.

Benchmarking Biofuels and Sustainable Aviation Fuels

Decarbonizing transport requires evaluating fuels against multiple competing physical metrics: gravimetric energy density, volumetric energy content, stoichiometric air-fuel ratio, and carbon dioxide emissions per megajoule released.

Notebook 07 benchmarks ethanol and methanol against conventional gasoline and kerosene jet fuel. Rather than pulling generic textbook numbers, the calculations evaluate lower heating values (LHV) and higher heating values (HHV) directly from NASA polynomial integrations.

The resulting tables expose the engineering trade-offs cleanly: while ethanol produces less carbon per kilogram of fuel burned, its lower energy density requires significantly higher fuel mass flow rates to achieve identical thermal output in aircraft engines.

Supplying Thermochemistry to CFD and Reaction Kinetics

High-performance reacting flow simulations in tools like OpenFOAM or custom finite-volume codes cannot afford repeated SQL database lookups inside spatial grid loops.

Notebook 10 demonstrates how to convert pyglenn into an in-memory property provider for computational fluid dynamics (CFD) and ordinary differential equation (ODE) integrators. By pre-allocating contiguous NumPy arrays or extracting raw polynomial coefficients into vectorized evaluators, the notebook establishes property evaluation pipelines capable of millions of state queries per second.

The Complete Twelve-Notebook Curriculum

The repository is organized as a graduated progression from basic toolchain setup to advanced multidisciplinary modeling:

Index	Notebook Title	Technical Scope
01	Getting Started	Connection management, case-insensitive exact species lookup, error handling
02	NASA Polynomials Under the Hood	Piecewise interval mechanics, polynomial reconstruction, integration constants
03	Temperature Curves and Plotting	Vibrational excitation physics, sensible enthalpy, analytical derivatives
04	Formation Enthalpy Recovery	Reconciling standardized enthalpy scales with reference formation values
05	Reaction Enthalpies	Kirchhoff laws, heat of combustion, stoichiometric summation
06	Adiabatic Flame Temperature	Enthalpy-balance root-finding, equivalence ratio sweeps, reactant preheating
07	Comparing Fuels and Biofuels	LHV, HHV, air-fuel ratios, CO2 emission indices for renewable fuels
08	Chemical Equilibrium	Gibbs energy, equilibrium constants, water-gas shift reaction, dissociation
09	Brayton Gas-Turbine Cycle	Real-gas entropy tracking vs cold-air models, compressor-turbine matching
10	Property Provider for CFD	High-throughput property tables, ODE kinetics integration, memory caching
11	Gas Mixture Thermochemistry	Mole-fraction weighting, mass basis conversion, composition validation
12	NASA-7 Coefficient Fitting	Multi-interval least-squares regression with C0 and C1 continuity constraints

Running the Examples Locally

Every notebook in the repository is checked into version control with its graphical plots and numeric outputs already rendered, allowing you to browse the results directly on GitHub or through the documentation site.

To execute and modify the notebooks locally, install the dependencies using either package manager:

# Using pip
pip install pyglenn numpy pandas matplotlib scipy jupyter

# Using conda-forge
conda install -c conda-forge pyglenn numpy pandas matplotlib scipy jupyter

Clone the repository and launch the Jupyter server:

git clone https://github.com/ProfLeao/pyglenn-notebooks.git
cd pyglenn-notebooks
jupyter lab

If you wish to re-execute the entire suite programmatically in batch mode, the repository includes a headless execution pipeline:

jupyter nbconvert --to notebook --execute --inplace notebooks/en/*.ipynb

Project Links and Citation

The entire collection is distributed under open-source terms and maintained alongside the core library:

Repository: github.com/ProfLeao/pyglenn-notebooks
Interactive Documentation: profleao.github.io/pyglenn-notebooks
Core Library: github.com/ProfLeao/pyglenn
DOI Reference: doi.org/10.5281/zenodo.21324685

NASA Polynomials Without the FORTRAN Headache: Meet pyglenn

Reginaldo Leão Jr. — Sat, 14 Nov 2026 20:30:41 +0000

Four decades ago, engineers at NASA Glenn Research Center codified the thermodynamic behavior of thousands of chemical species for their Chemical Equilibrium with Applications (CEA) code. Those empirical polynomials remain the gold standard for combustion simulations, jet engine design, and rocket propellant modeling.

Yet, working with that data today often feels like an archaeology expedition. The official coefficients still circulate in thermo.inp, a rigid, 80-column fixed-width FORTRAN layout that traces its roots straight back to punch cards.

If you have ever tried to slice columns 53 to 65 just to extract a molecular weight, or struggled to evaluate double-precision exponents in modern web services and analytics pipelines, you know the frustration.

Meet pyglenn.

Built by Dr. Reginaldo G. Leão Jr. and released under the MIT license, pyglenn wraps the entire NASA Glenn thermodynamic catalog into an embedded SQLite database and pairs it with a modern, fully typed Python API.

Here is what it does, why it matters, and how you can integrate it into your scientific workflows in minutes.

The 5.7 PPM Trap Most Codes Ignore

NASA polynomials compute dimensionless ratios for heat capacity, enthalpy, and entropy across specific temperature windows:

\frac{C _{p \circ} ( T )}{R} = a_{1} T^{- 2} + a_{2} T^{- 1} + a_{3} + a_{4} T + a_{5} T^{2} + a_{6} T^{3} + a_{7} T^{4}

To recover dimensional units like Joules per mole-Kelvin, you multiply by the universal gas constant, $R$ .

Here lies a subtle pitfall that catches many numerical libraries off guard. The original NASA dataset was calibrated using the CODATA 1986 reference constant ( $R = 8.314510 J/(mol \cdot K)$ ). When modern software evaluates these polynomials using the current CODATA universal constant ( $R = 8.31446261815324 J/(mol \cdot K)$ ), every calculation incurs an invisible, systematic shift of roughly 5.7 parts per million.

While 5.7 ppm sounds tiny, high-temperature equilibrium codes can drift significantly over iterative convergence loops. pyglenn tracks this reference constant directly in its database metadata, denormalizing properties with exact historical consistency while preserving the modern constant for universal physical relations.

Zero Configuration, Fully Typed

Unlike older wrappers that require manual database builds or compile external C extensions, pyglenn ships with an optimized thermo.db file containing 2,035 chemical species and 3,795 temperature intervals.

Installation requires only standard tools from PyPI or conda-forge:

# Using pip
pip install pyglenn

# Or using conda
conda install conda-forge::pyglenn

The library exposes immutable, frozen dataclasses instead of loose dictionaries. Your IDE autocompletes every field, from heat capacity to molecular weight, with full type safety.

Evaluating properties for oxygen at 1000 K takes five lines of Python:

from pyglenn import ThermochemicalCalculator

with ThermochemicalCalculator() as calc:
    # Exact case-insensitive matching isolates O2 from mixed formulas
    species = calc.get_available_species('O2', exact_match=True)[0]
    props = calc.calculate_properties(species.id, 1000.0)

    print(f"Species: {props.species_name}")
    print(f"Cp:      {props.cp:.2f} J/(mol·K)")
    print(f"H°:      {props.h_relative:.1f} J/mol")
    print(f"S°:      {props.s:.3f} J/(mol·K)")

Notice that props.h_relative evaluates absolute enthalpy under the standard NASA convention, meaning that enthalpy at 298.15 K matches the standard heat of formation of the compound.

If you need the sensible enthalpy between 298.15 K and operating temperature, call the dedicated helper:

h_sens = calc.h_sensible_to(species.id, 1000.0)
print(f"Sensible enthalpy rise: {h_sens:.1f} J/mol")

Evaluating Gas Mixtures Without Headaches

Engineering systems rarely burn pure reactants. We deal with atmospheric air, syngas, and complex exhaust mixtures.

pyglenn includes a Mixture abstraction that computes aggregate properties on both molar and mass bases. You specify the components and their mole fractions, and the engine handles molar mass averaging and property weighting automatically:

from pyglenn import Mixture, ThermochemicalCalculator

with ThermochemicalCalculator() as calc:
    n2 = calc.get_available_species('N2', exact_match=True)[0]
    o2 = calc.get_available_species('O2', exact_match=True)[0]
    ar = calc.get_available_species('AR', exact_match=True)[0]

    # Standard dry atmospheric air composition
    dry_air = Mixture((
        (n2.id, 0.78084),
        (o2.id, 0.20946),
        (ar.id, 0.00970),
    ))

    props = calc.mixture_properties(dry_air, 500.0)

    print(f"Mean molar mass: {props.molar_mass * 1000.0:.3f} g/mol")
    print(f"Air Cp (mass):   {props.cp_mass:.2f} J/(kg·K)")
    print(f"Air H° (mass):   {props.h_mass / 1e3:.2f} kJ/kg")

The composition validation enforces strict physical checks. If mole fractions fail to sum to 1.0 within numerical precision, or if negative fractions appear, the system flags the error immediately before calculating downstream states.

Fitting Custom Polynomials with Continuity Constraints

What if you have laboratory measurements or quantum chemistry calculations for a novel fuel candidate, and you need to generate valid NASA-7 coefficients for a simulation tool?

pyglenn provides least-squares polynomial regressors inside its fitting module. The algorithm scales temperature coordinates by their geometric mean, preventing the Vandermonde matrix from becoming ill-conditioned across wide ranges.

When fitting multiple temperature intervals, fit_nasa7_multi imposes linear equality constraints at the junction points. This guarantees that heat capacity and its first derivative remain continuous across the entire domain:

import numpy as np
from pyglenn.fitting import fit_nasa7_multi

# Sample synthetic laboratory data across 300 K to 3000 K
temps = np.linspace(300.0, 3000.0, 150)
cp_data = 28.0 + 0.015 * temps - 1.2e-6 * temps**2

# Break into low and high temperature intervals at 1000 K
intervals = fit_nasa7_multi(
    temperatures=temps,
    cp_values=cp_data,
    breakpoints=[1000.0],
    t_ref=298.15,
    h_ref=0.0,
)

print(f"Fitted intervals: {len(intervals)}")
print(f"Low interval a3:  {intervals[0].a3:.6e}")
print(f"High interval a3: {intervals[1].a3:.6e}")

The resulting coefficients follow the exact NASA CEA convention, placing enthalpy and entropy integration constants into $b_{1}$ and $b_{2}$ .

Terminal Diagnostics at Your Fingertips

You do not even need to open a Python shell to inspect a chemical species. The package includes a clean command-line interface:

# Query O2 properties across default temperature points
pyglenn query -s O2

# Validate internal database relational integrity
pyglenn validate

Running pyglenn validate inspects interval ordering, verifies foreign keys, and confirms that temperature coverage remains contiguous.

Where to Go Next

pyglenn bridges four decades of aerospace thermodynamics with modern, reliable Python engineering. It removes the friction of FORTRAN file parsers, prevents subtle gas constant scaling errors, and lets you focus on your actual physics models.

You can inspect the codebase, explore the documentation, or contribute directly on GitHub:

Repository: github.com/ProfLeao/pyglenn
Online Documentation: profleao.github.io/pyglenn
PyPI: pypi.org/project/pyglenn
Conda-Forge: anaconda.org/conda-forge/pyglenn