zhyang-dev/openfoam
1
0
Fork 0
mirror of https://develop.openfoam.com/Development/openfoam.git synced 2025-11-28 03:28:01 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

combustionModels::EDC: New Eddy Dissipation Concept (EDC) turbulent combustion model

Browse Source 
including support for TDAC and ISAT for efficient chemistry calculation.

Description
    Eddy Dissipation Concept (EDC) turbulent combustion model.

    This model considers that the reaction occurs in the regions of the flow
    where the dissipation of turbulence kinetic energy takes place (fine
    structures). The mass fraction of the fine structures and the mean residence
    time are provided by an energy cascade model.

    There are many versions and developments of the EDC model, 4 of which are
    currently supported in this implementation: v1981, v1996, v2005 and
    v2016.  The model variant is selected using the optional \c version entry in
    the \c EDCCoeffs dictionary, \eg

    \verbatim
        EDCCoeffs
        {
            version v2016;
        }
    \endverbatim

    The default version is \c v2015 if the \c version entry is not specified.

    Model versions and references:
    \verbatim
        Version v2005:

            Cgamma = 2.1377
            Ctau = 0.4083
            kappa = gammaL^exp1 / (1 - gammaL^exp2),

            where exp1 = 2, and exp2 = 2.

            Magnussen, B. F. (2005, June).
            The Eddy Dissipation Concept -
            A Bridge Between Science and Technology.
            In ECCOMAS thematic conference on computational combustion
            (pp. 21-24).

        Version v1981:

            Changes coefficients exp1 = 3 and exp2 = 3

            Magnussen, B. (1981, January).
            On the structure of turbulence and a generalized
            eddy dissipation concept for chemical reaction in turbulent flow.
            In 19th Aerospace Sciences Meeting (p. 42).

        Version v1996:

            Changes coefficients exp1 = 2 and exp2 = 3

            Gran, I. R., & Magnussen, B. F. (1996).
            A numerical study of a bluff-body stabilized diffusion flame.
            Part 2. Influence of combustion modeling and finite-rate chemistry.
            Combustion Science and Technology, 119(1-6), 191-217.

        Version v2016:

            Use local constants computed from the turbulent Da and Re numbers.

            Parente, A., Malik, M. R., Contino, F., Cuoci, A., & Dally, B. B.
            (2016).
            Extension of the Eddy Dissipation Concept for
            turbulence/chemistry interactions to MILD combustion.
            Fuel, 163, 98-111.
    \endverbatim

Tutorials cases provided: reactingFoam/RAS/DLR_A_LTS, reactingFoam/RAS/SandiaD_LTS.

This codes was developed and contributed by

    Zhiyi Li
    Alessandro Parente
    Francesco Contino
    from BURN Research Group

and updated and tested for release by

    Henry G. Weller
    CFD Direct Ltd.
This commit is contained in:
Henry Weller
2017-03-17 09:44:15 +00:00
parent b68043256c
commit dd15478158
78 changed files with 15950 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

248
src/combustionModels/EDC/EDC.C Normal file
View File

