Using the builtin differential diffusion in OpenFOAM-10

Introduction

The differential diffusion transportation is available since OpenFOAM-9. However, it is never easy to use that. A LONG and LARGE table for diffusion coefficients should be generated beforehand, which can be time-consuming. Besides, there is no tutorial (until 2023/08/07) on the internet showing how to make this works. This repository will offer you an easy way to use that differential diffusion functionality.

Generally, we offer two methods.

Generate that crazy table for you with a piece of Python code, using the diffusion values from Cantera. DNS and RANS is supported natively in OpenFOAM, our library can add support for LES.
Generate a much simplified table containing polynomial coefficients fitting the binary diffusion values of all species pair, and let the OpenFOAM compute the diffusion coefficients during runtime. Our library add supports for DNS, LES and RANS

Note, the method 2 is definitely more accurate, but might be slower since recalculating the coefficients is more expensive than looking up the table.

Compile the code

You should, of course, install OpenFOAM-10 and enable the environment. Go to the repository directory and run

wmake fluidReactionThermo

Then everything is ready.

Usage

Generate differential diffusion table.

Our Python class require the Cantera for Python. Please install Cantera beforehand. Install through conda is the recommended way.
Convert the reaction mechanism into the cantera format. You might need to change the file name.

ck2yaml --input=chem.inp --thermo=therm.dat --transport=tran.dat

Put the generated mechanism file(usually 'mech.yaml') into the 'ddtransport' folder. If you install with conda, please make sure you enable the environment with Cantera. Then run
```
python getDiffTable.py
```
to generate the complex table (for method 1).

Or run
```
python getDiffPoly.py
```

to generate the simplified table (for method 2). Note, you might need to set change some configuration settings, such as the range of pressure and temperature (See 'getDiffTable.py' and 'getDiffPoly.py').

Put the table in the constant folder of your case as a separate file

Configure the thermophysicalTransport file

See the following example. You can find more examples from 'Cases' folder

laminar
{
    // FickianFourier, TabulatedFickianFourier for DNS
    // FickianEddyDiffusivity, TabulatedFickianEddyDiffusivity for RANS and LES
    // Add "Tabulated" to use a simplified table
    model          FickianFourier;

    mixtureDiffusionCoefficients no;
    
    Prt             0.7;
    Sct             0.7;

    // D           for method 1, complex table
    // DPolyCoeffs for method 2, simplified table
    DPolyCoeffs // [m^2/s] 
    {
        // #include "transportProperties"         // Use method 1, complex table
        #include "transportPropertiesPolynomials" // Use method 2, simplified table
    }
}

Don't forget to add the library to your 'controlDict' file

// For simplified or complex
libs ("libtabulatedFluidReactionThermophysicalTransportModels.so");

Validation and update (2024/08/13)

The premixed hydrogen flame speed is validated with cantera results.

We found around 5% under prediction. At least part of the reason is due to inaccurate thermal conductivity prediction of sutherland transport.

To fix it, the "ddpolynomialTransport" is implemented. Please generate the polynomials with the folloing code. Please note that you might need to set up the mechanism and fitting informations.

python getThermoPoly.py

The generated file should be included in the constant directory. Please note that the transport model now should be "ddpolynomial" instead of "sutherland" With this transport, slightly better results are expected.

A test case (phi10) is put in the Cases folder.

Examples

We offer a 1D hydrogen flame case using DNS, LES and RANS model, with both simplified and complex tables.

'Cases/DNS-builtin' (DNS, complex table)
'Cases/DNS' (DNS, simplified table)
'Cases/LES-builtin' (LES, complex table)
'Cases/LES' (LES, simplified table)
'Cases/RANS-builtin' (RANS, complex table)
'Cases/RANS' (RANS, simplified table)

The complex table is too large to be uploaded to Github. Please generate by yourself.

In LES/RANS cases, the turbulent kinetic energy is set to be zero, so there is no turbulent diffusion. The cases are configured for testing purposes.

The result is accurate.

Another OpenFOAM solver supporting differential diffusion.

See reacitngDNS. reactingDNS (in OpenFOAM-8) is accurate and well-tested in many cases.

In this repository, the differential diffusion is achieved in a library, instead of a solver. Consequently, you can enable it in all reacting solvers, and integrate it with other functionalities (e.g. turbulence, dynamic mesh, spray clouds...)

Reference

to be added in the future

yuchenzh/DDOF