Boost Your Workflow with a Natural Gas Properties Plugin for Engineers

Integrating a Natural Gas Properties Plugin into Process SimulationsAccurate thermophysical properties of natural gas are essential for reliable process simulations in gas processing, pipeline transport, power generation, and chemical engineering design. A Natural Gas Properties Plugin (NGPP) — a modular software component that supplies composition-dependent properties such as density, viscosity, compressibility factor (Z), heating value, and phase behavior — can dramatically improve model fidelity and reduce engineering uncertainty. This article explains why an NGPP matters, what key capabilities to expect, how to integrate one into process simulations, practical implementation steps, validation and testing practices, common pitfalls, and performance and maintenance considerations.

Why use a Natural Gas Properties Plugin?

• Natural gas is a complex mixture of hydrocarbons (methane, ethane, propane, etc.) plus non-hydrocarbon components (CO2, N2, H2S, water). Properties vary strongly with composition, pressure, and temperature.
• Built-in, generic property correlations in process simulators often oversimplify the mixture or assume ideal behavior, causing significant errors in mass/energy balances, phase split predictions, and equipment sizing.
• An NGPP centralizes advanced property calculations (equations of state, transport property models, PVT calculations, heating value, dew point/phase envelopes), making them reusable across flowsheets and ensuring consistent results.

Key benefit: Higher accuracy and consistent properties across simulation modules with minimal user rework.

Core capabilities of a Natural Gas Properties Plugin

An effective NGPP typically provides:

• Composition handling: specification via mole or mass fractions, support for varying component lists, and addition/removal of trace species.
• Equation of State (EoS) models: Peng–Robinson, Soave–Redlich–Kwong, GERG-2008 or other advanced EoS suitable for natural gas mixtures.
• Phase equilibrium (VLE/LLE): robust flash calculations that handle liquid hydrocarbons and water/hydrocarbon systems, including multi-phase splits.
• Transport properties: viscosity and thermal conductivity models tuned for hydrocarbon mixtures.
• Compressibility factor (Z) and density: accurate, composition- and condition-dependent values.
• Energy properties: lower heating value (LHV), higher heating value (HHV), specific heat capacities.
• Fugacity and activity coefficients for equilibrium and reaction calculations.
• Dew point and phase envelope generation for pipeline and storage design.
• Unit conversions, reference states, and thermodynamic consistency checks.
• API and/or library interfaces (DLL, shared object, REST, gRPC) for easy simulator integration.
• Logging, error handling, and traceable calculation provenance.

Integration approaches

Integration depends on the host process simulator and deployment constraints. Common approaches:

1. Native plugin/extension mechanism

   • Many commercial simulators (e.g., Aspen HYSYS, Aspen Plus, gPROMS) expose plugin APIs allowing compiled modules to register property methods directly.
   • Advantage: tight integration, native performance, and seamless unit operation access to properties.
   • Consideration: requires building against simulator SDK and conforming to its type systems and lifecycle.

2. Shared library (DLL/.so) with wrapper

   • The plugin exposes a stable function set (init, setComposition, calcProperties, cleanup). The simulator or an intermediate wrapper calls these functions.
   • Advantage: portable and language-agnostic; easier to test independently.
   • Consideration: need careful memory and threading management.

3. Microservice (REST/gRPC)

   • Properties are served by a separate process via HTTP/gRPC. The simulator sends composition and conditions and receives property values.
   • Advantage: language-agnostic, scalable, centralizable for enterprise use, easier to update without changing client binaries.
   • Consideration: network latency; must ensure deterministic behavior and retry/error strategies.

4. Scripting interface

   • Use Python/Matlab/R/Julia scripts that call property libraries (e.g., CoolProp, REFPROP, in-house libraries) and interact with the simulator via its scripting API.
   • Advantage: rapid prototyping, flexibility.
   • Consideration: performance and production readiness.

Implementation steps (practical checklist)

1. Requirements and scoping

   • List required properties (density, Z, viscosity, dew point, LHV, etc.).
   • Define supported components and compositional flexibility (C1–C6+, heavy fraction handling).
   • Establish acceptable accuracy and performance targets.
   • Choose EoS and transport models (e.g., PR with volume translation, GERG-2008 for non-ideal mixtures).

