Reactors

NeqSim provides a family of reactor models for gas-phase kinetics, chemical equilibrium, stoichiometric conversion, catalytic reactions, and bio-processing. All reactors live in the neqsim.process.equipment.reactor package and integrate with ProcessSystem flowsheets.

Table of Contents

Overview

Package: neqsim.process.equipment.reactor

Class Description
PlugFlowReactor Tubular reactor with ODE-based kinetics, catalyst bed, pressure drop
KineticReaction Rate expression (power-law, LHHW, reversible Arrhenius)
CatalystBed Packed bed properties, Ergun pressure drop, Thiele modulus
ReactorAxialProfile Axial position profiles with interpolation and export
StirredTankReactor Continuous stirred tank reactor (CSTR)
GibbsReactor Gibbs free energy minimization for equilibrium
GibbsReactorCO2 Gibbs reactor variant specialized for CO2 reactions
StoichiometricReaction Fixed-conversion stoichiometric reactor
AmmoniaSynthesisReactor Specialized reactor for ammonia synthesis
SulfurOxidationReactor Partial oxidation of H2S and oxygen to elemental sulfur (S8) and water
IronSulfideWallInventory Stateful FeS, FeCO3, and iron-oxide wall inventory with exposure history
IronSulfideOxidationSource FeS formation/oxidation source coupled to an S8 outlet and uncertainty bounds
SulfurDepositionAnalyser Sulfur solubility, deposition onset, corrosion assessment
FurnaceBurner Fired heater / furnace burner
CatalyticTubeReformer Tube-side SMR equilibrium model with duty and tube-wall screening
ReformerFurnace Fired SMR furnace coupling burner heat to reformer tube demand
SyngasBurnerZone Oxygen-blown ATR/POX burner-zone screening model
AutothermalReformer ATR route model with O₂/C and S/C control, burner zone, catalytic equilibrium, and soot risk
PartialOxidationReactor POX route model with refractory warning, quench section, and H₂/CO metric
QuenchSection Rapid syngas cooling model with heat-removed and quench-severity outputs
Fermenter Fermentation reactor for bio-processing
EnzymeTreatment Enzyme-based treatment reactor

Reactor Selection Guide

Reactor When to Use
PlugFlowReactor Gas-phase catalytic or homogeneous reactions with axial gradients
StirredTankReactor Liquid-phase reactions, good mixing, residence time calculations
GibbsReactor Complex equilibrium without specifying reaction stoichiometry
StoichiometricReaction Known fixed conversion, simple material balance
CatalyticTubeReformer SMR tube-side syngas generation with heat-duty and catalyst-activity screening
ReformerFurnace SMR furnace heat-balance studies with fuel/air combustion and tube reforming
AutothermalReformer ATR concept studies with oxygen/steam ratio control and soot-risk screening
PartialOxidationReactor POX syngas route studies with quench and refractory-temperature screening
AmmoniaSynthesisReactor Haber-Bosch ammonia synthesis modeling
SulfurOxidationReactor Sour gas with oxygen ingress or controlled oxidation where generated S8 should feed a downstream sulfur filter
IronSulfideOxidationSource Historical wet/sour carbon-steel service followed by oxygen ingress, purge, shutdown, or restart
SulfurDepositionAnalyser Sulfur precipitation, H2S reactions, corrosion assessment

Plug Flow Reactor (PFR)

The PlugFlowReactor is the most comprehensive reactor in NeqSim. It solves coupled ODEs for species molar flows, temperature, and pressure as a function of axial position.

Key features:

Quick Example

import neqsim.thermo.system.SystemSrkEos;
import neqsim.process.equipment.stream.Stream;
import neqsim.process.equipment.reactor.PlugFlowReactor;
import neqsim.process.equipment.reactor.KineticReaction;
import neqsim.process.equipment.reactor.CatalystBed;

// Feed gas
SystemSrkEos gas = new SystemSrkEos(273.15 + 300.0, 20.0);
gas.addComponent("methane", 0.90);
gas.addComponent("ethane", 0.10);
gas.setMixingRule("classic");

Stream feed = new Stream("Feed", gas);
feed.setFlowRate(10.0, "mole/sec");
feed.run();

// Reaction: methane -> ethane (illustrative)
KineticReaction rxn = new KineticReaction("A to B");
rxn.addReactant("methane", 1.0, 1.0);
rxn.addProduct("ethane", 1.0);
rxn.setPreExponentialFactor(1.0e4);
rxn.setActivationEnergy(50000.0);
rxn.setHeatOfReaction(-50000.0);

