Skip to content

Reactive Flow

Overview

The FluidDynamics module can be coupled with species transport and heat sources to simulate reactive flow — combustion, heterogeneous reactions in packed beds, and flame propagation. This capability is built on top of the thermally compressible LBM extension.

Reactive flow simulations use additional modules from openphase/include/ReactiveFlows/:

ModulePurpose
FlowMixtureMulti-species gas mixture properties (viscosity, thermal conductivity, diffusivity)
EnergyTransportEnergy (enthalpy) transport equation
SolidBodySolid particle tracking in reactive environments

These modules are not part of FluidDynamics/ itself but are documented here because they form the complete reactive flow stack together with FlowSolverLBM.


Coupling architecture

The reactive flow stack builds on the thermally compressible LBM:

text
FlowSolverLBM (TC mode)
    ↕ density, velocity
FlowMixture          — species transport, mixture EOS
    ↕ temperature, composition
EnergyTransport      — heat equation with reaction source terms
    ↕ species sources
Chemistry (external) — reaction rates (e.g. CHEMKIN, simple Arrhenius)

The Composition module carries species mass fractions. The Temperature module carries the enthalpy field. FlowMixture computes mixture-averaged transport properties. EnergyTransport advances the enthalpy equation.


Flame speed validation

The primary validation case for reactive flow is the 1D premixed laminar flame:

  • examples/ReactiveFlow/FlameSpeed1D — standard Arrhenius kinetics
  • examples/ReactiveFlow/FlameSpeed1D_NN — neural-network equation of state

The laminar flame speed SL is obtained by tracking the position of the reaction zone over time.


0D homogeneous ignition

The simplest reactive case: a perfectly stirred reactor without spatial gradients.

  • examples/ReactiveFlow/Flame0D

This example validates the chemical kinetics implementation by comparing against analytical ignition delay times.


2D flame–wall interaction

  • examples/ReactiveFlow/FlameWall2D

A premixed flame propagates toward a cold solid wall. This tests the solid–fluid thermal coupling and the effect of heat loss on flame quenching.


Packed-bed reactive flow

The most complex scenario: a reacting gas flowing through a bed of solid particles.

ExampleDimensionalityDescription
ReactiveFlow/FlamePackedBed2D2DFlame propagation in packed bed
ReactiveFlow/FlamePackedBed3D3D3D version
ReactiveFlow/FlamePackedBed-SFB287-A3Geom3DRealistic SFB287-A3 geometry

These examples require:

  • FlowSolverLBM with Do_ThermalComp = true
  • InteractionSolidFluid for solid–gas coupling
  • FlowMixture for multi-species properties
  • EnergyTransport for the enthalpy equation

Typical time loop for reactive flow

cpp
Settings        OPSettings(InputFile);
PhaseField      Phase(OPSettings);
BoundaryConditions BC(OPSettings, InputFile);
FlowSolverLBM   FL(OPSettings, InputFile);
Velocities      Vel(OPSettings);
FlowMixture     FM(InputFile);
EnergyTransport ET(OPSettings, InputFile);
SolidBody       SB(OPSettings, InputFile);
Temperature     Tx(OPSettings, InputFile);
Composition     Cx(OPSettings, InputFile);

// Initialize...

while (!RTC.Finished())
{
    FL.CalculateDensityTC(Tx, Cx, BC);
    FL.CollisionTC(Vel);
    FL.Propagation(Phase, BC);
    FL.SetBoundaryConditions(BC);
    FL.CalculateHydrodynamicPressureAndMomentum(Vel);
    FL.CalculateFluidVelocities(Vel, Phase, BC);

    ET.Solve(...);   // enthalpy transport
    FM.Solve(...);   // species transport
    // chemistry source terms...

    RTC.Increment();
}

TODO


Numerical considerations

  • Reactive flows involve steep gradients in temperature and species. Use fine grids or adaptive techniques near flame fronts.
  • The Van Leer density gradient scheme (GradRho_VanLeer) is essential for stability near reaction zones.
  • Chemical time scales are typically much shorter than fluid time scales; operator splitting (Strang splitting) is used to decouple chemistry from transport.
  • MPI decomposition across a reactive packed bed requires care: chemistry and transport must be consistent across domain boundaries.

Released under the GNU GPLv3 License.