2. Select or develop the property engine

   • Evaluate open-source libraries (CoolProp for pure/mixtures, GERG implementations, REFPROP where license permits) versus in-house or commercial engines.
   • Implement missing models (e.g., water-hydrocarbon interactions, H2S/CO2 handling) and unit conversions.

3. Design integration layer

   • Define API: initialization, set composition, set conditions, get properties, flash calculations, error codes.
   • Choose data exchange format: binary structs, JSON, Protocol Buffers.

4. Build and test a standalone validator

   • Create a test harness that calls the engine across typical P–T–composition matrices.
   • Validate against reference data (experimental data, literature, or a trusted simulator).

5. Integrate with the simulator

   • For native plugins: implement required hooks (property method registration, memory model).
   • For microservices: implement client calls, batching, and caching where appropriate.
   • Add GUI elements or scripting functions to pass composition and call the NGPP.

6. Performance optimization

   • Cache repeated calls for identical states; use composition hashing.
   • Vectorize calculations for batched conditions.
   • Precompute phase envelopes where feasible.

7. Validation in-flowsheet

   • Replace baseline property calls and run end-to-end cases: steady-state material & energy balances, dynamic scenarios, and equipment rating cases.
   • Compare results with baseline and with lab/field data.

8. Documentation and training

   • Document API, supported components, assumptions, and known limitations.
   • Provide examples and typical workflows for engineers.

Validation and testing strategies

• Unit tests for each model and property (edge cases: near-critical, very low/high temperature).
• Regression tests comparing plugin outputs to trusted references (e.g., REFPROP, GERG-2008, experimental datasets).
• Round-trip consistency checks: fugacity -> flash -> composition should conserve mass and Gibbs energy within tolerance.
• Sensitivity analyses: vary composition, pressure, and temperature to ensure stable gradients for optimization.
• Real-world case studies: pipelines, compressor stations, amine units, dehydration, LNG precooling.
• Performance tests: throughput targets (e.g., properties per second) and latency measurements for microservice deployments.

Common pitfalls and how to avoid them

• Ignoring non-hydrocarbon components: CO2, N2, H2S, and water significantly impact phase behavior and heating value.
• Using inappropriate EoS: select EoS calibrated for gas mixtures and high non-ideality when needed.
• Mismatched reference states and units: ensure consistent enthalpy/entropy bases and unit systems across simulators and plugin.
• Not handling binary interaction parameters (BIPs): tune or source reliable BIPs for heavy hydrocarbon interactions.
• Overlooking numerical robustness: implement safeguards for flash convergence, fallback methods, and meaningful error messages.
• Neglecting performance: optimize for typical use patterns (batched calls, caching) to avoid slow simulations.

Performance, deployment, and maintenance

• Deployment: package as a versioned library or containerized service. Provide installer or Helm charts for enterprise.
• Monitoring: collect metrics (call rates, latencies, error rates) and surface them to ops teams.
• Updates: version API changes, maintain backward compatibility where possible; publish changelogs for model or BIP updates.
• Licensing: ensure third-party libraries (REFPROP, GERG implementations) comply with your licensing model.
• Security: for microservices, use authentication and secure transport (TLS); sanitize inputs to avoid denial-of-service via pathological composition vectors.

Example integration pattern (high level)

1. Simulator calls NGPP.init(config)
2. Simulator sends composition and state: NGPP.setState({components, moleFractions, T, P})
3. NGPP performs flash and returns: {phaseFractions, densities, viscosities, Z, enthalpies}
4. Simulator uses returned values for unit operations and system solves
5. For repeated composition/nearby states, simulator requests properties in batch or queries cached values

Conclusion

Integrating a Natural Gas Properties Plugin into process simulations standardizes and improves the accuracy of thermophysical calculations essential to gas-industry workflows. Selecting appropriate models (EoS, transport), designing a robust API, validating against trusted data, and planning for performance and maintainability are the keys to successful deployment. When done properly, an NGPP reduces engineering uncertainty, speeds up design iterations, and provides consistent inputs for optimization and control tasks.