// Catalyst
CatalystBed catalyst = new CatalystBed(3.0, 0.40, 800.0);

// Reactor
PlugFlowReactor pfr = new PlugFlowReactor("PFR-1", feed);
pfr.addReaction(rxn);
pfr.setCatalystBed(catalyst);
pfr.setLength(5.0, "m");
pfr.setDiameter(0.10, "m");
pfr.setEnergyMode(PlugFlowReactor.EnergyMode.ADIABATIC);
pfr.setNumberOfSteps(100);
pfr.setKeyComponent("methane");
pfr.run();

double conversion = pfr.getConversion();
double outletTemperatureC = pfr.getOutletTemperature() - 273.15;
double pressureDropBar = pfr.getPressureDrop();

Full documentation: See the Plug Flow Reactor Guide for governing equations, all kinetic models, LHHW setup, coolant mode, multi-tube reactors, Python usage, and the complete API reference.

Stirred Tank Reactor (CSTR)

The StirredTankReactor models a continuous stirred tank reactor with perfect mixing.

import neqsim.process.equipment.reactor.StirredTankReactor;

StirredTankReactor cstr = new StirredTankReactor("R-100", feedStream);
cstr.run();

Gibbs Reactor

Minimizes Gibbs free energy to find equilibrium composition without requiring explicit reaction stoichiometry. Uses Newton-Raphson iteration with element balance constraints.

import neqsim.process.equipment.reactor.GibbsReactor;

// Feed must include all possible product species (even at zero mole fraction)
SystemSrkEos gas = new SystemSrkEos(273.15 + 800.0, 20.0);
gas.addComponent("methane", 1.0);
gas.addComponent("water", 3.0);
gas.addComponent("CO", 1.0e-10);
gas.addComponent("CO2", 1.0e-10);
gas.addComponent("hydrogen", 1.0e-10);
gas.setMixingRule("classic");

Stream feed = new Stream("Feed", gas);
feed.setFlowRate(100.0, "kmol/hr");
feed.run();

GibbsReactor gibbs = new GibbsReactor("SMR Reactor", feed);
gibbs.run();

Key methods:

See GibbsReactor Reference Documentation for the full mathematical foundation, algorithm details, and usage examples.

Stoichiometric Reactor

Fixed-conversion reactor based on specified stoichiometry.

import neqsim.process.equipment.reactor.StoichiometricReaction;

StoichiometricReaction stoich = new StoichiometricReaction("R-Stoich", feedStream);
stoich.run();

Ammonia Synthesis Reactor

Specialized reactor for the Haber-Bosch process (N2 + 3 H2 ⇌ 2 NH3).

import neqsim.process.equipment.reactor.AmmoniaSynthesisReactor;

AmmoniaSynthesisReactor nh3 = new AmmoniaSynthesisReactor("NH3-Reactor", feedStream);
nh3.run();

Sulfur Oxidation Reactor

SulfurOxidationReactor is a two-port process unit for screening elemental sulfur formation from hydrogen sulfide and oxygen in a methane-rich gas stream. It applies the stoichiometric reaction:

\[2\,\mathrm{H_2S} + \mathrm{O_2} \rightarrow 2\,\mathrm{H_2O} + 0.25\,\mathrm{S_8}\]

Methane and other hydrocarbons are treated as inert. The model consumes H2S up to the target conversion, then applies oxygen limitation. The product sulfur is added as the S8 component, and the reactor can run a solid sulfur flash at the outlet so downstream equipment can detect solid S8.

Use this reactor when chemistry should modify the stream composition before filtration. Use SulfurDepositionAnalyser when the task is solubility, temperature-sweep, corrosion, or blockage-risk analysis without modifying the outlet stream.

SystemInterface gas = new SystemSrkEos(283.15, 20.0);
gas.addComponent("methane", 80.0);
gas.addComponent("H2S", 80.0);
gas.addComponent("oxygen", 40.0);
gas.addComponent("water", 1.0e-12);
gas.addComponent("S8", 1.0e-12);
gas.setMixingRule("classic");
gas.setMultiPhaseCheck(true);
gas.setSolidPhaseCheck("S8");

Stream feed = new Stream("sour methane feed", gas);
feed.setFlowRate(1000.0, "kg/hr");
feed.run();

SulfurOxidationReactor reactor = new SulfurOxidationReactor("sulfur reactor", feed);
reactor.setH2SConversionTarget(1.0);
reactor.setPressureDrop(0.0);
reactor.run();