@ -0,0 +1,248 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2017 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
\*---------------------------------------------------------------------------*/
#include "EDC.H"
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class Type>
Foam::combustionModels::EDC<Type>::EDC
(
const word& modelType,
const fvMesh& mesh,
const word& combustionProperties,
const word& phaseName
)
:
laminar<Type>(modelType, mesh, combustionProperties, phaseName),
version_
(
EDCversionNames
[
this->coeffs().lookupOrDefault
(
"version",
word(EDCversionNames[EDCdefaultVersion])
)
]
),
C1_(this->coeffs().lookupOrDefault("C1", 0.05774)),
C2_(this->coeffs().lookupOrDefault("C2", 0.5)),
Cgamma_(this->coeffs().lookupOrDefault("Cgamma", 2.1377)),
Ctau_(this->coeffs().lookupOrDefault("Ctau", 0.4083)),
exp1_(this->coeffs().lookupOrDefault("exp1", EDCexp1[int(version_)])),
exp2_(this->coeffs().lookupOrDefault("exp2", EDCexp2[int(version_)])),
kappa_
(
IOobject
(
IOobject::groupName(typeName + ":kappa", phaseName),
mesh.time().timeName(),
mesh,
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
mesh,
dimensionedScalar("kappa", dimless, 0)
)
{}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
template<class Type>
Foam::combustionModels::EDC<Type>::~EDC()
{}
// * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * * //
template<class Type>
void Foam::combustionModels::EDC<Type>::correct()
{
if (this->active())
{
tmp<volScalarField> tepsilon(this->turbulence().epsilon());
const volScalarField& epsilon = tepsilon();
tmp<volScalarField> tmu(this->turbulence().mu());
const volScalarField& mu = tmu();
tmp<volScalarField> tk(this->turbulence().k());
const volScalarField& k = tk();
tmp<volScalarField> trho(this->rho());
const volScalarField& rho = trho();
scalarField tauStar(epsilon.size(), 0);
if (version_ == EDCversions::v2016)
{
tmp<volScalarField> ttc(this->chemistryPtr_->tc());
const volScalarField& tc = ttc();
forAll(tauStar, i)
{
const scalar nu = mu[i]/(rho[i] + SMALL);
const scalar Da =
max(min(sqrt(nu/(epsilon[i] + SMALL))/tc[i], 10), 1e-10);
const scalar ReT = sqr(k[i])/(nu*epsilon[i] + SMALL);
const scalar CtauI = min(C1_/(Da*sqrt(ReT + 1)), 2.1377);
const scalar CgammaI =
max(min(C2_*sqrt(Da*(ReT + 1)), 5), 0.4082);
const scalar gammaL =
CgammaI*pow025(nu*epsilon[i]/(sqr(k[i]) + SMALL));
tauStar[i] = CtauI*sqrt(nu/(epsilon[i] + SMALL));
if (gammaL >= 1)
{
kappa_[i] = 1;
}
else
{
kappa_[i] =
max
(
min
(
pow(gammaL, exp1_)/(1 - pow(gammaL, exp2_)),
1
),
0
);
}
}
}
else
{
forAll(tauStar, i)
{
const scalar nu = mu[i]/(rho[i] + SMALL);
const scalar gammaL =
Cgamma_*pow025(nu*epsilon[i]/(sqr(k[i]) + SMALL));
tauStar[i] = Ctau_*sqrt(nu/(epsilon[i] + SMALL));
if (gammaL >= 1)
{
kappa_[i] = 1;
}
else
{
kappa_[i] =
max
(
min
(
pow(gammaL, exp1_)/(1 - pow(gammaL, exp2_)),
1
),
0
);
}
}
}
this->chemistryPtr_->solve(tauStar);
}
}
template<class Type>
Foam::tmp<Foam::fvScalarMatrix>
Foam::combustionModels::EDC<Type>::R(volScalarField& Y) const
{
return kappa_*laminar<Type>::R(Y);
}
template<class Type>
Foam::tmp<Foam::volScalarField>
Foam::combustionModels::EDC<Type>::Qdot() const
{
tmp<volScalarField> tQdot
(
new volScalarField
(
IOobject
(
IOobject::groupName(typeName + ":Qdot", this->phaseName_),
this->mesh().time().timeName(),
this->mesh(),
IOobject::NO_READ,
IOobject::NO_WRITE,
false
),
this->mesh(),
dimensionedScalar("Qdot", dimEnergy/dimVolume/dimTime, 0)
)
);
if (this->active())
{
tQdot.ref() = kappa_*this->chemistryPtr_->Qdot();
}
return tQdot;
}
template<class Type>
bool Foam::combustionModels::EDC<Type>::read()
{
if (Type::read())
{
version_ =
(
EDCversionNames
[
this->coeffs().lookupOrDefault
(
"version",
word(EDCversionNames[EDCdefaultVersion])
)
]
);
C1_ = this->coeffs().lookupOrDefault("C1", 0.05774);
C2_ = this->coeffs().lookupOrDefault("C2", 0.5);
Cgamma_ = this->coeffs().lookupOrDefault("Cgamma", 2.1377);
Ctau_ = this->coeffs().lookupOrDefault("Ctau", 0.4083);
exp1_ = this->coeffs().lookupOrDefault("exp1", EDCexp1[int(version_)]);
exp2_ = this->coeffs().lookupOrDefault("exp2", EDCexp2[int(version_)]);
return true;
}
else
{
return false;
}
}
// ************************************************************************* //

214
src/combustionModels/EDC/EDC.H Normal file
View File

@ -0,0 +1,214 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2017 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Class
Foam::combustionModels::EDC
Description
Eddy Dissipation Concept (EDC) turbulent combustion model.
This model considers that the reaction occurs in the regions of the flow
where the dissipation of turbulence kinetic energy takes place (fine
structures). The mass fraction of the fine structures and the mean residence
time are provided by an energy cascade model.
There are many versions and developments of the EDC model, 4 of which are
currently supported in this implementation: v1981, v1996, v2005 and
v2016. The model variant is selected using the optional \c version entry in
the \c EDCCoeffs dictionary, \eg
\verbatim
EDCCoeffs
{
version v2016;
}
\endverbatim
The default version is \c v2015 if the \c version entry is not specified.
Model versions and references:
\verbatim
Version v2005:
Cgamma = 2.1377
Ctau = 0.4083
kappa = gammaL^exp1 / (1 - gammaL^exp2),
where exp1 = 2, and exp2 = 2.
Magnussen, B. F. (2005, June).
The Eddy Dissipation Concept -
A Bridge Between Science and Technology.
In ECCOMAS thematic conference on computational combustion
(pp. 21-24).
Version v1981:
Changes coefficients exp1 = 3 and exp2 = 3
Magnussen, B. (1981, January).
On the structure of turbulence and a generalized
eddy dissipation concept for chemical reaction in turbulent flow.
In 19th Aerospace Sciences Meeting (p. 42).
Version v1996:
Changes coefficients exp1 = 2 and exp2 = 3
Gran, I. R., & Magnussen, B. F. (1996).
A numerical study of a bluff-body stabilized diffusion flame.
Part 2. Influence of combustion modeling and finite-rate chemistry.
Combustion Science and Technology, 119(1-6), 191-217.
Version v2016:
Use local constants computed from the turbulent Da and Re numbers.
Parente, A., Malik, M. R., Contino, F., Cuoci, A., & Dally, B. B.
(2016).
Extension of the Eddy Dissipation Concept for
turbulence/chemistry interactions to MILD combustion.
Fuel, 163, 98-111.
\endverbatim
SourceFiles
EDC.C
\*---------------------------------------------------------------------------*/
#ifndef EDC_H
#define EDC_H
#include "../laminar/laminar.H"
#include "NamedEnum.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
namespace combustionModels
{
//- EDC model versions
enum class EDCversions
{
v1981,
v1996,
v2005,
v2016
};
extern const NamedEnum<EDCversions, 4> EDCversionNames;
extern const EDCversions EDCdefaultVersion;
const scalar EDCexp1[] = {3, 2, 2, 2};
const scalar EDCexp2[] = {3, 3, 2, 2};
/*---------------------------------------------------------------------------*\
Class EDC Declaration
\*---------------------------------------------------------------------------*/
template<class Type>
class EDC
:
public laminar<Type>
{
// Private data
//- The selected model version
EDCversions version_;
scalar C1_;
scalar C2_;
scalar Cgamma_;
scalar Ctau_;
scalar exp1_;
scalar exp2_;
//- Mixing parameter
volScalarField kappa_;
// Private Member Functions
//- Disallow copy construct
EDC(const EDC&);
//- Disallow default bitwise assignment
void operator=(const EDC&);
public:
//- Runtime type information
TypeName("EDC");
// Constructors
//- Construct from components
EDC
(
const word& modelType,
const fvMesh& mesh,
const word& combustionProperties,
const word& phaseName
);
//- Destructor
virtual ~EDC();
// Member Functions
//- Correct combustion rate
virtual void correct();
//- Fuel consumption rate matrix.
virtual tmp<fvScalarMatrix> R(volScalarField& Y) const;
//- Heat release rate [kg/m/s3]
virtual tmp<volScalarField> Qdot() const;
//- Update properties from given dictionary
virtual bool read();
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace combustionModels
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#ifdef NoRepository
#include "EDC.C"
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

61
src/combustionModels/EDC/EDCs.C Normal file
View File

@ -0,0 +1,61 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2017 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
This file is part of OpenFOAM.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
\*---------------------------------------------------------------------------*/
#include "makeCombustionTypes.H"
#include "psiChemistryCombustion.H"
#include "rhoChemistryCombustion.H"
#include "EDC.H"
// * * * * * * * * * * * * * Static Member Data * * * * * * * * * * * * * * //
template<>
const char* Foam::NamedEnum
<
Foam::combustionModels::EDCversions,
4
>::names[] =
{
"v1981",
"v1996",
"v2005",
"v2016"
};
const Foam::NamedEnum<Foam::combustionModels::EDCversions, 4>
Foam::combustionModels::EDCversionNames;
const Foam::combustionModels::EDCversions
Foam::combustionModels::EDCdefaultVersion
(
Foam::combustionModels::EDCversions::v2005
);
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
makeCombustionTypes(EDC, psiChemistryCombustion, psiCombustionModel);
makeCombustionTypes(EDC, rhoChemistryCombustion, rhoCombustionModel);
// ************************************************************************* //

1
src/combustionModels/Make/files
View File

@ -14,6 +14,7 @@ diffusion/diffusions.C
infinitelyFastChemistry/infinitelyFastChemistrys.C
PaSR/PaSRs.C
EDC/EDCs.C
laminar/laminars.C