double h2sConversion = reactor.getH2SConversion();
double s8Moles = reactor.getS8ProducedMoles();
boolean solidSulfur = reactor.isSolidSulfurPresent();

The reactor is designed to connect directly to SulfurFilter. The filter then captures solid S8, accumulates sulfur loading, and builds pressure drop during transient operation:

SulfurFilter filter = new SulfurFilter("sulfur filter", reactor.getOutletStream());
filter.setRemovalEfficiency(1.0);
filter.setFilterElementCapacity(1000.0);
filter.setPressureDropIncreaseAtCapacity(1.0);
filter.setCalculateSteadyState(false);
filter.runTransient(3600.0, UUID.randomUUID());

These examples are covered by SulfurOxidationReactorTest and FilterTest.

Iron-Sulfide Wall Source

IronSulfideWallInventory retains FeS, FeCO3, and iron-oxide-equivalent scale formed during earlier wet or sour service. IronSulfideOxidationSource calculates user-configured formation and oxidation rates, applies H2S/O2 availability limits, and introduces the elemental-sulfur fraction as S8 into its outlet stream. Uncalibrated cases report low/base/high sulfur rates.

This model is appropriate when a fluid-only H2S oxidation calculation cannot explain the observed inventory or timing—for example, oxygen-containing nitrogen reaching old FeS scale during a purge or restart. The generated S8 can be connected to SolidFlashDepositSource; that source can evaluate a warmer compressor shaft thermal node and report local condensate evaporation.

Full documentation: See the Iron-Sulfide Wall Source Guide for reaction bookkeeping, history, uncertainty, condensate carry-over, and warm-shaft coupling.

Sulfur Deposition Analyser

Analyses sulfur solubility, deposition onset temperature, chemical equilibrium of H2S/O2 reactions, corrosion (FeS formation), and blockage risk. Performs temperature sweep analysis.

import neqsim.process.equipment.reactor.SulfurDepositionAnalyser;

SulfurDepositionAnalyser analyser = new SulfurDepositionAnalyser("S-Analyser", feedStream);
analyser.setTemperatureSweepRange(0.0, 200.0, 5.0);
analyser.setRunChemicalEquilibrium(true);
analyser.setRunSolidFlash(true);
analyser.setRunCorrosionAssessment(true);
analyser.run();

double onset = analyser.getSulfurDepositionOnsetTemperature();
String json = analyser.getResultsAsJson();

Furnace Burner

Models a fired heater / furnace burner for high-temperature heating.

import neqsim.process.equipment.reactor.FurnaceBurner;

FurnaceBurner burner = new FurnaceBurner("Furnace", feedStream);
burner.run();

Hydrogen Production Reactors

The hydrogen-production reactor models build on GibbsReactor, FurnaceBurner, and catalyst screening utilities to provide route-level models for SMR, ATR, POX, and water-gas shift studies. Use them for concept screening, heat-balance checks, oxygen and steam-ratio envelopes, soot/refractory/tube-temperature warnings, WGS conversion checks, and plant builder templates. Detailed radiant-box design, burner CFD, vendor tube ratings, and rate-based catalyst calibration remain outside this screening layer.

Class Typical use
CatalyticTubeReformer Tube-side steam methane reforming equilibrium, heat duty, tube-wall temperature, heat flux, methane conversion
ReformerFurnace Fired SMR furnace with process feed, fuel feed, combustion air, syngas outlet, and flue-gas outlet
SyngasBurnerZone High-temperature oxygen-blown burner zone for ATR and POX front ends
AutothermalReformer Integrated ATR model with O₂/C and S/C controls, burner-zone warnings, and catalytic equilibrium
PartialOxidationReactor POX model with O₂/C control, optional steam, refractory warning, fast quench, and H₂/CO output
QuenchSection Standalone rapid syngas cooling and quench-severity screening
WaterGasShiftReactor HT/LT WGS equilibrium wrapper with CO conversion, H2 gain, CO2 formation, heat duty, and WGS ratio reporting

For full route examples and plant builders, see Hydrogen Production with NeqSim.

Bio-Processing Reactors

Fermenter

Models a biological fermentation reactor.

import neqsim.process.equipment.reactor.Fermenter;

Fermenter fermenter = new Fermenter("BioReactor", feedStream);
fermenter.run();

Enzyme Treatment

Models an enzyme-based treatment step.

import neqsim.process.equipment.reactor.EnzymeTreatment;

EnzymeTreatment enzyme = new EnzymeTreatment("EnzymeUnit", feedStream);
enzyme.run();