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

ENH: combustionModels: Changed the construction order

Browse Source 
The combustion and chemistry models no longer select and own the
thermodynamic model; they hold a reference instead. The construction of
the combustion and chemistry models has been changed to require a
reference to the thermodyanmics, rather than the mesh and a phase name.

At the solver-level the thermo, turbulence and combustion models are now
selected in sequence. The cyclic dependency between the three models has
been resolved, and the raw-pointer based post-construction step for the
combustion model has been removed.

The old solver-level construction sequence (typically in createFields.H)
was as follows:

    autoPtr<combustionModels::psiCombustionModel> combustion
    (
        combustionModels::psiCombustionModel::New(mesh)
    );

    psiReactionThermo& thermo = combustion->thermo();

    // Create rho, U, phi, etc...

    autoPtr<compressible::turbulenceModel> turbulence
    (
        compressible::turbulenceModel::New(rho, U, phi, thermo)
    );

    combustion->setTurbulence(*turbulence);

The new sequence is:

    autoPtr<psiReactionThermo> thermo(psiReactionThermo::New(mesh));

    // Create rho, U, phi, etc...

    autoPtr<compressible::turbulenceModel> turbulence
    (
        compressible::turbulenceModel::New(rho, U, phi, *thermo)
    );

    autoPtr<combustionModels::psiCombustionModel> combustion
    (
        combustionModels::psiCombustionModel::New(*thermo, *turbulence)
    );

ENH: combustionModel, chemistryModel: Simplified model selection

The combustion and chemistry model selection has been simplified so
that the user does not have to specify the form of the thermodynamics.

Examples of new combustion and chemistry entries are as follows:

    In constant/combustionProperties:

        combustionModel PaSR;

        combustionModel FSD;

    In constant/chemistryProperties:

        chemistryType
        {
            solver          ode;
            method          TDAC;
        }

All the angle bracket parts of the model names (e.g.,
<psiThermoCombustion,gasHThermoPhysics>) have been removed as well as
the chemistryThermo entry.

The changes are mostly backward compatible. Only support for the
angle bracket form of chemistry solver names has been removed. Warnings
will print if some of the old entries are used, as the parts relating to
thermodynamics are now ignored.

ENH: combustionModel, chemistryModel: Simplified model selection

Updated all tutorials to the new format

STYLE: combustionModel: Namespace changes

Wrapped combustion model make macros in the Foam namespace and removed
combustion model namespace from the base classes. This fixes a namespace
specialisation bug in gcc 4.8. It is also somewhat less verbose in the
solvers.

This resolves bug report https://bugs.openfoam.org/view.php?id=2787

ENH: combustionModels: Default to the "none" model

When the constant/combustionProperties dictionary is missing, the solver
will now default to the "none" model. This is consistent with how
radiation models are selected.
This commit is contained in:
Will Bainbridge
2017-11-23 16:57:12 +00:00
committed by Andrew Heather
parent 255ec7366b
commit 22aae2816d
190 changed files with 2266 additions and 2991 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
applications/solvers/combustion/chemFoam/chemFoam.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2017 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -37,7 +37,8 @@ Description
#include "fvCFD.H"
#include "psiReactionThermo.H"
#include "psiChemistryModel.H"
#include "BasicChemistryModel.H"
#include "reactingMixture.H"
#include "chemistrySolver.H"
#include "OFstream.H"
#include "thermoPhysicsTypes.H"

6
applications/solvers/combustion/chemFoam/createFieldRefs.H
View File

@ -1,4 +1,8 @@
scalar dtChem = refCast<const psiChemistryModel>(chemistry).deltaTChem()[0];
BasicChemistryModel<psiReactionThermo>& chemistry = pChemistry();
scalar dtChem = refCast<const BasicChemistryModel<psiReactionThermo>>
(
chemistry
).deltaTChem()[0];
basicMultiComponentMixture& composition = thermo.composition();
PtrList<volScalarField>& Y = composition.Y();
volScalarField& p = thermo.p();

14
applications/solvers/combustion/chemFoam/createFields.H
View File

@ -23,14 +23,16 @@
#include "createBaseFields.H"
Info<< nl << "Reading thermophysicalProperties" << endl;
autoPtr<psiChemistryModel> pChemistry(psiChemistryModel::New(mesh));
psiChemistryModel& chemistry = pChemistry();
psiReactionThermo& thermo = chemistry.thermo();
Info<< "Reading thermophysical properties\n" << endl;
autoPtr<psiReactionThermo> pThermo(psiReactionThermo::New(mesh));
psiReactionThermo& thermo = pThermo();
thermo.validate(args.executable(), "h");
autoPtr<BasicChemistryModel<psiReactionThermo>> pChemistry
(
BasicChemistryModel<psiReactionThermo>::New(thermo)
);
volScalarField rho
(
IOobject

21
applications/solvers/combustion/fireFoam/createFields.H
View File

@ -1,16 +1,6 @@
Info<< "Creating combustion model\n" << endl;
autoPtr<combustionModels::psiCombustionModel> combustion
(
combustionModels::psiCombustionModel::New
(
mesh
)
);
Info<< "Reading thermophysical properties\n" << endl;
psiReactionThermo& thermo = combustion->thermo();
autoPtr<psiReactionThermo> pThermo(psiReactionThermo::New(mesh));
psiReactionThermo& thermo = pThermo();
thermo.validate(args.executable(), "h", "e");
SLGThermo slgThermo(mesh, thermo);
@ -74,8 +64,11 @@ autoPtr<compressible::turbulenceModel> turbulence
)
);
// Set the turbulence into the combustion model
combustion->setTurbulence(turbulence());
Info<< "Creating combustion model\n" << endl;
autoPtr<CombustionModel<psiReactionThermo>> combustion
(
CombustionModel<psiReactionThermo>::New(thermo, turbulence())
);
#include "readGravitationalAcceleration.H"

3
applications/solvers/combustion/fireFoam/fireFoam.C
View File

@ -41,7 +41,8 @@ Description
#include "radiationModel.H"
#include "SLGThermo.H"
#include "solidChemistryModel.H"
#include "psiCombustionModel.H"
#include "psiReactionThermo.H"
#include "CombustionModel.H"
#include "pimpleControl.H"
#include "fvOptions.H"

22
applications/solvers/combustion/reactingFoam/createFields.H
View File

@ -1,13 +1,8 @@
#include "createRDeltaT.H"
Info<< "Creating reaction model\n" << endl;
autoPtr<combustionModels::psiCombustionModel> reaction
(
combustionModels::psiCombustionModel::New(mesh)
);
psiReactionThermo& thermo = reaction->thermo();
Info<< "Reading thermophysical properties\n" << endl;
autoPtr<psiReactionThermo> pThermo(psiReactionThermo::New(mesh));
psiReactionThermo& thermo = pThermo();
thermo.validate(args.executable(), "h", "e");
basicMultiComponentMixture& composition = thermo.composition();
@ -18,8 +13,7 @@ if (!composition.species().found(inertSpecie))
{
FatalIOErrorIn(args.executable().c_str(), thermo)
<< "Inert specie " << inertSpecie << " not found in available species "
<< composition.species()
<< exit(FatalIOError);
<< composition.species() << exit(FatalIOError);
}
volScalarField rho
@ -47,7 +41,6 @@ volVectorField U
mesh
);
volScalarField& p = thermo.p();
#include "compressibleCreatePhi.H"
@ -68,8 +61,11 @@ autoPtr<compressible::turbulenceModel> turbulence
)
);
// Set the turbulence into the reaction model
reaction->setTurbulence(turbulence());
Info<< "Creating reaction model\n" << endl;
autoPtr<CombustionModel<psiReactionThermo>> reaction
(
CombustionModel<psiReactionThermo>::New(thermo, turbulence())
);
multivariateSurfaceInterpolationScheme<scalar>::fieldTable fields;

3
applications/solvers/combustion/reactingFoam/reactingFoam.C
View File

@ -34,7 +34,8 @@ Description
#include "fvCFD.H"
#include "turbulentFluidThermoModel.H"
#include "psiCombustionModel.H"
#include "psiReactionThermo.H"
#include "CombustionModel.H"
#include "multivariateScheme.H"
#include "pimpleControl.H"
#include "pressureControl.H"

19
applications/solvers/combustion/reactingFoam/rhoReactingBuoyantFoam/createFields.H
View File

@ -1,13 +1,8 @@
#include "createRDeltaT.H"
Info<< "Creating reaction model\n" << endl;
autoPtr<combustionModels::rhoCombustionModel> reaction
(
combustionModels::rhoCombustionModel::New(mesh)
);
rhoReactionThermo& thermo = reaction->thermo();
Info<< "Reading thermophysical properties\n" << endl;
autoPtr<rhoReactionThermo> pThermo(rhoReactionThermo::New(mesh));
rhoReactionThermo& thermo = pThermo();
thermo.validate(args.executable(), "h", "e");
basicMultiComponentMixture& composition = thermo.composition();
@ -67,9 +62,11 @@ autoPtr<compressible::turbulenceModel> turbulence
)
);
// Set the turbulence into the reaction model
reaction->setTurbulence(turbulence());
Info<< "Creating reaction model\n" << endl;
autoPtr<CombustionModel<rhoReactionThermo>> reaction
(
CombustionModel<rhoReactionThermo>::New(thermo, turbulence())
);
#include "readGravitationalAcceleration.H"
#include "readhRef.H"

3
applications/solvers/combustion/reactingFoam/rhoReactingBuoyantFoam/rhoReactingBuoyantFoam.C
View File

@ -34,7 +34,8 @@ Description
\*---------------------------------------------------------------------------*/
#include "fvCFD.H"
#include "rhoCombustionModel.H"
#include "rhoReactionThermo.H"
#include "CombustionModel.H"
#include "turbulentFluidThermoModel.H"
#include "multivariateScheme.H"
#include "pimpleControl.H"

18
applications/solvers/combustion/reactingFoam/rhoReactingFoam/createFields.H
View File

@ -1,13 +1,8 @@
#include "createRDeltaT.H"
Info<< "Creating reaction model\n" << endl;
autoPtr<combustionModels::rhoCombustionModel> reaction
(
combustionModels::rhoCombustionModel::New(mesh)
);
rhoReactionThermo& thermo = reaction->thermo();
Info<< "Reading thermophysical properties\n" << endl;
autoPtr<rhoReactionThermo> pThermo(rhoReactionThermo::New(mesh));
rhoReactionThermo& thermo = pThermo();
thermo.validate(args.executable(), "h", "e");
basicMultiComponentMixture& composition = thermo.composition();
@ -69,8 +64,11 @@ autoPtr<compressible::turbulenceModel> turbulence
)
);
// Set the turbulence into the reaction model
reaction->setTurbulence(turbulence());
Info<< "Creating reaction model\n" << endl;
autoPtr<CombustionModel<rhoReactionThermo>> reaction
(
CombustionModel<rhoReactionThermo>::New(thermo, turbulence())
);
multivariateSurfaceInterpolationScheme<scalar>::fieldTable fields;

3
applications/solvers/combustion/reactingFoam/rhoReactingFoam/rhoReactingFoam.C
View File

@ -34,7 +34,8 @@ Description
\*---------------------------------------------------------------------------*/
#include "fvCFD.H"
#include "rhoCombustionModel.H"
#include "rhoReactionThermo.H"
#include "CombustionModel.H"
#include "turbulentFluidThermoModel.H"
#include "multivariateScheme.H"
#include "pimpleControl.H"

3
applications/solvers/lagrangian/coalChemistryFoam/coalChemistryFoam.C
View File

@ -37,7 +37,8 @@ Description
#include "turbulentFluidThermoModel.H"
#include "basicThermoCloud.H"
#include "coalCloud.H"
#include "psiCombustionModel.H"
#include "psiReactionThermo.H"
#include "CombustionModel.H"
#include "fvOptions.H"
#include "radiationModel.H"
#include "SLGThermo.H"

18
applications/solvers/lagrangian/coalChemistryFoam/createFields.H
View File

@ -2,14 +2,9 @@
#include "readGravitationalAcceleration.H"
Info<< "Creating combustion model\n" << endl;
autoPtr<combustionModels::psiCombustionModel> combustion
(
combustionModels::psiCombustionModel::New(mesh)
);
psiReactionThermo& thermo = combustion->thermo();
Info<< "Reading thermophysical properties\n" << endl;
autoPtr<psiReactionThermo> pThermo(psiReactionThermo::New(mesh));
psiReactionThermo& thermo = pThermo();
thermo.validate(args.executable(), "h", "e");
SLGThermo slgThermo(mesh, thermo);
@ -112,8 +107,11 @@ autoPtr<compressible::turbulenceModel> turbulence
)
);
// Set the turbulence into the combustion model
combustion->setTurbulence(turbulence());
Info<< "Creating combustion model\n" << endl;
autoPtr<CombustionModel<psiReactionThermo>> combustion
(
CombustionModel<psiReactionThermo>::New(thermo, turbulence())
);
volScalarField Qdot
(

18
applications/solvers/lagrangian/reactingParcelFoam/createFields.H
View File

@ -1,13 +1,8 @@
#include "createRDeltaT.H"
Info<< "Creating combustion model\n" << endl;
autoPtr<combustionModels::rhoCombustionModel> combustion
(
combustionModels::rhoCombustionModel::New(mesh)
);
rhoReactionThermo& thermo = combustion->thermo();
Info<< "Reading thermophysical properties\n" << endl;
autoPtr<rhoReactionThermo> pThermo(rhoReactionThermo::New(mesh));
rhoReactionThermo& thermo = pThermo();
thermo.validate(args.executable(), "h", "e");
SLGThermo slgThermo(mesh, thermo);
@ -68,8 +63,11 @@ autoPtr<compressible::turbulenceModel> turbulence
)
);
// Set the turbulence into the combustion model
combustion->setTurbulence(turbulence());
Info<< "Creating combustion model\n" << endl;
autoPtr<CombustionModel<rhoReactionThermo>> combustion
(
CombustionModel<rhoReactionThermo>::New(thermo, turbulence())
);
#include "readGravitationalAcceleration.H"
#include "readhRef.H"

3
applications/solvers/lagrangian/reactingParcelFoam/reactingParcelFoam.C
View File

@ -37,7 +37,8 @@ Description
#include "turbulentFluidThermoModel.H"
#include "basicReactingMultiphaseCloud.H"
#include "surfaceFilmModel.H"
#include "rhoCombustionModel.H"
#include "rhoReactionThermo.H"
#include "CombustionModel.H"
#include "radiationModel.H"
#include "SLGThermo.H"
#include "fvOptions.H"

18
applications/solvers/lagrangian/reactingParcelFoam/simpleReactingParcelFoam/createFields.H
View File

@ -1,13 +1,8 @@
#include "readGravitationalAcceleration.H"
Info<< "Creating combustion model\n" << endl;
autoPtr<combustionModels::rhoCombustionModel> combustion
(
combustionModels::rhoCombustionModel::New(mesh)
);
rhoReactionThermo& thermo = combustion->thermo();
Info<< "Reading thermophysical properties\n" << endl;
autoPtr<rhoReactionThermo> pThermo(rhoReactionThermo::New(mesh));
rhoReactionThermo& thermo = pThermo();
thermo.validate(args.executable(), "h", "e");
SLGThermo slgThermo(mesh, thermo);
@ -91,8 +86,11 @@ autoPtr<compressible::turbulenceModel> turbulence
)
);
// Set the turbulence into the combustion model
combustion->setTurbulence(turbulence());
Info<< "Creating combustion model\n" << endl;
autoPtr<CombustionModel<rhoReactionThermo>> combustion
(
CombustionModel<rhoReactionThermo>::New(thermo, turbulence())
);
Info<< "Creating multi-variate interpolation scheme\n" << endl;
multivariateSurfaceInterpolationScheme<scalar>::fieldTable fields;

3
applications/solvers/lagrangian/reactingParcelFoam/simpleReactingParcelFoam/simpleReactingParcelFoam.C
View File

@ -33,7 +33,8 @@ Description
#include "fvCFD.H"
#include "turbulentFluidThermoModel.H"
#include "basicReactingMultiphaseCloud.H"
#include "rhoCombustionModel.H"
#include "rhoReactionThermo.H"
#include "CombustionModel.H"
#include "radiationModel.H"
#include "IOporosityModelList.H"
#include "fvOptions.H"

18
applications/solvers/lagrangian/sprayFoam/createFields.H
View File

@ -1,13 +1,8 @@
#include "readGravitationalAcceleration.H"
Info<< "Creating combustion model\n" << endl;
autoPtr<combustionModels::psiCombustionModel> combustion
(
combustionModels::psiCombustionModel::New(mesh)
);
psiReactionThermo& thermo = combustion->thermo();
Info<< "Reading thermophysical properties\n" << endl;
autoPtr<psiReactionThermo> pThermo(psiReactionThermo::New(mesh));
psiReactionThermo& thermo = pThermo();
thermo.validate(args.executable(), "h", "e");
SLGThermo slgThermo(mesh, thermo);
@ -91,8 +86,11 @@ autoPtr<compressible::turbulenceModel> turbulence
)
);
// Set the turbulence into the combustion model
combustion->setTurbulence(turbulence());
Info<< "Creating combustion model\n" << endl;
autoPtr<CombustionModel<psiReactionThermo>> combustion
(
CombustionModel<psiReactionThermo>::New(thermo, turbulence())
);
multivariateSurfaceInterpolationScheme<scalar>::fieldTable fields;

3
applications/solvers/lagrangian/sprayFoam/engineFoam/engineFoam.C
View File

@ -35,7 +35,8 @@ Description
#include "engineMesh.H"
#include "turbulentFluidThermoModel.H"
#include "basicSprayCloud.H"
#include "psiCombustionModel.H"
#include "psiReactionThermo.H"
#include "CombustionModel.H"
#include "radiationModel.H"
#include "SLGThermo.H"
#include "pimpleControl.H"

3
applications/solvers/lagrangian/sprayFoam/sprayDyMFoam/sprayDyMFoam.C
View File

@ -37,7 +37,8 @@ Description
#include "dynamicFvMesh.H"
#include "turbulenceModel.H"
#include "basicSprayCloud.H"
#include "psiCombustionModel.H"
#include "psiReactionThermo.H"
#include "CombustionModel.H"
#include "radiationModel.H"
#include "SLGThermo.H"
#include "pimpleControl.H"

3
applications/solvers/lagrangian/sprayFoam/sprayFoam.C
View File

@ -36,7 +36,8 @@ Description
#include "fvCFD.H"
#include "turbulentFluidThermoModel.H"
#include "basicSprayCloud.H"
#include "psiCombustionModel.H"
#include "psiReactionThermo.H"
#include "CombustionModel.H"
#include "radiationModel.H"
#include "SLGThermo.H"
#include "pimpleControl.H"

6
applications/solvers/multiphase/compressibleInterFoam/twoPhaseMixtureThermo/twoPhaseMixtureThermo.C
View File

@ -98,6 +98,12 @@ void Foam::twoPhaseMixtureThermo::correct()
}
Foam::word Foam::twoPhaseMixtureThermo::thermoName() const
{
return thermo1_->thermoName() + ',' + thermo2_->thermoName();
}
bool Foam::twoPhaseMixtureThermo::incompressible() const
{
return thermo1_->incompressible() && thermo2_->incompressible();

3
applications/solvers/multiphase/compressibleInterFoam/twoPhaseMixtureThermo/twoPhaseMixtureThermo.H
View File

@ -113,6 +113,9 @@ public:
//- Update mixture properties
virtual void correct();
//- Return the name of the thermo physics
virtual word thermoName() const;
//- Return true if the equation of state is incompressible
// i.e. rho != f(p)
virtual bool incompressible() const;

15
applications/solvers/multiphase/compressibleMultiphaseInterFoam/multiphaseMixtureThermo/multiphaseMixtureThermo.C
View File

@ -150,6 +150,21 @@ void Foam::multiphaseMixtureThermo::correctRho(const volScalarField& dp)
}
Foam::word Foam::multiphaseMixtureThermo::thermoName() const
{
PtrDictionary<phaseModel>::const_iterator phasei = phases_.begin();
word name = phasei().thermo().thermoName();
for (++ phasei; phasei != phases_.end(); ++ phasei)
{
name += ',' + phasei().thermo().thermoName();
}
return name;
}
bool Foam::multiphaseMixtureThermo::incompressible() const
{
bool ico = true;

3
applications/solvers/multiphase/compressibleMultiphaseInterFoam/multiphaseMixtureThermo/multiphaseMixtureThermo.H
View File

@ -227,6 +227,9 @@ public:
//- Update densities for given pressure change
void correctRho(const volScalarField& dp);
//- Return the name of the thermo physics
virtual word thermoName() const;
//- Return true if the equation of state is incompressible
// i.e. rho != f(p)
virtual bool incompressible() const;

8
applications/solvers/multiphase/reactingEulerFoam/phaseSystems/phaseModel/MovingPhaseModel/MovingPhaseModel.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2015-2016 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2015-2017 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -63,7 +63,9 @@ class MovingPhaseModel
:
public BasePhaseModel
{
// Private data
protected:
// Protected data
//- Velocity field
volVectorField U_;
@ -94,6 +96,8 @@ class MovingPhaseModel
tmp<surfaceScalarField> DbyA_;
private:
// Private static member functions
//- Calculate and return the flux field

40
applications/solvers/multiphase/reactingEulerFoam/phaseSystems/phaseModel/ReactingPhaseModel/ReactingPhaseModel.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2015-2016 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2015-2017 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -37,26 +37,9 @@ Foam::ReactingPhaseModel<BasePhaseModel, ReactionType>::ReactingPhaseModel
const label index
)
:
BasePhaseModel(fluid, phaseName, index, false),
reaction_
(
ReactionType::New
(
fluid.mesh(),
combustionModel::combustionPropertiesName,
this->name()
)
)
{
this->thermo_ = &reaction_->thermo();
this->thermo_->validate
(
IOobject::groupName(phaseModel::typeName, this->name()),
"h",
"e"
);
}
BasePhaseModel(fluid, phaseName, index),
reaction_(ReactionType::New(this->thermo_(), this->turbulence_()))
{}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
@ -71,21 +54,6 @@ Foam::ReactingPhaseModel<BasePhaseModel, ReactionType>::~ReactingPhaseModel()
template<class BasePhaseModel, class ReactionType>
void Foam::ReactingPhaseModel<BasePhaseModel, ReactionType>::correctThermo()
{
reaction_->setTurbulence
(
const_cast<compressibleTurbulenceModel&>
(
this->mesh().template lookupObject<compressibleTurbulenceModel>
(
IOobject::groupName
(
turbulenceModel::propertiesName,
this->name()
)
)
)
);
BasePhaseModel::correctThermo();
reaction_->correct();

34
applications/solvers/multiphase/reactingEulerFoam/phaseSystems/phaseModel/ThermoPhaseModel/ThermoPhaseModel.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2015 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2015-2017 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -41,28 +41,18 @@ Foam::ThermoPhaseModel<BasePhaseModel, ThermoType>::ThermoPhaseModel
(
const phaseSystem& fluid,
const word& phaseName,
const label index,
const bool createThermo
const label index
)
:
BasePhaseModel(fluid, phaseName, index)
BasePhaseModel(fluid, phaseName, index),
thermo_(ThermoType::New(fluid.mesh(), this->name()))
{
if (createThermo)
{
thermoPtr_.reset
(
ThermoType::New(fluid.mesh(), this->name()).ptr()
);
thermo_ = thermoPtr_.ptr();
thermo_->validate
(
IOobject::groupName(phaseModel::typeName, this->name()),
"h",
"e"
);
}
thermo_->validate
(
IOobject::groupName(phaseModel::typeName, this->name()),
"h",
"e"
);
}
@ -79,7 +69,7 @@ template<class BasePhaseModel, class ThermoType>
const Foam::rhoThermo&
Foam::ThermoPhaseModel<BasePhaseModel, ThermoType>::thermo() const
{
return *thermo_;
return thermo_();
}
@ -87,7 +77,7 @@ template<class BasePhaseModel, class ThermoType>
Foam::rhoThermo&
Foam::ThermoPhaseModel<BasePhaseModel, ThermoType>::thermo()
{
return *thermo_;
return thermo_();
}

10
applications/solvers/multiphase/reactingEulerFoam/phaseSystems/phaseModel/ThermoPhaseModel/ThermoPhaseModel.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2015-2016 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2015-2017 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -62,10 +62,7 @@ protected:
// Protected data
//- Thermophysical model
autoPtr<ThermoType> thermoPtr_;
//- Thermophysical model
ThermoType* thermo_;
autoPtr<ThermoType> thermo_;
public:
@ -76,8 +73,7 @@ public:
(
const phaseSystem& fluid,
const word& phaseName,
const label index,
const bool createThermo = true
const label index
);

42
applications/solvers/multiphase/reactingEulerFoam/phaseSystems/phaseModel/phaseModel/phaseModels.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2015 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2015-2017 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -28,7 +28,7 @@ License
#include "rhoThermo.H"
#include "rhoReactionThermo.H"
#include "rhoCombustionModel.H"
#include "CombustionModel.H"
#include "phaseModel.H"
#include "ThermoPhaseModel.H"
@ -45,13 +45,13 @@ License
namespace Foam
{
typedef
MovingPhaseModel
AnisothermalPhaseModel
<
AnisothermalPhaseModel
PurePhaseModel
<
PurePhaseModel
InertPhaseModel
<
InertPhaseModel
MovingPhaseModel
<
ThermoPhaseModel<phaseModel, rhoThermo>
>
@ -69,13 +69,13 @@ namespace Foam
);
typedef
MovingPhaseModel
IsothermalPhaseModel
<
IsothermalPhaseModel
PurePhaseModel
<
PurePhaseModel
InertPhaseModel
<
InertPhaseModel
MovingPhaseModel
<
ThermoPhaseModel<phaseModel, rhoThermo>
>
@ -93,13 +93,13 @@ namespace Foam
);
typedef
MovingPhaseModel
AnisothermalPhaseModel
<
AnisothermalPhaseModel
MultiComponentPhaseModel
<
MultiComponentPhaseModel
InertPhaseModel
<
InertPhaseModel
MovingPhaseModel
<
ThermoPhaseModel<phaseModel, rhoReactionThermo>
>
@ -117,17 +117,17 @@ namespace Foam
);
typedef
MovingPhaseModel
AnisothermalPhaseModel
<
AnisothermalPhaseModel
MultiComponentPhaseModel
<
MultiComponentPhaseModel
ReactingPhaseModel
<
ReactingPhaseModel
MovingPhaseModel
<
ThermoPhaseModel<phaseModel, rhoReactionThermo>,
combustionModels::rhoCombustionModel
>
ThermoPhaseModel<phaseModel, rhoReactionThermo>
>,
CombustionModel<rhoReactionThermo>
>
>
>

37
src/combustionModels/rhoCombustionModel/rhoChemistryCombustion/rhoChemistryCombustion.C → src/combustionModels/CombustionModel/ChemistryCombustion/ChemistryCombustion.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2012-2016 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2012-2017 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -23,40 +23,51 @@ License
\*---------------------------------------------------------------------------*/
#include "rhoChemistryCombustion.H"
#include "ChemistryCombustion.H"
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::combustionModels::rhoChemistryCombustion::rhoChemistryCombustion
template<class ReactionThermo>
Foam::ChemistryCombustion<ReactionThermo>::ChemistryCombustion
(
const word& modelType,
const fvMesh& mesh,
const word& combustionProperties,
const word& phaseName
ReactionThermo& thermo,
const compressibleTurbulenceModel& turb,
const word& combustionProperties
)
:
rhoCombustionModel(modelType, mesh, combustionProperties, phaseName),
chemistryPtr_(rhoChemistryModel::New(mesh, phaseName))
CombustionModel<ReactionThermo>
(
modelType,
thermo,
turb,
combustionProperties
),
chemistryPtr_(BasicChemistryModel<ReactionThermo>::New(thermo))
{}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::combustionModels::rhoChemistryCombustion::~rhoChemistryCombustion()
template<class ReactionThermo>
Foam::ChemistryCombustion<ReactionThermo>::
~ChemistryCombustion()
{}
// * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * * //
Foam::rhoReactionThermo&
Foam::combustionModels::rhoChemistryCombustion::thermo()
template<class ReactionThermo>
ReactionThermo&
Foam::ChemistryCombustion<ReactionThermo>::thermo()
{
return chemistryPtr_->thermo();
}
const Foam::rhoReactionThermo&
Foam::combustionModels::rhoChemistryCombustion::thermo() const
template<class ReactionThermo>
const ReactionThermo&
Foam::ChemistryCombustion<ReactionThermo>::thermo() const
{
return chemistryPtr_->thermo();
}

58
src/combustionModels/psiCombustionModel/psiThermoCombustion/psiThermoCombustion.H → src/combustionModels/CombustionModel/ChemistryCombustion/ChemistryCombustion.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2012-2016 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2012-2017 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -22,89 +22,85 @@ License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Class
Foam::psiThermoCombustion
Foam::ChemistryCombustion
Description
Compressibility-based thermo model wrapper for combustion models
Chemistry model wrapper for combustion models
SourceFiles
psiThermoCombustion.C
ChemistryCombustion.C
\*---------------------------------------------------------------------------*/
#ifndef psiThermoCombustion_H
#define psiThermoCombustion_H
#ifndef ChemistryCombustion_H
#define ChemistryCombustion_H
#include "autoPtr.H"
#include "psiCombustionModel.H"
#include "psiReactionThermo.H"
#include "CombustionModel.H"
#include "BasicChemistryModel.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
namespace combustionModels
{
/*---------------------------------------------------------------------------*\
class psiThermoCombustion Declaration
class ChemistryCombustion Declaration
\*---------------------------------------------------------------------------*/
class psiThermoCombustion
template<class ReactionThermo>
class ChemistryCombustion
:
public psiCombustionModel
public CombustionModel<ReactionThermo>
{
// Private Member Functions
//- Construct as copy (not implemented)
psiThermoCombustion(const psiThermoCombustion&);
//- Disallow default bitwise assignment
void operator=(const psiThermoCombustion&);
protected:
// Protected data
//- Pointer to chemistry model
autoPtr<psiReactionThermo> thermoPtr_;
autoPtr<BasicChemistryModel<ReactionThermo>> chemistryPtr_;
public:
// Constructors
//- Construct from components
psiThermoCombustion
//- Construct from components and thermo
ChemistryCombustion
(
const word& modelType,
const fvMesh& mesh,
const word& phaseName
ReactionThermo& thermo,
const compressibleTurbulenceModel& turb,
const word& combustionProperties
);
//- Destructor
virtual ~psiThermoCombustion();
virtual ~ChemistryCombustion();
// Member Functions
//- Return access to the thermo package
virtual psiReactionThermo& thermo();
virtual ReactionThermo& thermo();
//- Return const access to the thermo package
virtual const psiReactionThermo& thermo() const;
virtual const ReactionThermo& thermo() const;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace combustionModels
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#ifdef NoRepository
#include "ChemistryCombustion.C"
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

53
src/combustionModels/rhoCombustionModel/rhoCombustionModel/rhoCombustionModel.C → src/combustionModels/CombustionModel/CombustionModel/CombustionModel.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2017 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -23,42 +23,55 @@ License
\*---------------------------------------------------------------------------*/
#include "rhoCombustionModel.H"
/* * * * * * * * * * * * * * * private static data * * * * * * * * * * * * * */
namespace Foam
{
namespace combustionModels
{
defineTypeNameAndDebug(rhoCombustionModel, 0);
defineRunTimeSelectionTable(rhoCombustionModel, dictionary);
}
}
#include "CombustionModel.H"
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::combustionModels::rhoCombustionModel::rhoCombustionModel
template<class ReactionThermo>
Foam::CombustionModel<ReactionThermo>::CombustionModel
(
const word& modelType,
const fvMesh& mesh,
const word& combustionProperties,
const word& phaseName
ReactionThermo& thermo,
const compressibleTurbulenceModel& turb,
const word& combustionProperties
)
:
combustionModel(modelType, mesh, combustionProperties, phaseName)
combustionModel(modelType, thermo, turb, combustionProperties)
{}
// * * * * * * * * * * * * * * * * Selectors * * * * * * * * * * * * * * * * //
template<class ReactionThermo>
Foam::autoPtr<Foam::CombustionModel<ReactionThermo>>
Foam::CombustionModel<ReactionThermo>::New
(
ReactionThermo& thermo,
const compressibleTurbulenceModel& turb,
const word& combustionProperties
)
{
return
combustionModel::New<CombustionModel<ReactionThermo>>
(
thermo,
turb,
combustionProperties
);
}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::combustionModels::rhoCombustionModel::~rhoCombustionModel()
template<class ReactionThermo>
Foam::CombustionModel<ReactionThermo>::~CombustionModel()
{}
// * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * * //
bool Foam::combustionModels::rhoCombustionModel::read()
template<class ReactionThermo>
bool Foam::CombustionModel<ReactionThermo>::read()
{
if (combustionModel::read())
{

77
src/combustionModels/psiCombustionModel/psiCombustionModel/psiCombustionModel.H → src/combustionModels/CombustionModel/CombustionModel/CombustionModel.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2017 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -22,107 +22,97 @@ License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Class
Foam::psiCombustionModel
Foam::CombustionModel
Description
Combustion models for compressibility-based thermodynamics
Combustion models for templated thermodynamics
SourceFiles
psiCombustionModelI.H
psiCombustionModel.C
psiCombustionModelNew.C
CombustionModelI.H
CombustionModel.C
CombustionModelNew.C
\*---------------------------------------------------------------------------*/
#ifndef psiCombustionModel_H
#define psiCombustionModel_H
#ifndef CombustionModel_H
#define CombustionModel_H
#include "combustionModel.H"
#include "autoPtr.H"
#include "runTimeSelectionTables.H"
#include "psiReactionThermo.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
namespace combustionModels
{
/*---------------------------------------------------------------------------*\
class psiCombustionModel Declaration
class CombustionModel Declaration
\*---------------------------------------------------------------------------*/
class psiCombustionModel
template<class ReactionThermo>
class CombustionModel
:
public combustionModel
{
// Private Member Functions
//- Construct as copy (not implemented)
psiCombustionModel(const psiCombustionModel&);
//- Disallow default bitwise assignment
void operator=(const psiCombustionModel&);
public:
typedef psiReactionThermo ReactionThermo;
//- Thermo type
typedef ReactionThermo reactionThermo;
//- Runtime type information
TypeName("psiCombustionModel");
TypeName("CombustionModel");
//- Declare run-time constructor selection tables
declareRunTimeSelectionTable
(
autoPtr,
psiCombustionModel,
CombustionModel,
dictionary,
(
const word& modelType,
const fvMesh& mesh,
const word& combustionProperties,
const word& phaseName
ReactionThermo& thermo,
const compressibleTurbulenceModel& turb,
const word& combustionProperties
),
(modelType, mesh, combustionProperties, phaseName)
(modelType, thermo, turb, combustionProperties)
);
// Constructors
//- Construct from components
psiCombustionModel
CombustionModel
(
const word& modelType,
const fvMesh& mesh,
const word& combustionProperties,
const word& phaseName
ReactionThermo& thermo,
const compressibleTurbulenceModel& turb,
const word& combustionProperties
);
//- Selector
static autoPtr<psiCombustionModel> New
static autoPtr<CombustionModel> New
(
const fvMesh& mesh,
const word& combustionProperties=combustionPropertiesName,
const word& phaseName=word::null
ReactionThermo& thermo,
const compressibleTurbulenceModel& turb,
const word& combustionProperties=combustionPropertiesName
);
//- Destructor
virtual ~psiCombustionModel();
virtual ~CombustionModel();
// Member Functions
//- Return access to the thermo package
virtual psiReactionThermo& thermo() = 0;
virtual ReactionThermo& thermo() = 0;
//- Return const access to the thermo package
virtual const psiReactionThermo& thermo() const = 0;
virtual const ReactionThermo& thermo() const = 0;
// IO
@ -134,11 +124,16 @@ public:
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace combustionModels
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#ifdef NoRepository
#include "CombustionModel.C"
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

25
src/thermophysicalModels/chemistryModel/chemistryModel/rhoChemistryModel/rhoChemistryModelI.H → src/combustionModels/CombustionModel/CombustionModel/CombustionModels.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2012 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2017 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -23,18 +23,21 @@ License
\*---------------------------------------------------------------------------*/
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
#include "makeCombustionTypes.H"
inline Foam::rhoReactionThermo& Foam::rhoChemistryModel::thermo()
#include "CombustionModel.H"
#include "rhoReactionThermo.H"
#include "psiReactionThermo.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
return *thermo_;
makeCombustion(psiReactionThermo);
makeCombustion(rhoReactionThermo);
}
inline const Foam::rhoReactionThermo& Foam::rhoChemistryModel::thermo() const
{
return *thermo_;
}
// ************************************************************************* //

39
src/combustionModels/psiCombustionModel/psiChemistryCombustion/psiChemistryCombustion.C → src/combustionModels/CombustionModel/ThermoCombustion/ThermoCombustion.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2012-2016 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2012-2017 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -23,42 +23,51 @@ License
\*---------------------------------------------------------------------------*/
#include "psiChemistryCombustion.H"
#include "ThermoCombustion.H"
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::combustionModels::psiChemistryCombustion::psiChemistryCombustion
template<class ReactionThermo>
Foam::ThermoCombustion<ReactionThermo>::ThermoCombustion
(
const word& modelType,
const fvMesh& mesh,
const word& combustionProperties,
const word& phaseName
ReactionThermo& thermo,
const compressibleTurbulenceModel& turb
)
:
psiCombustionModel(modelType, mesh, combustionProperties, phaseName),
chemistryPtr_(psiChemistryModel::New(mesh, phaseName))
CombustionModel<ReactionThermo>
(
modelType,
thermo,
turb,
combustionModel::combustionPropertiesName
),
thermo_(thermo)
{}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::combustionModels::psiChemistryCombustion::~psiChemistryCombustion()
template<class ReactionThermo>
Foam::ThermoCombustion<ReactionThermo>::~ThermoCombustion()
{}
// * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * * //
Foam::psiReactionThermo&
Foam::combustionModels::psiChemistryCombustion::thermo()
template<class ReactionThermo>
ReactionThermo&
Foam::ThermoCombustion<ReactionThermo>::thermo()
{
return chemistryPtr_->thermo();
return thermo_;
}
const Foam::psiReactionThermo&
Foam::combustionModels::psiChemistryCombustion::thermo() const
template<class ReactionThermo>
const ReactionThermo&
Foam::ThermoCombustion<ReactionThermo>::thermo() const
{
return chemistryPtr_->thermo();
return thermo_;
}

56
src/combustionModels/rhoCombustionModel/rhoThermoCombustion/rhoThermoCombustion.H → src/combustionModels/CombustionModel/ThermoCombustion/ThermoCombustion.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2012-2016 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2012-2017 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -22,53 +22,42 @@ License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Class
Foam::rhoThermoCombustion
Foam::ThermoCombustion
Description
Density-based thermo model wrapper for combustion models
Thermo model wrapper for combustion models
SourceFiles
rhoThermoCombustion.C
ThermoCombustion.C
\*---------------------------------------------------------------------------*/
#ifndef rhoThermoCombustion_H
#define rhoThermoCombustion_H
#ifndef ThermoCombustion_H
#define ThermoCombustion_H
#include "autoPtr.H"
#include "rhoCombustionModel.H"
#include "rhoChemistryModel.H"
#include "CombustionModel.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
namespace combustionModels
{
/*---------------------------------------------------------------------------*\
class rhoThermoCombustion Declaration
class ThermoCombustion Declaration
\*---------------------------------------------------------------------------*/
class rhoThermoCombustion
template<class ReactionThermo>
class ThermoCombustion
:
public rhoCombustionModel
public CombustionModel<ReactionThermo>
{
// Private Member Functions
//- Construct as copy (not implemented)
rhoThermoCombustion(const rhoThermoCombustion&);
//- Disallow default bitwise assignment
void operator=(const rhoThermoCombustion&);
protected:
// Protected data
//- Pointer to thermo model
autoPtr<rhoReactionThermo> thermoPtr_;
//- Thermo
ReactionThermo& thermo_;
public:
@ -76,35 +65,40 @@ public:
// Constructors
//- Construct from components
rhoThermoCombustion
ThermoCombustion
(
const word& modelType,
const fvMesh& mesh,
const word& phaseName
ReactionThermo& thermo,
const compressibleTurbulenceModel& turb
);
//- Destructor
virtual ~rhoThermoCombustion();
virtual ~ThermoCombustion();
// Member Functions
//- Return access to the thermo package
virtual rhoReactionThermo& thermo();
virtual ReactionThermo& thermo();
//- Return const access to the thermo package
virtual const rhoReactionThermo& thermo() const;
virtual const ReactionThermo& thermo() const;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace combustionModels
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#ifdef NoRepository
#include "ThermoCombustion.C"
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

46
src/combustionModels/EDC/EDC.C
View File

@ -27,16 +27,16 @@ License
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class Type>
Foam::combustionModels::EDC<Type>::EDC
template<class ReactionThermo>
Foam::combustionModels::EDC<ReactionThermo>::EDC
(
const word& modelType,
const fvMesh& mesh,
const word& combustionProperties,
const word& phaseName
ReactionThermo& thermo,
const compressibleTurbulenceModel& turb,
const word& combustionProperties
)
:
laminar<Type>(modelType, mesh, combustionProperties, phaseName),
laminar<ReactionThermo>(modelType, thermo, turb, combustionProperties),
version_
(
EDCversionNames.lookupOrDefault
@ -56,13 +56,13 @@ Foam::combustionModels::EDC<Type>::EDC
(
IOobject
(
IOobject::groupName(typeName + ":kappa", phaseName),
mesh.time().timeName(),
mesh,
this->thermo().phasePropertyName(typeName + ":kappa"),
this->mesh().time().timeName(),
this->mesh(),
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
mesh,
this->mesh(),
dimensionedScalar(dimless, Zero)
)
{}
@ -70,15 +70,15 @@ Foam::combustionModels::EDC<Type>::EDC
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
template<class Type>
Foam::combustionModels::EDC<Type>::~EDC()
template<class ReactionThermo>
Foam::combustionModels::EDC<ReactionThermo>::~EDC()
{}
// * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * * //
template<class Type>
void Foam::combustionModels::EDC<Type>::correct()
template<class ReactionThermo>
void Foam::combustionModels::EDC<ReactionThermo>::correct()
{
if (this->active())
{
@ -172,17 +172,17 @@ void Foam::combustionModels::EDC<Type>::correct()
}
template<class Type>
template<class ReactionThermo>
Foam::tmp<Foam::fvScalarMatrix>
Foam::combustionModels::EDC<Type>::R(volScalarField& Y) const
Foam::combustionModels::EDC<ReactionThermo>::R(volScalarField& Y) const
{
return kappa_*laminar<Type>::R(Y);
return kappa_*laminar<ReactionThermo>::R(Y);
}
template<class Type>
template<class ReactionThermo>
Foam::tmp<Foam::volScalarField>
Foam::combustionModels::EDC<Type>::Qdot() const
Foam::combustionModels::EDC<ReactionThermo>::Qdot() const
{
tmp<volScalarField> tQdot
(
@ -190,7 +190,7 @@ Foam::combustionModels::EDC<Type>::Qdot() const
(
IOobject
(
IOobject::groupName(typeName + ":Qdot", this->phaseName_),
this->thermo().phasePropertyName(typeName + ":Qdot"),
this->mesh().time().timeName(),
this->mesh(),
IOobject::NO_READ,
@ -211,10 +211,10 @@ Foam::combustionModels::EDC<Type>::Qdot() const
}
template<class Type>
bool Foam::combustionModels::EDC<Type>::read()
template<class ReactionThermo>
bool Foam::combustionModels::EDC<ReactionThermo>::read()
{
if (Type::read())
if (laminar<ReactionThermo>::read())
{
version_ =
(

10
src/combustionModels/EDC/EDC.H
View File

@ -128,10 +128,10 @@ const scalar EDCexp2[] = {3, 3, 2, 2};
Class EDC Declaration
\*---------------------------------------------------------------------------*/
template<class Type>
template<class ReactionThermo>
class EDC
:
public laminar<Type>
public laminar<ReactionThermo>
{
// Private data
@ -170,9 +170,9 @@ public:
EDC
(
const word& modelType,
const fvMesh& mesh,
const word& combustionProperties,
const word& phaseName
ReactionThermo& type,
const compressibleTurbulenceModel& turb,
const word& combustionProperties
);

12
src/combustionModels/EDC/EDCs.C
View File

@ -25,8 +25,8 @@ License
#include "makeCombustionTypes.H"
#include "psiChemistryCombustion.H"
#include "rhoChemistryCombustion.H"
#include "psiReactionThermo.H"
#include "rhoReactionThermo.H"
#include "EDC.H"
// * * * * * * * * * * * * * Static Member Data * * * * * * * * * * * * * * //
@ -49,8 +49,12 @@ Foam::combustionModels::EDCdefaultVersion(EDCversions::v2005);
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
makeCombustionTypes(EDC, psiChemistryCombustion, psiCombustionModel);
makeCombustionTypes(EDC, rhoChemistryCombustion, rhoCombustionModel);
namespace Foam
{
makeCombustionTypes(EDC, psiReactionThermo);
makeCombustionTypes(EDC, rhoReactionThermo);
}
// ************************************************************************* //

52
src/combustionModels/FSD/FSD.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2017 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -36,21 +36,21 @@ namespace combustionModels
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class CombThermoType, class ThermoType>
FSD<CombThermoType, ThermoType>::FSD
template<class ReactionThermo, class ThermoType>
FSD<ReactionThermo, ThermoType>::FSD
(
const word& modelType,
const fvMesh& mesh,
const word& combustionProperties,
const word& phaseName
ReactionThermo& thermo,
const compressibleTurbulenceModel& turb,
const word& combustionProperties
)
:
singleStepCombustion<CombThermoType, ThermoType>
singleStepCombustion<ReactionThermo, ThermoType>
(
modelType,
mesh,
combustionProperties,
phaseName
thermo,
turb,
combustionProperties
),
reactionRateFlameArea_
(
@ -65,7 +65,7 @@ FSD<CombThermoType, ThermoType>::FSD
(
IOobject
(
IOobject::groupName("ft", phaseName),
this->thermo().phasePropertyName("ft"),
this->mesh().time().timeName(),
this->mesh(),
IOobject::NO_READ,
@ -87,23 +87,23 @@ FSD<CombThermoType, ThermoType>::FSD
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
template<class CombThermoType, class ThermoType>
FSD<CombThermoType, ThermoType>::~FSD()
template<class ReactionThermo, class ThermoType>
FSD<ReactionThermo, ThermoType>::~FSD()
{}
// * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * * //
template<class CombThermoType, class ThermoType>
void FSD<CombThermoType, ThermoType>::calculateSourceNorm()
template<class ReactionThermo, class ThermoType>
void FSD<ReactionThermo, ThermoType>::calculateSourceNorm()
{
this->singleMixturePtr_->fresCorrect();
const label fuelI = this->singleMixturePtr_->fuelIndex();
const volScalarField& YFuel = this->thermoPtr_->composition().Y()[fuelI];
const volScalarField& YFuel = this->thermo().composition().Y()[fuelI];
const volScalarField& YO2 = this->thermoPtr_->composition().Y("O2");
const volScalarField& YO2 = this->thermo().composition().Y("O2");
const dimensionedScalar s = this->singleMixturePtr_->s();
@ -152,7 +152,7 @@ void FSD<CombThermoType, ThermoType>::calculateSourceNorm()
(
IOobject
(
IOobject::groupName("Pc", this->phaseName_),
this->thermo().phasePropertyName("Pc"),
U.time().timeName(),
U.db(),
IOobject::NO_READ,
@ -171,7 +171,7 @@ void FSD<CombThermoType, ThermoType>::calculateSourceNorm()
(
IOobject
(
IOobject::groupName("omegaFuelBar", this->phaseName_),
this->thermo().phasePropertyName("omegaFuelBar"),
U.time().timeName(),
U.db(),
IOobject::NO_READ,
@ -297,7 +297,7 @@ void FSD<CombThermoType, ThermoType>::calculateSourceNorm()
(
IOobject
(
IOobject::groupName("products", this->phaseName_),
this->thermo().phasePropertyName("products"),
U.time().timeName(),
U.db(),
IOobject::NO_READ,
@ -313,7 +313,7 @@ void FSD<CombThermoType, ThermoType>::calculateSourceNorm()
forAll(productsIndex, j)
{
label specieI = productsIndex[j];
const volScalarField& Yp = this->thermoPtr_->composition().Y()[specieI];
const volScalarField& Yp = this->thermo().composition().Y()[specieI];
products += Yp;
}
@ -330,8 +330,8 @@ void FSD<CombThermoType, ThermoType>::calculateSourceNorm()
}
template<class CombThermoType, class ThermoType>
void FSD<CombThermoType, ThermoType>::correct()
template<class ReactionThermo, class ThermoType>
void FSD<ReactionThermo, ThermoType>::correct()
{
this->wFuel_ == dimensionedScalar(dimMass/dimTime/dimVolume, Zero);
@ -342,10 +342,10 @@ void FSD<CombThermoType, ThermoType>::correct()
}
template<class CombThermoType, class ThermoType>
bool FSD<CombThermoType, ThermoType>::read()
template<class ReactionThermo, class ThermoType>
bool FSD<ReactionThermo, ThermoType>::read()
{
if (singleStepCombustion<CombThermoType, ThermoType>::read())
if (singleStepCombustion<ReactionThermo, ThermoType>::read())
{
this->coeffs().lookup("Cv") >> Cv_ ;
this->coeffs().lookup("ftVarMin") >> ftVarMin_;

12
src/combustionModels/FSD/FSD.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2017 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -80,10 +80,10 @@ namespace combustionModels
Class FSD Declaration
\*---------------------------------------------------------------------------*/
template<class CombThermoType, class ThermoType>
template<class ReactionThermo, class ThermoType>
class FSD
:
public singleStepCombustion <CombThermoType, ThermoType>
public singleStepCombustion <ReactionThermo, ThermoType>
{
// Private data
@ -142,9 +142,9 @@ public:
FSD
(
const word& modelType,
const fvMesh& mesh,
const word& combustionProperties,
const word& phaseName
ReactionThermo& thermo,
const compressibleTurbulenceModel& turb,
const word& combustionProperties
);

52
src/combustionModels/FSD/FSDs.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2017 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -26,79 +26,73 @@ License
#include "makeCombustionTypes.H"
#include "thermoPhysicsTypes.H"
#include "psiCombustionModel.H"
#include "psiThermoCombustion.H"
#include "rhoCombustionModel.H"
#include "rhoThermoCombustion.H"
#include "psiReactionThermo.H"
#include "rhoReactionThermo.H"
#include "FSD.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// Combustion models based on sensibleEnthalpy
makeCombustionTypesThermo
(
FSD,
psiThermoCombustion,
gasHThermoPhysics,
psiCombustionModel
psiReactionThermo,
gasHThermoPhysics
);
makeCombustionTypesThermo
(
FSD,
psiThermoCombustion,
constGasHThermoPhysics,
psiCombustionModel
psiReactionThermo,
constGasHThermoPhysics
);
makeCombustionTypesThermo
(
FSD,
rhoThermoCombustion,
gasHThermoPhysics,
rhoCombustionModel
rhoReactionThermo,
gasHThermoPhysics
);
makeCombustionTypesThermo
(
FSD,
rhoThermoCombustion,
constGasHThermoPhysics,
rhoCombustionModel
rhoReactionThermo,
constGasHThermoPhysics
);
// Combustion models based on sensibleInternalEnergy
makeCombustionTypesThermo
(
FSD,
psiThermoCombustion,
gasEThermoPhysics,
psiCombustionModel
psiReactionThermo,
gasEThermoPhysics
);
makeCombustionTypesThermo
(
FSD,
psiThermoCombustion,
constGasEThermoPhysics,
psiCombustionModel
psiReactionThermo,
constGasEThermoPhysics
);
makeCombustionTypesThermo
(
FSD,
rhoThermoCombustion,
gasEThermoPhysics,
rhoCombustionModel
rhoReactionThermo,
gasEThermoPhysics
);
makeCombustionTypesThermo
(
FSD,
rhoThermoCombustion,
constGasEThermoPhysics,
rhoCombustionModel
rhoReactionThermo,
constGasEThermoPhysics
);
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

11
src/combustionModels/Make/files
View File

@ -1,14 +1,5 @@
combustionModel/combustionModel.C
psiCombustionModel/psiCombustionModel/psiCombustionModel.C
psiCombustionModel/psiCombustionModel/psiCombustionModelNew.C
psiCombustionModel/psiThermoCombustion/psiThermoCombustion.C
psiCombustionModel/psiChemistryCombustion/psiChemistryCombustion.C
rhoCombustionModel/rhoCombustionModel/rhoCombustionModel.C
rhoCombustionModel/rhoCombustionModel/rhoCombustionModelNew.C
rhoCombustionModel/rhoThermoCombustion/rhoThermoCombustion.C
rhoCombustionModel/rhoChemistryCombustion/rhoChemistryCombustion.C
CombustionModel/CombustionModel/CombustionModels.C
diffusion/diffusions.C
infinitelyFastChemistry/infinitelyFastChemistrys.C

50
src/combustionModels/PaSR/PaSR.C
View File

@ -27,28 +27,28 @@ License
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class Type>
Foam::combustionModels::PaSR<Type>::PaSR
template<class ReactionThermo>
Foam::combustionModels::PaSR<ReactionThermo>::PaSR
(
const word& modelType,
const fvMesh& mesh,
const word& combustionProperties,
const word& phaseName
ReactionThermo& thermo,
const compressibleTurbulenceModel& turb,
const word& combustionProperties
)
:
laminar<Type>(modelType, mesh, combustionProperties, phaseName),
laminar<ReactionThermo>(modelType, thermo, turb, combustionProperties),
Cmix_(readScalar(this->coeffs().lookup("Cmix"))),
kappa_
(
IOobject
(
IOobject::groupName(typeName + ":kappa", phaseName),
mesh.time().timeName(),
mesh,
thermo.phasePropertyName(typeName + ":kappa"),
this->mesh().time().timeName(),
this->mesh(),
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
mesh,
this->mesh(),
dimensionedScalar(dimless, Zero)
)
{}
@ -56,19 +56,19 @@ Foam::combustionModels::PaSR<Type>::PaSR
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
template<class Type>
Foam::combustionModels::PaSR<Type>::~PaSR()
template<class ReactionThermo>
Foam::combustionModels::PaSR<ReactionThermo>::~PaSR()
{}
// * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * * //
template<class Type>
void Foam::combustionModels::PaSR<Type>::correct()
template<class ReactionThermo>
void Foam::combustionModels::PaSR<ReactionThermo>::correct()
{
if (this->active())
{
laminar<Type>::correct();
laminar<ReactionThermo>::correct();
tmp<volScalarField> tepsilon(this->turbulence().epsilon());
const scalarField& epsilon = tepsilon();
@ -100,33 +100,33 @@ void Foam::combustionModels::PaSR<Type>::correct()
}
template<class Type>
template<class ReactionThermo>
Foam::tmp<Foam::fvScalarMatrix>
Foam::combustionModels::PaSR<Type>::R(volScalarField& Y) const
Foam::combustionModels::PaSR<ReactionThermo>::R(volScalarField& Y) const
{
return kappa_*laminar<Type>::R(Y);
return kappa_*laminar<ReactionThermo>::R(Y);
}
template<class Type>
template<class ReactionThermo>
Foam::tmp<Foam::volScalarField>
Foam::combustionModels::PaSR<Type>::Qdot() const
Foam::combustionModels::PaSR<ReactionThermo>::Qdot() const
{
return tmp<volScalarField>
(
new volScalarField
(
IOobject::groupName(typeName + ":Qdot", this->phaseName_),
kappa_*laminar<Type>::Qdot()
this->thermo().phasePropertyName(typeName + ":Qdot"),
kappa_*laminar<ReactionThermo>::Qdot()
)
);
}
template<class Type>
bool Foam::combustionModels::PaSR<Type>::read()
template<class ReactionThermo>
bool Foam::combustionModels::PaSR<ReactionThermo>::read()
{
if (laminar<Type>::read())
if (laminar<ReactionThermo>::read())
{
this->coeffs().lookup("Cmix") >> Cmix_;
return true;

10
src/combustionModels/PaSR/PaSR.H
View File

@ -55,10 +55,10 @@ namespace combustionModels
Class PaSR Declaration
\*---------------------------------------------------------------------------*/
template<class Type>
template<class ReactionThermo>
class PaSR
:
public laminar<Type>
public laminar<ReactionThermo>
{
// Private data
@ -90,9 +90,9 @@ public:
PaSR
(
const word& modelType,
const fvMesh& mesh,
const word& combustionProperties,
const word& phaseName
ReactionThermo& thermo,
const compressibleTurbulenceModel& turb,
const word& combustionProperties
);

14
src/combustionModels/PaSR/PaSRs.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2017 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -25,14 +25,18 @@ License
#include "makeCombustionTypes.H"
#include "psiChemistryCombustion.H"
#include "rhoChemistryCombustion.H"
#include "psiReactionThermo.H"
#include "rhoReactionThermo.H"
#include "PaSR.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
makeCombustionTypes(PaSR, psiChemistryCombustion, psiCombustionModel);
makeCombustionTypes(PaSR, rhoChemistryCombustion, rhoCombustionModel);
namespace Foam
{
makeCombustionTypes(PaSR, psiReactionThermo);
makeCombustionTypes(PaSR, rhoReactionThermo);
}
// ************************************************************************* //

62
src/combustionModels/combustionModel/combustionModel.C
View File

@ -38,45 +38,59 @@ const Foam::word Foam::combustionModel::combustionPropertiesName
);
// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * //
Foam::IOobject Foam::combustionModel::createIOobject
(
basicThermo& thermo,
const word& combustionProperties
) const
{
IOobject io
(
thermo.phasePropertyName(combustionProperties),
thermo.db().time().constant(),
thermo.db(),
IOobject::MUST_READ,
IOobject::NO_WRITE
);
if (io.typeHeaderOk<IOdictionary>(true))
{
io.readOpt() = IOobject::MUST_READ_IF_MODIFIED;
return io;
}
else
{
io.readOpt() = IOobject::NO_READ;
return io;
}
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::combustionModel::combustionModel
(
const word& modelType,
const fvMesh& mesh,
const word& combustionProperties,
const word& phaseName
basicThermo& thermo,
const compressibleTurbulenceModel& turb,
const word& combustionProperties
)
:
IOdictionary
(
IOobject
(
IOobject::groupName(combustionProperties, phaseName),
mesh.time().constant(),
mesh,
IOobject::MUST_READ_IF_MODIFIED,
IOobject::NO_WRITE
)
),
turbulencePtr_(),
mesh_(mesh),
IOdictionary(createIOobject(thermo, combustionProperties)),
mesh_(thermo.p().mesh()),
turb_(turb),
active_(lookupOrDefault<Switch>("active", true)),
coeffs_(optionalSubDict(modelType + "Coeffs")),
modelType_(modelType),
phaseName_(phaseName)
modelType_(modelType)
{}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::combustionModel::~combustionModel()
{
if (turbulencePtr_)
{
turbulencePtr_ = 0;
}
}
{}
// * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * * //

43
src/combustionModels/combustionModel/combustionModel.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2017 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -62,17 +62,24 @@ class combustionModel
//- Disallow default bitwise assignment
void operator=(const combustionModel&);
//- Construct the base IO object
IOobject createIOobject
(
basicThermo& thermo,
const word& combustionProperties
) const;
protected:
// Protected data
//- Reference to the turbulence model
compressibleTurbulenceModel* turbulencePtr_;
//- Reference to the mesh database
const fvMesh& mesh_;
//- Reference to the turbulence model
const compressibleTurbulenceModel& turb_;
//- Active
Switch active_;
@ -82,9 +89,6 @@ protected:
//- Model type
const word modelType_;
//- Phase name
const word phaseName_;
public:
@ -101,9 +105,21 @@ public:
combustionModel
(
const word& modelType,
const fvMesh& mesh,
const word& combustionProperties=combustionPropertiesName,
const word& phaseName=word::null
basicThermo& thermo,
const compressibleTurbulenceModel& turb,
const word& combustionProperties=combustionPropertiesName
);
// Selectors
//- Generic New for each of the related chemistry model
template<class CombustionModel>
static autoPtr<CombustionModel> New
(
typename CombustionModel::reactionThermo& thermo,
const compressibleTurbulenceModel& turb,
const word& combustionProperties
);
@ -116,9 +132,6 @@ public:
//- Return const access to the mesh database
inline const fvMesh& mesh() const;
//- Set turbulence
inline void setTurbulence(compressibleTurbulenceModel& turbModel);
//- Return access to turbulence
inline const compressibleTurbulenceModel& turbulence() const;
@ -156,6 +169,10 @@ public:
#include "combustionModelI.H"
#ifdef NoRepository
#include "combustionModelTemplates.C"
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif

22
src/combustionModels/combustionModel/combustionModelI.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2017 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -34,16 +34,7 @@ inline const Foam::fvMesh& Foam::combustionModel::mesh() const
inline const Foam::compressibleTurbulenceModel&
Foam::combustionModel::turbulence() const
{
if (!turbulencePtr_)
{
FatalErrorInFunction
<< "turbulencePtr_ is empty. Please use "
<< "combustionModel::setTurbulence "
<< "(compressibleTurbulenceModel&)"
<< abort(FatalError);
}
return *turbulencePtr_;
return turb_;
}
@ -65,15 +56,6 @@ inline const Foam::Switch& Foam::combustionModel::active() const
}
inline void Foam::combustionModel::setTurbulence
(
compressibleTurbulenceModel& turbModel
)
{
turbulencePtr_ = &turbModel;
}
inline const Foam::dictionary& Foam::combustionModel::coeffs() const
{
return coeffs_;

180
src/combustionModels/combustionModel/combustionModelTemplates.C Normal file
View File

@ -0,0 +1,180 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-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/>.
\*---------------------------------------------------------------------------*/
// * * * * * * * * * * * * * * * * Selectors * * * * * * * * * * * * * * * * //
template<class CombustionModel>
Foam::autoPtr<CombustionModel> Foam::combustionModel::New
(
typename CombustionModel::reactionThermo& thermo,
const compressibleTurbulenceModel& turb,
const word& combustionProperties
)
{
IOobject combIO
(
IOobject
(
thermo.phasePropertyName(combustionProperties),
thermo.db().time().constant(),
thermo.db(),
IOobject::MUST_READ,
IOobject::NO_WRITE,
false
)
);
word combModelName("none");
if (combIO.typeHeaderOk<IOdictionary>(false))
{
IOdictionary(combIO).lookup("combustionModel") >> combModelName;
}
else
{
Info<< "Combustion model not active: "
<< thermo.phasePropertyName(combustionProperties)
<< " not found" << endl;
}
Info<< "Selecting combustion model " << combModelName << endl;
const wordList cmpts2(basicThermo::splitThermoName(combModelName, 2));
const wordList cmpts3(basicThermo::splitThermoName(combModelName, 3));
if (cmpts2.size() == 2 || cmpts3.size() == 3)
{
combModelName = cmpts2.size() ? cmpts2[0] : cmpts3[0];
WarningInFunction
<< "Template parameters are no longer required when selecting a "
<< combustionModel::typeName << ". This information is now "
<< "obtained directly from the thermodynamics. Actually selecting "
<< "combustion model " << combModelName << "." << endl;
}
typedef typename CombustionModel::dictionaryConstructorTable cstrTableType;
cstrTableType* cstrTable = CombustionModel::dictionaryConstructorTablePtr_;
const word compCombModelName =
combModelName + '<' + CombustionModel::reactionThermo::typeName + '>';
const word thermoCombModelName =
combModelName + '<' + CombustionModel::reactionThermo::typeName + ','
+ thermo.thermoName() + '>';
typename cstrTableType::iterator compCstrIter =
cstrTable->find(compCombModelName);
typename cstrTableType::iterator thermoCstrIter =
cstrTable->find(thermoCombModelName);
if (compCstrIter == cstrTable->end() && thermoCstrIter == cstrTable->end())
{
FatalErrorInFunction
<< "Unknown " << combustionModel::typeName << " type "
<< combModelName << endl << endl;
const wordList names(cstrTable->toc());
wordList thisCmpts;
thisCmpts.append(word::null);
thisCmpts.append(CombustionModel::reactionThermo::typeName);
thisCmpts.append(basicThermo::splitThermoName(thermo.thermoName(), 5));
wordList validNames;
forAll(names, i)
{
wordList cmpts(basicThermo::splitThermoName(names[i], 2));
if (cmpts.size() != 2)
{
cmpts = basicThermo::splitThermoName(names[i], 7);
}
bool isValid = true;
for (label i = 1; i < cmpts.size() && isValid; ++ i)
{
isValid = isValid && cmpts[i] == thisCmpts[i];
}
if (isValid)
{
validNames.append(cmpts[0]);
}
}
FatalErrorInFunction
<< "Valid " << combustionModel::typeName << " types for this "
<< "thermodynamic model are:" << endl << validNames << endl;
List<wordList> validCmpts2, validCmpts7;
validCmpts2.append(wordList(2, word::null));
validCmpts2[0][0] = combustionModel::typeName;
validCmpts2[0][1] = "reactionThermo";
validCmpts7.append(wordList(7, word::null));
validCmpts7[0][0] = combustionModel::typeName;
validCmpts7[0][1] = "reactionThermo";
validCmpts7[0][2] = "transport";
validCmpts7[0][3] = "thermo";
validCmpts7[0][4] = "equationOfState";
validCmpts7[0][5] = "specie";
validCmpts7[0][6] = "energy";
forAll(names, i)
{
const wordList cmpts2(basicThermo::splitThermoName(names[i], 2));
const wordList cmpts7(basicThermo::splitThermoName(names[i], 7));
if (cmpts2.size() == 2)
{
validCmpts2.append(cmpts2);
}
if (cmpts7.size() == 7)
{
validCmpts7.append(cmpts7);
}
}
FatalErrorInFunction
<< "All " << validCmpts2[0][0] << '/' << validCmpts2[0][1]
<< " combinations are:" << endl << endl;
printTable(validCmpts2, FatalErrorInFunction);
FatalErrorInFunction << endl;
FatalErrorInFunction
<< "All " << validCmpts7[0][0] << '/' << validCmpts7[0][1]
<< "/thermoPhysics combinations are:" << endl << endl;
printTable(validCmpts7, FatalErrorInFunction);
FatalErrorInFunction << exit(FatalError);
}
return autoPtr<CombustionModel>
(
thermoCstrIter != cstrTable->end()
? thermoCstrIter()(combModelName, thermo, turb, combustionProperties)
: compCstrIter()(combModelName, thermo, turb, combustionProperties)
);
}
// ************************************************************************* //

92
src/combustionModels/combustionModel/makeCombustionTypes.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2017 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -30,61 +30,75 @@ License
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#define makeCombustionTypesThermo(CombModel, CombType, Thermo, Table) \
namespace Foam
{
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#define makeCombustion(Comp) \
\
typedef Foam::combustionModels::CombModel \
<Foam::combustionModels::CombType, Foam::Thermo> \
CombModel##CombType##Thermo; \
typedef CombustionModel<Comp> CombustionModel##Comp; \
\
defineTemplateTypeNameAndDebugWithName \
( \
CombModel##CombType##Thermo, \
#CombModel"<"#CombType","#Thermo">", \
CombustionModel##Comp, \
( \
word(CombustionModel##Comp::typeName_()) + "<" + Comp::typeName \
+ ">" \
).c_str(), \
0 \
); \
\
namespace Foam \
{ \
namespace combustionModels \
{ \
typedef CombModel<CombType, Thermo> CombModel##CombType##Thermo; \
addToRunTimeSelectionTable \
( \
Table, \
CombModel##CombType##Thermo, \
dictionary \
); \
} \
}
defineTemplateRunTimeSelectionTable \
( \
CombustionModel##Comp, \
dictionary \
);
#define makeCombustionTypes(CombModel, CombType, Table) \
#define makeCombustionTypesThermo(CombModel, Comp, Thermo) \
\
typedef Foam::combustionModels::CombModel \
<Foam::combustionModels::CombType> \
CombModel##CombType; \
typedef combustionModels::CombModel<Comp, Thermo> \
CombModel##Comp##Thermo; \
\
defineTemplateTypeNameAndDebugWithName \
( \
CombModel##CombType, \
#CombModel"<"#CombType">", \
CombModel##Comp##Thermo, \
( \
word(CombModel##Comp##Thermo::typeName_()) + "<" + Comp::typeName \
+ "," + Thermo::typeName() + ">" \
).c_str(), \
0 \
); \
\
namespace Foam \
{ \
namespace combustionModels \
{ \
typedef CombModel<CombType> CombModel##CombType; \
CombustionModel<Comp>:: \
add##dictionary##ConstructorToTable<CombModel##Comp##Thermo> \
add##CombModel##Comp##Thermo##dictionary##ConstructorTo##\
CombustionModel##Comp##Table_;
#define makeCombustionTypes(CombModel, Comp) \
\
addToRunTimeSelectionTable \
( \
Table, \
CombModel##CombType, \
dictionary \
); \
} \
}
typedef combustionModels::CombModel<Comp> CombModel##Comp; \
\
defineTemplateTypeNameAndDebugWithName \
( \
CombModel##Comp, \
( \
word(CombModel##Comp::typeName_()) + "<" + Comp::typeName + ">" \
).c_str(), \
0 \
); \
\
CombustionModel<Comp>:: \
add##dictionary##ConstructorToTable<CombModel##Comp> \
add##CombModel##Comp##dictionary##ConstructorTo##CombustionModel##Comp\
##Table_;
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

38
src/combustionModels/diffusion/diffusion.C
View File

@ -33,21 +33,21 @@ namespace combustionModels
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class CombThermoType, class ThermoType>
diffusion<CombThermoType, ThermoType>::diffusion
template<class ReactionThermo, class ThermoType>
diffusion<ReactionThermo, ThermoType>::diffusion
(
const word& modelType,
const fvMesh& mesh,
const word& combustionProperties,
const word& phaseName
ReactionThermo& thermo,
const compressibleTurbulenceModel& turb,
const word& combustionProperties
)
:
singleStepCombustion<CombThermoType, ThermoType>
singleStepCombustion<ReactionThermo, ThermoType>
(
modelType,
mesh,
combustionProperties,
phaseName
thermo,
turb,
combustionProperties
),
C_(readScalar(this->coeffs().lookup("C"))),
oxidantName_(this->coeffs().template lookupOrDefault<word>("oxidant", "O2"))
@ -56,15 +56,15 @@ diffusion<CombThermoType, ThermoType>::diffusion
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
template<class CombThermoType, class ThermoType>
diffusion<CombThermoType, ThermoType>::~diffusion()
template<class ReactionThermo, class ThermoType>
diffusion<ReactionThermo, ThermoType>::~diffusion()
{}
// * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * * //
template<class CombThermoType, class ThermoType>
void diffusion<CombThermoType, ThermoType>::correct()
template<class ReactionThermo, class ThermoType>
void diffusion<ReactionThermo, ThermoType>::correct()
{
this->wFuel_ == dimensionedScalar(dimMass/dimVolume/dimTime, Zero);
@ -75,12 +75,12 @@ void diffusion<CombThermoType, ThermoType>::correct()
const label fuelI = this->singleMixturePtr_->fuelIndex();
const volScalarField& YFuel =
this->thermoPtr_->composition().Y()[fuelI];
this->thermo().composition().Y()[fuelI];
if (this->thermoPtr_->composition().contains(oxidantName_))
if (this->thermo().composition().contains(oxidantName_))
{
const volScalarField& YO2 =
this->thermoPtr_->composition().Y(oxidantName_);
this->thermo().composition().Y(oxidantName_);
this->wFuel_ ==
C_*this->turbulence().muEff()
@ -91,10 +91,10 @@ void diffusion<CombThermoType, ThermoType>::correct()
}
template<class CombThermoType, class ThermoType>
bool diffusion<CombThermoType, ThermoType>::read()
template<class ReactionThermo, class ThermoType>
bool diffusion<ReactionThermo, ThermoType>::read()
{
if (singleStepCombustion<CombThermoType, ThermoType>::read())
if (singleStepCombustion<ReactionThermo, ThermoType>::read())
{
this->coeffs().lookup("C") >> C_ ;
this->coeffs().readIfPresent("oxidant", oxidantName_);

12
src/combustionModels/diffusion/diffusion.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2012-2016 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2012-2017 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -53,10 +53,10 @@ namespace combustionModels
Class diffusion Declaration
\*---------------------------------------------------------------------------*/
template<class CombThermoType, class ThermoType>
template<class ReactionThermo, class ThermoType>
class diffusion
:
public singleStepCombustion<CombThermoType, ThermoType>
public singleStepCombustion<ReactionThermo, ThermoType>
{
// Private data
@ -88,9 +88,9 @@ public:
diffusion
(
const word& modelType,
const fvMesh& mesh,
const word& combustionProperties,
const word& phaseName
ReactionThermo& thermo,
const compressibleTurbulenceModel& turb,
const word& combustionProperties
);

50
src/combustionModels/diffusion/diffusions.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2012-2016 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2012-2017 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -26,43 +26,42 @@ License
#include "makeCombustionTypes.H"
#include "thermoPhysicsTypes.H"
#include "psiThermoCombustion.H"
#include "rhoThermoCombustion.H"
#include "psiReactionThermo.H"
#include "rhoReactionThermo.H"
#include "diffusion.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// Combustion models based on sensibleEnthalpy
makeCombustionTypesThermo
(
diffusion,
psiThermoCombustion,
gasHThermoPhysics,
psiCombustionModel
psiReactionThermo,
gasHThermoPhysics
);
makeCombustionTypesThermo
(
diffusion,
psiThermoCombustion,
constGasHThermoPhysics,
psiCombustionModel
psiReactionThermo,
constGasHThermoPhysics
);
makeCombustionTypesThermo
(
diffusion,
rhoThermoCombustion,
gasHThermoPhysics,
rhoCombustionModel
rhoReactionThermo,
gasHThermoPhysics
);
makeCombustionTypesThermo
(
diffusion,
rhoThermoCombustion,
constGasHThermoPhysics,
rhoCombustionModel
rhoReactionThermo,
constGasHThermoPhysics
);
@ -71,34 +70,31 @@ makeCombustionTypesThermo
makeCombustionTypesThermo
(
diffusion,
psiThermoCombustion,
gasEThermoPhysics,
psiCombustionModel
psiReactionThermo,
gasEThermoPhysics
);
makeCombustionTypesThermo
(
diffusion,
psiThermoCombustion,
constGasEThermoPhysics,
psiCombustionModel
psiReactionThermo,
constGasEThermoPhysics
);
makeCombustionTypesThermo
(
diffusion,
rhoThermoCombustion,
gasEThermoPhysics,
rhoCombustionModel
rhoReactionThermo,
gasEThermoPhysics
);
makeCombustionTypesThermo
(
diffusion,
rhoThermoCombustion,
constGasEThermoPhysics,
rhoCombustionModel
rhoReactionThermo,
constGasEThermoPhysics
);
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

40
src/combustionModels/infinitelyFastChemistry/infinitelyFastChemistry.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2017 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -32,21 +32,21 @@ namespace combustionModels
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class CombThermoType, class ThermoType>
infinitelyFastChemistry<CombThermoType, ThermoType>::infinitelyFastChemistry
template<class ReactionThermo, class ThermoType>
infinitelyFastChemistry<ReactionThermo, ThermoType>::infinitelyFastChemistry
(
const word& modelType,
const fvMesh& mesh,
const word& combustionProperties,
const word& phaseName
ReactionThermo& thermo,
const compressibleTurbulenceModel& turb,
const word& combustionProperties
)
:
singleStepCombustion<CombThermoType, ThermoType>
singleStepCombustion<ReactionThermo, ThermoType>
(
modelType,
mesh,
combustionProperties,
phaseName
thermo,
turb,
combustionProperties
),
C_(readScalar(this->coeffs().lookup("C")))
{}
@ -54,15 +54,15 @@ infinitelyFastChemistry<CombThermoType, ThermoType>::infinitelyFastChemistry
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
template<class CombThermoType, class ThermoType>
infinitelyFastChemistry<CombThermoType, ThermoType>::~infinitelyFastChemistry()
template<class ReactionThermo, class ThermoType>
infinitelyFastChemistry<ReactionThermo, ThermoType>::~infinitelyFastChemistry()
{}
// * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * * //
template<class CombThermoType, class ThermoType>
void infinitelyFastChemistry<CombThermoType, ThermoType>::correct()
template<class ReactionThermo, class ThermoType>
void infinitelyFastChemistry<ReactionThermo, ThermoType>::correct()
{
this->wFuel_ == dimensionedScalar(dimMass/dimVolume/dimTime, Zero);
@ -73,13 +73,13 @@ void infinitelyFastChemistry<CombThermoType, ThermoType>::correct()
const label fuelI = this->singleMixturePtr_->fuelIndex();
const volScalarField& YFuel =
this->thermoPtr_->composition().Y()[fuelI];
this->thermo().composition().Y()[fuelI];
const dimensionedScalar s = this->singleMixturePtr_->s();
if (this->thermoPtr_->composition().contains("O2"))
if (this->thermo().composition().contains("O2"))
{
const volScalarField& YO2 = this->thermoPtr_->composition().Y("O2");
const volScalarField& YO2 = this->thermo().composition().Y("O2");
this->wFuel_ ==
this->rho()/(this->mesh().time().deltaT()*C_)
@ -89,10 +89,10 @@ void infinitelyFastChemistry<CombThermoType, ThermoType>::correct()
}
template<class CombThermoType, class ThermoType>
bool infinitelyFastChemistry<CombThermoType, ThermoType>::read()
template<class ReactionThermo, class ThermoType>
bool infinitelyFastChemistry<ReactionThermo, ThermoType>::read()
{
if (singleStepCombustion<CombThermoType, ThermoType>::read())
if (singleStepCombustion<ReactionThermo, ThermoType>::read())
{
this->coeffs().lookup("C") >> C_ ;
return true;

12
src/combustionModels/infinitelyFastChemistry/infinitelyFastChemistry.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2017 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -53,10 +53,10 @@ namespace combustionModels
Class infinitelyFastChemistry Declaration
\*---------------------------------------------------------------------------*/
template<class CombThermoType, class ThermoType>
template<class ReactionThermo, class ThermoType>
class infinitelyFastChemistry
:
public singleStepCombustion<CombThermoType, ThermoType>
public singleStepCombustion<ReactionThermo, ThermoType>
{
// Private data
@ -85,9 +85,9 @@ public:
infinitelyFastChemistry
(
const word& modelType,
const fvMesh& mesh,
const word& combustionProperties,
const word& phaseName
ReactionThermo& thermo,
const compressibleTurbulenceModel& turb,
const word& combustionProperties
);

50
src/combustionModels/infinitelyFastChemistry/infinitelyFastChemistrys.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2017 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -26,44 +26,43 @@ License
#include "makeCombustionTypes.H"
#include "thermoPhysicsTypes.H"
#include "psiThermoCombustion.H"
#include "rhoThermoCombustion.H"
#include "psiReactionThermo.H"
#include "rhoReactionThermo.H"
#include "infinitelyFastChemistry.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// Combustion models based on sensibleEnthalpy
makeCombustionTypesThermo
(
infinitelyFastChemistry,
psiThermoCombustion,
gasHThermoPhysics,
psiCombustionModel
psiReactionThermo,
gasHThermoPhysics
);
makeCombustionTypesThermo
(
infinitelyFastChemistry,
psiThermoCombustion,
constGasHThermoPhysics,
psiCombustionModel
psiReactionThermo,
constGasHThermoPhysics
);
makeCombustionTypesThermo
(
infinitelyFastChemistry,
rhoThermoCombustion,
gasHThermoPhysics,
rhoCombustionModel
rhoReactionThermo,
gasHThermoPhysics
);
makeCombustionTypesThermo
(
infinitelyFastChemistry,
rhoThermoCombustion,
constGasHThermoPhysics,
rhoCombustionModel
rhoReactionThermo,
constGasHThermoPhysics
);
// Combustion models based on sensibleInternalEnergy
@ -71,34 +70,31 @@ makeCombustionTypesThermo
makeCombustionTypesThermo
(
infinitelyFastChemistry,
psiThermoCombustion,
gasEThermoPhysics,
psiCombustionModel
psiReactionThermo,
gasEThermoPhysics
);
makeCombustionTypesThermo
(
infinitelyFastChemistry,
psiThermoCombustion,
constGasEThermoPhysics,
psiCombustionModel
psiReactionThermo,
constGasEThermoPhysics
);
makeCombustionTypesThermo
(
infinitelyFastChemistry,
rhoThermoCombustion,
gasEThermoPhysics,
rhoCombustionModel
rhoReactionThermo,
gasEThermoPhysics
);
makeCombustionTypesThermo
(
infinitelyFastChemistry,
rhoThermoCombustion,
constGasEThermoPhysics,
rhoCombustionModel
rhoReactionThermo,
constGasEThermoPhysics
);
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

46
src/combustionModels/laminar/laminar.C
View File

@ -29,16 +29,22 @@ License
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class Type>
Foam::combustionModels::laminar<Type>::laminar
template<class ReactionThermo>
Foam::combustionModels::laminar<ReactionThermo>::laminar
(
const word& modelType,
const fvMesh& mesh,
const word& combustionProperties,
const word& phaseName
ReactionThermo& thermo,
const compressibleTurbulenceModel& turb,
const word& combustionProperties
)
:
Type(modelType, mesh, combustionProperties, phaseName),
ChemistryCombustion<ReactionThermo>
(
modelType,
thermo,
turb,
combustionProperties
),
integrateReactionRate_
(
this->coeffs().lookupOrDefault("integrateReactionRate", true)
@ -57,23 +63,23 @@ Foam::combustionModels::laminar<Type>::laminar
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
template<class Type>
Foam::combustionModels::laminar<Type>::~laminar()
template<class ReactionThermo>
Foam::combustionModels::laminar<ReactionThermo>::~laminar()
{}
// * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * * //
template<class Type>
template<class ReactionThermo>
Foam::tmp<Foam::volScalarField>
Foam::combustionModels::laminar<Type>::tc() const
Foam::combustionModels::laminar<ReactionThermo>::tc() const
{
return this->chemistryPtr_->tc();
}
template<class Type>
void Foam::combustionModels::laminar<Type>::correct()
template<class ReactionThermo>
void Foam::combustionModels::laminar<ReactionThermo>::correct()
{
if (this->active())
{
@ -114,9 +120,9 @@ void Foam::combustionModels::laminar<Type>::correct()
}
template<class Type>
template<class ReactionThermo>
Foam::tmp<Foam::fvScalarMatrix>
Foam::combustionModels::laminar<Type>::R(volScalarField& Y) const
Foam::combustionModels::laminar<ReactionThermo>::R(volScalarField& Y) const
{
tmp<fvScalarMatrix> tSu(new fvScalarMatrix(Y, dimMass/dimTime));
@ -134,9 +140,9 @@ Foam::combustionModels::laminar<Type>::R(volScalarField& Y) const
}
template<class Type>
template<class ReactionThermo>
Foam::tmp<Foam::volScalarField>
Foam::combustionModels::laminar<Type>::Qdot() const
Foam::combustionModels::laminar<ReactionThermo>::Qdot() const
{
tmp<volScalarField> tQdot
(
@ -144,7 +150,7 @@ Foam::combustionModels::laminar<Type>::Qdot() const
(
IOobject
(
IOobject::groupName(typeName + ":Qdot", this->phaseName_),
this->thermo().phasePropertyName(typeName + ":Qdot"),
this->mesh().time().timeName(),
this->mesh(),
IOobject::NO_READ,
@ -165,10 +171,10 @@ Foam::combustionModels::laminar<Type>::Qdot() const
}
template<class Type>
bool Foam::combustionModels::laminar<Type>::read()
template<class ReactionThermo>
bool Foam::combustionModels::laminar<ReactionThermo>::read()
{
if (Type::read())
if (ChemistryCombustion<ReactionThermo>::read())
{
integrateReactionRate_ =
this->coeffs().lookupOrDefault("integrateReactionRate", true);

14
src/combustionModels/laminar/laminar.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2013-2016 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2013-2017 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -38,6 +38,8 @@ SourceFiles
#ifndef combustionModels_laminar_H
#define combustionModels_laminar_H
#include "ChemistryCombustion.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
@ -49,10 +51,10 @@ namespace combustionModels
Class laminar Declaration
\*---------------------------------------------------------------------------*/
template<class Type>
template<class ReactionThermo>
class laminar
:
public Type
public ChemistryCombustion<ReactionThermo>
{
// Private data
@ -90,9 +92,9 @@ public:
laminar
(
const word& modelType,
const fvMesh& mesh,
const word& combustionProperties,
const word& phaseName
ReactionThermo& thermo,
const compressibleTurbulenceModel& turb,
const word& combustionProperties
);

14
src/combustionModels/laminar/laminars.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2013-2015 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2013-2017 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -25,14 +25,18 @@ License
#include "makeCombustionTypes.H"
#include "psiChemistryCombustion.H"
#include "rhoChemistryCombustion.H"
#include "psiReactionThermo.H"
#include "rhoReactionThermo.H"
#include "laminar.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
makeCombustionTypes(laminar, psiChemistryCombustion, psiCombustionModel);
makeCombustionTypes(laminar, rhoChemistryCombustion, rhoCombustionModel);
namespace Foam
{
makeCombustionTypes(laminar, psiReactionThermo);
makeCombustionTypes(laminar, rhoReactionThermo);
}
// ************************************************************************* //

36
src/combustionModels/noCombustion/noCombustion.C
View File

@ -28,36 +28,36 @@ License
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class CombThermoType>
Foam::combustionModels::noCombustion<CombThermoType>::noCombustion
template<class ReactionThermo>
Foam::combustionModels::noCombustion<ReactionThermo>::noCombustion
(
const word& modelType,
const fvMesh& mesh,
const word& combustionProperties,
const word& phaseName
ReactionThermo& thermo,
const compressibleTurbulenceModel& turb,
const word& combustionProperties
)
:
CombThermoType(modelType, mesh, phaseName)
ThermoCombustion<ReactionThermo>(modelType, thermo, turb)
{}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
template<class CombThermoType>
Foam::combustionModels::noCombustion<CombThermoType>::~noCombustion()
template<class ReactionThermo>
Foam::combustionModels::noCombustion<ReactionThermo>::~noCombustion()
{}
// * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * * //
template<class CombThermoType>
void Foam::combustionModels::noCombustion<CombThermoType>::correct()
template<class ReactionThermo>
void Foam::combustionModels::noCombustion<ReactionThermo>::correct()
{}
template<class CombThermoType>
template<class ReactionThermo>
Foam::tmp<Foam::fvScalarMatrix>
Foam::combustionModels::noCombustion<CombThermoType>::R
Foam::combustionModels::noCombustion<ReactionThermo>::R
(
volScalarField& Y
) const
@ -71,15 +71,15 @@ Foam::combustionModels::noCombustion<CombThermoType>::R
}
template<class CombThermoType>
template<class ReactionThermo>
Foam::tmp<Foam::volScalarField>
Foam::combustionModels::noCombustion<CombThermoType>::Qdot() const
Foam::combustionModels::noCombustion<ReactionThermo>::Qdot() const
{
return tmp<volScalarField>::New
(
IOobject
(
IOobject::groupName(typeName + ":Qdot", this->phaseName_),
this->thermo().phasePropertyName(typeName + ":Qdot"),
this->mesh().time().timeName(),
this->mesh(),
IOobject::NO_READ,
@ -92,10 +92,10 @@ Foam::combustionModels::noCombustion<CombThermoType>::Qdot() const
}
template<class CombThermoType>
bool Foam::combustionModels::noCombustion<CombThermoType>::read()
template<class ReactionThermo>
bool Foam::combustionModels::noCombustion<ReactionThermo>::read()
{
if (CombThermoType::read())
if (ThermoCombustion<ReactionThermo>::read())
{
return true;
}

16
src/combustionModels/noCombustion/noCombustion.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2017 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -38,6 +38,8 @@ SourceFiles
#ifndef noCombustion_H
#define noCombustion_H
#include "ThermoCombustion.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
@ -49,10 +51,10 @@ namespace combustionModels
Class noCombustion Declaration
\*---------------------------------------------------------------------------*/
template<class CombThermoType>
template<class ReactionThermo>
class noCombustion
:
public CombThermoType
public ThermoCombustion<ReactionThermo>
{
//- Disallow copy construct
@ -65,7 +67,7 @@ class noCombustion
public:
//- Runtime type information
TypeName("noCombustion");
TypeName("none");
// Constructors
@ -74,9 +76,9 @@ public:
noCombustion
(
const word& modelType,
const fvMesh& mesh,
const word& combustionProperties,
const word& phaseName
ReactionThermo& thermo,
const compressibleTurbulenceModel& turb,
const word& combustionProperties
);

26
src/combustionModels/noCombustion/noCombustions.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2012-2015 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2012-2017 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -25,28 +25,18 @@ License
#include "makeCombustionTypes.H"
#include "psiCombustionModel.H"
#include "rhoCombustionModel.H"
#include "psiThermoCombustion.H"
#include "rhoThermoCombustion.H"
#include "psiReactionThermo.H"
#include "rhoReactionThermo.H"
#include "noCombustion.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
makeCombustionTypes
(
noCombustion,
psiThermoCombustion,
psiCombustionModel
);
namespace Foam
{
makeCombustionTypes
(
noCombustion,
rhoThermoCombustion,
rhoCombustionModel
);
makeCombustionTypes(noCombustion, psiReactionThermo);
makeCombustionTypes(noCombustion, rhoReactionThermo);
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

111
src/combustionModels/psiCombustionModel/psiChemistryCombustion/psiChemistryCombustion.H
View File

@ -1,111 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2012-2016 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::psiChemistryCombustion
Description
Compressibility-based chemistry model wrapper for combustion models
SourceFiles
psiChemistryCombustion.C
\*---------------------------------------------------------------------------*/
#ifndef psiChemistryCombustion_H
#define psiChemistryCombustion_H
#include "autoPtr.H"
#include "psiCombustionModel.H"
#include "psiChemistryModel.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
namespace combustionModels
{
/*---------------------------------------------------------------------------*\
class psiChemistryCombustion Declaration
\*---------------------------------------------------------------------------*/
class psiChemistryCombustion
:
public psiCombustionModel
{
// Private Member Functions
//- Construct as copy (not implemented)
psiChemistryCombustion(const psiChemistryCombustion&);
//- Disallow default bitwise assignment
void operator=(const psiChemistryCombustion&);
protected:
// Protected data
//- Pointer to chemistry model
autoPtr<psiChemistryModel> chemistryPtr_;
public:
// Constructors
//- Construct from components and thermo
psiChemistryCombustion
(
const word& modelType,
const fvMesh& mesh,
const word& combustionProperties,
const word& phaseName
);
//- Destructor
virtual ~psiChemistryCombustion();
// Member Functions
//- Return access to the thermo package
virtual psiReactionThermo& thermo();
//- Return const access to the thermo package
virtual const psiReactionThermo& thermo() const;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace combustionModels
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

74
src/combustionModels/psiCombustionModel/psiCombustionModel/psiCombustionModel.C
View File

@ -1,74 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2016 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 "psiCombustionModel.H"
/* * * * * * * * * * * * * * * private static data * * * * * * * * * * * * * */
namespace Foam
{
namespace combustionModels
{
defineTypeNameAndDebug(psiCombustionModel, 0);
defineRunTimeSelectionTable(psiCombustionModel, dictionary);
}
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::combustionModels::psiCombustionModel::psiCombustionModel
(
const word& modelType,
const fvMesh& mesh,
const word& combustionProperties,
const word& phaseName
)
:
combustionModel(modelType, mesh, combustionProperties, phaseName)
{}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::combustionModels::psiCombustionModel::~psiCombustionModel()
{}
// * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * * //
bool Foam::combustionModels::psiCombustionModel::read()
{
if (combustionModel::read())
{
return true;
}
else
{
return false;
}
}
// ************************************************************************* //

77
src/combustionModels/psiCombustionModel/psiCombustionModel/psiCombustionModelNew.C
View File

@ -1,77 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2016 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 "psiCombustionModel.H"
// * * * * * * * * * * * * * * * * Selectors * * * * * * * * * * * * * * * * //
Foam::autoPtr<Foam::combustionModels::psiCombustionModel>
Foam::combustionModels::psiCombustionModel::New
(
const fvMesh& mesh,
const word& combustionProperties,
const word& phaseName
)
{
const word modelType
(
IOdictionary
(
IOobject
(
IOobject::groupName(combustionProperties, phaseName),
mesh.time().constant(),
mesh,
IOobject::MUST_READ,
IOobject::NO_WRITE,
false
)
).lookup("combustionModel")
);
Info<< "Selecting combustion model " << modelType << endl;
auto cstrIter = dictionaryConstructorTablePtr_->cfind(modelType);
if (!cstrIter.found())
{
FatalErrorInFunction
<< "Unknown psiCombustionModel type "
<< modelType << nl << nl
<< "Valid combustionModel types :" << nl
<< dictionaryConstructorTablePtr_->sortedToc()
<< exit(FatalError);
}
const word className = modelType.substr(0, modelType.find('<'));
return autoPtr<psiCombustionModel>
(
cstrIter()(className, mesh, combustionProperties, phaseName)
);
}
// ************************************************************************* //

64
src/combustionModels/psiCombustionModel/psiThermoCombustion/psiThermoCombustion.C
View File

@ -1,64 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2012-2016 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 "psiThermoCombustion.H"
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::combustionModels::psiThermoCombustion::psiThermoCombustion
(
const word& modelType,
const fvMesh& mesh,
const word& phaseName
)
:
psiCombustionModel(modelType, mesh, combustionPropertiesName, phaseName),
thermoPtr_(psiReactionThermo::New(mesh, phaseName))
{}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::combustionModels::psiThermoCombustion::~psiThermoCombustion()
{}
// * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * * //
Foam::psiReactionThermo&
Foam::combustionModels::psiThermoCombustion::thermo()
{
return *thermoPtr_;
}
const Foam::psiReactionThermo&
Foam::combustionModels::psiThermoCombustion::thermo() const
{
return *thermoPtr_;
}
// ************************************************************************* //

111
src/combustionModels/rhoCombustionModel/rhoChemistryCombustion/rhoChemistryCombustion.H
View File

@ -1,111 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2012-2016 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::rhoChemistryCombustion
Description
Density-based chemistry model wrapper for combustion models
SourceFiles
rhoChemistryCombustion.C
\*---------------------------------------------------------------------------*/
#ifndef rhoChemistryCombustion_H
#define rhoChemistryCombustion_H
#include "autoPtr.H"
#include "rhoCombustionModel.H"
#include "rhoChemistryModel.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
namespace combustionModels
{
/*---------------------------------------------------------------------------*\
class rhoChemistryCombustion Declaration
\*---------------------------------------------------------------------------*/
class rhoChemistryCombustion
:
public rhoCombustionModel
{
// Private Member Functions
//- Construct as copy (not implemented)
rhoChemistryCombustion(const rhoChemistryCombustion&);
//- Disallow default bitwise assignment
void operator=(const rhoChemistryCombustion&);
protected:
// Protected data
//- Pointer to chemistry model
autoPtr<rhoChemistryModel> chemistryPtr_;
public:
// Constructors
//- Construct from components and thermo
rhoChemistryCombustion
(
const word& modelType,
const fvMesh& mesh,
const word& combustionProperties,
const word& phaseName
);
//- Destructor
virtual ~rhoChemistryCombustion();
// Member Functions
//- Return access to the thermo package
virtual rhoReactionThermo& thermo();
//- Return const access to the thermo package
virtual const rhoReactionThermo& thermo() const;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace combustionModels
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

153
src/combustionModels/rhoCombustionModel/rhoCombustionModel/rhoCombustionModel.H
View File

@ -1,153 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2016 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::rhoCombustionModel
Description
Combustion models for rho-based thermodynamics
SourceFiles
rhoCombustionModelI.H
rhoCombustionModel.C
rhoCombustionModelNew.C
\*---------------------------------------------------------------------------*/
#ifndef rhoCombustionModel_H
#define rhoCombustionModel_H
#include "combustionModel.H"
#include "autoPtr.H"
#include "runTimeSelectionTables.H"
#include "rhoReactionThermo.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
namespace combustionModels
{
/*---------------------------------------------------------------------------*\
class rhoCombustionModel Declaration
\*---------------------------------------------------------------------------*/
class rhoCombustionModel
:
public combustionModel
{
// Private Member Functions
//- Construct as copy (not implemented)
rhoCombustionModel(const rhoCombustionModel&);
//- Disallow default bitwise assignment
void operator=(const rhoCombustionModel&);
public:
typedef rhoReactionThermo ReactionThermo;
//- Runtime type information
TypeName("rhoCombustionModel");
//- Declare run-time constructor selection tables
declareRunTimeSelectionTable
(
autoPtr,
rhoCombustionModel,
dictionary,
(
const word& modelType,
const fvMesh& mesh,
const word& combustionProperties,
const word& phaseName
),
(modelType, mesh, combustionProperties, phaseName)
);
// Constructors
//- Construct from components
rhoCombustionModel
(
const word& modelType,
const fvMesh& mesh,
const word& combustionProperties,
const word& phaseName
);
//- Selector
static autoPtr<rhoCombustionModel> New
(
const fvMesh& mesh,
const word& combustionProperties=combustionPropertiesName,
const word& phaseName=word::null
);
//- Destructor
virtual ~rhoCombustionModel();
// Member Functions
// Access functions
//- Access combustion dict
inline const dictionary& coeff() const;
//- Return access to the thermo package
virtual rhoReactionThermo& thermo() = 0;
//- Return const access to the thermo package
virtual const rhoReactionThermo& thermo() const = 0;
// IO
//- Update properties from given dictionary
virtual bool read();
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace combustionModels
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

77
src/combustionModels/rhoCombustionModel/rhoCombustionModel/rhoCombustionModelNew.C
View File

@ -1,77 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2016 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 "rhoCombustionModel.H"
// * * * * * * * * * * * * * * * * Selectors * * * * * * * * * * * * * * * * //
Foam::autoPtr<Foam::combustionModels::rhoCombustionModel>
Foam::combustionModels::rhoCombustionModel::New
(
const fvMesh& mesh,
const word& combustionProperties,
const word& phaseName
)
{
const word modelType
(
IOdictionary
(
IOobject
(
IOobject::groupName(combustionProperties, phaseName),
mesh.time().constant(),
mesh,
IOobject::MUST_READ,
IOobject::NO_WRITE,
false
)
).lookup("combustionModel")
);
Info<< "Selecting combustion model " << modelType << endl;
auto cstrIter = dictionaryConstructorTablePtr_->cfind(modelType);
if (!cstrIter.found())
{
FatalErrorInFunction
<< "Unknown rhoCombustionModel type "
<< modelType << nl << nl
<< "Valid combustionModel types :" << nl
<< dictionaryConstructorTablePtr_->sortedToc()
<< exit(FatalError);
}
const word className = modelType.substr(0, modelType.find('<'));
return autoPtr<rhoCombustionModel>
(
cstrIter()(className, mesh, combustionProperties, phaseName)
);
}
// ************************************************************************* //

64
src/combustionModels/rhoCombustionModel/rhoThermoCombustion/rhoThermoCombustion.C
View File

@ -1,64 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2012-2016 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 "rhoThermoCombustion.H"
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::combustionModels::rhoThermoCombustion::rhoThermoCombustion
(
const word& modelType,
const fvMesh& mesh,
const word& phaseName
)
:
rhoCombustionModel(modelType, mesh, combustionPropertiesName, phaseName),
thermoPtr_(rhoReactionThermo::New(mesh, phaseName))
{}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::combustionModels::rhoThermoCombustion::~rhoThermoCombustion()
{}
// * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * * //
Foam::rhoReactionThermo&
Foam::combustionModels::rhoThermoCombustion::thermo()
{
return *thermoPtr_;
}
const Foam::rhoReactionThermo&
Foam::combustionModels::rhoThermoCombustion::thermo() const
{
return *thermoPtr_;
}
// ************************************************************************* //

38
src/combustionModels/singleStepCombustion/singleStepCombustion.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2017 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -33,22 +33,22 @@ namespace combustionModels
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class CombThermoType, class ThermoType>
singleStepCombustion<CombThermoType, ThermoType>::singleStepCombustion
template<class ReactionThermo, class ThermoType>
singleStepCombustion<ReactionThermo, ThermoType>::singleStepCombustion
(
const word& modelType,
const fvMesh& mesh,
const word& combustionProperties,
const word& phaseName
ReactionThermo& thermo,
const compressibleTurbulenceModel& turb,
const word& combustionProperties
)
:
CombThermoType(modelType, mesh, phaseName),
ThermoCombustion<ReactionThermo>(modelType, thermo, turb),
singleMixturePtr_(nullptr),
wFuel_
(
IOobject
(
IOobject::groupName("wFuel", phaseName),
this->thermo().phasePropertyName("wFuel"),
this->mesh().time().timeName(),
this->mesh(),
IOobject::NO_READ,
@ -89,21 +89,21 @@ singleStepCombustion<CombThermoType, ThermoType>::singleStepCombustion
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
template<class CombThermoType, class ThermoType>
singleStepCombustion<CombThermoType, ThermoType>::~singleStepCombustion()
template<class ReactionThermo, class ThermoType>
singleStepCombustion<ReactionThermo, ThermoType>::~singleStepCombustion()
{}
// * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * * //
template<class CombThermoType, class ThermoType>
tmp<fvScalarMatrix> singleStepCombustion<CombThermoType, ThermoType>::R
template<class ReactionThermo, class ThermoType>
tmp<fvScalarMatrix> singleStepCombustion<ReactionThermo, ThermoType>::R
(
volScalarField& Y
) const
{
const label specieI =
this->thermoPtr_->composition().species()[Y.member()];
this->thermo().composition().species()[Y.member()];
volScalarField wSpecie
(
@ -125,22 +125,22 @@ tmp<fvScalarMatrix> singleStepCombustion<CombThermoType, ThermoType>::R
}
template<class CombThermoType, class ThermoType>
template<class ReactionThermo, class ThermoType>
tmp<volScalarField>
singleStepCombustion<CombThermoType, ThermoType>::Qdot() const
singleStepCombustion<ReactionThermo, ThermoType>::Qdot() const
{
const label fuelI = singleMixturePtr_->fuelIndex();
volScalarField& YFuel =
const_cast<volScalarField&>(this->thermoPtr_->composition().Y(fuelI));
const_cast<volScalarField&>(this->thermo().composition().Y(fuelI));
return -singleMixturePtr_->qFuel()*(R(YFuel) & YFuel);
}
template<class CombThermoType, class ThermoType>
bool singleStepCombustion<CombThermoType, ThermoType>::read()
template<class ReactionThermo, class ThermoType>
bool singleStepCombustion<ReactionThermo, ThermoType>::read()
{
if (CombThermoType::read())
if (ThermoCombustion<ReactionThermo>::read())
{
return true;
}

13
src/combustionModels/singleStepCombustion/singleStepCombustion.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2017 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -39,6 +39,7 @@ SourceFiles
#define singleStepCombustion_H
#include "singleStepReactingMixture.H"
#include "ThermoCombustion.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -51,10 +52,10 @@ namespace combustionModels
Class singleStepCombustion Declaration
\*---------------------------------------------------------------------------*/
template<class CombThermoType, class ThermoType>
template<class ReactionThermo, class ThermoType>
class singleStepCombustion
:
public CombThermoType
public ThermoCombustion<ReactionThermo>
{
// Private Member Functions
@ -87,9 +88,9 @@ public:
singleStepCombustion
(
const word& modelType,
const fvMesh& mesh,
const word& combustionProperties,
const word& phaseName
ReactionThermo& thermo,
const compressibleTurbulenceModel& turb,
const word& combustionProperties
);

72
src/combustionModels/zoneCombustion/zoneCombustion.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2016 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2016-2017 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -27,9 +27,9 @@ License
// * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * * //
template<class Type>
template<class ReactionThermo>
Foam::tmp<Foam::fvScalarMatrix>
Foam::combustionModels::zoneCombustion<Type>::filter
Foam::combustionModels::zoneCombustion<ReactionThermo>::filter
(
const tmp<fvScalarMatrix>& tR
) const
@ -72,9 +72,9 @@ Foam::combustionModels::zoneCombustion<Type>::filter
}
template<class Type>
template<class ReactionThermo>
Foam::tmp<Foam::volScalarField>
Foam::combustionModels::zoneCombustion<Type>::filter
Foam::combustionModels::zoneCombustion<ReactionThermo>::filter
(
const tmp<volScalarField>& tS
) const
@ -100,23 +100,29 @@ Foam::combustionModels::zoneCombustion<Type>::filter
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class Type>
Foam::combustionModels::zoneCombustion<Type>::zoneCombustion
template<class ReactionThermo>
Foam::combustionModels::zoneCombustion<ReactionThermo>::zoneCombustion
(
const word& modelType,
const fvMesh& mesh,
const word& combustionProperties,
const word& phaseName
ReactionThermo& thermo,
const compressibleTurbulenceModel& turb,
const word& combustionProperties
)
:
Type(modelType, mesh, combustionProperties, phaseName),
CombustionModel<ReactionThermo>
(
modelType,
thermo,
turb,
combustionProperties
),
combustionModelPtr_
(
Type::New
CombustionModel<ReactionThermo>::New
(
mesh,
"zoneCombustionProperties",
phaseName
thermo,
turb,
"zoneCombustionProperties"
)
),
zoneNames_(this->coeffs().lookup("zones"))
@ -125,56 +131,58 @@ Foam::combustionModels::zoneCombustion<Type>::zoneCombustion
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
template<class Type>
Foam::combustionModels::zoneCombustion<Type>::~zoneCombustion()
template<class ReactionThermo>
Foam::combustionModels::zoneCombustion<ReactionThermo>::~zoneCombustion()
{}
// * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * * //
template<class Type>
typename Type::ReactionThermo&
Foam::combustionModels::zoneCombustion<Type>::thermo()
template<class ReactionThermo>
ReactionThermo& Foam::combustionModels::zoneCombustion<ReactionThermo>::thermo()
{
return combustionModelPtr_->thermo();
}
template<class Type>
const typename Type::ReactionThermo&
Foam::combustionModels::zoneCombustion<Type>::thermo() const
template<class ReactionThermo>
const ReactionThermo&
Foam::combustionModels::zoneCombustion<ReactionThermo>::thermo() const
{
return combustionModelPtr_->thermo();
}
template<class Type>
void Foam::combustionModels::zoneCombustion<Type>::correct()
template<class ReactionThermo>
void Foam::combustionModels::zoneCombustion<ReactionThermo>::correct()
{
combustionModelPtr_->correct();
}
template<class Type>
template<class ReactionThermo>
Foam::tmp<Foam::fvScalarMatrix>
Foam::combustionModels::zoneCombustion<Type>::R(volScalarField& Y) const
Foam::combustionModels::zoneCombustion<ReactionThermo>::R
(
volScalarField& Y
) const
{
return filter(combustionModelPtr_->R(Y));
}
template<class Type>
template<class ReactionThermo>
Foam::tmp<Foam::volScalarField>
Foam::combustionModels::zoneCombustion<Type>::Qdot() const
Foam::combustionModels::zoneCombustion<ReactionThermo>::Qdot() const
{
return filter(combustionModelPtr_->Qdot());
}
template<class Type>
bool Foam::combustionModels::zoneCombustion<Type>::read()
template<class ReactionThermo>
bool Foam::combustionModels::zoneCombustion<ReactionThermo>::read()
{
if (Type::read())
if (CombustionModel<ReactionThermo>::read())
{
combustionModelPtr_->read();
return true;

20
src/combustionModels/zoneCombustion/zoneCombustion.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2016 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2016-2017 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -38,6 +38,8 @@ SourceFiles
#ifndef zoneCombustion_H
#define zoneCombustion_H
#include "CombustionModel.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
@ -49,15 +51,15 @@ namespace combustionModels
Class zoneCombustion Declaration
\*---------------------------------------------------------------------------*/
template<class Type>
template<class ReactionThermo>
class zoneCombustion
:
public Type
public CombustionModel<ReactionThermo>
{
// Private data
//- The combustion model to be zone-filtered
autoPtr<Type> combustionModelPtr_;
autoPtr<CombustionModel<ReactionThermo>> combustionModelPtr_;
//- List of zone names in which the reactions are active
wordList zoneNames_;
@ -90,9 +92,9 @@ public:
zoneCombustion
(
const word& modelType,
const fvMesh& mesh,
const word& combustionProperties,
const word& phaseName
ReactionThermo& thermo,
const compressibleTurbulenceModel& turb,
const word& combustionProperties
);
@ -103,10 +105,10 @@ public:
// Member Functions
//- Return access to the thermo package
virtual typename Type::ReactionThermo& thermo();
virtual ReactionThermo& thermo();
//- Return const access to the thermo package
virtual const typename Type::ReactionThermo& thermo() const;
virtual const ReactionThermo& thermo() const;
//- Correct combustion rate
virtual void correct();

15
src/combustionModels/zoneCombustion/zoneCombustions.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2016 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2016-2017 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -25,13 +25,18 @@ License
#include "makeCombustionTypes.H"
#include "psiCombustionModel.H"
#include "rhoCombustionModel.H"
#include "psiReactionThermo.H"
#include "rhoReactionThermo.H"
#include "zoneCombustion.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
makeCombustionTypes(zoneCombustion, psiCombustionModel, psiCombustionModel);
makeCombustionTypes(zoneCombustion, rhoCombustionModel, rhoCombustionModel);
namespace Foam
{
makeCombustionTypes(zoneCombustion, psiReactionThermo);
makeCombustionTypes(zoneCombustion, rhoReactionThermo);
}
// ************************************************************************* //

11
src/regionModels/pyrolysisModels/noPyrolysis/noPyrolysis.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2017 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -47,9 +47,14 @@ addToRunTimeSelectionTable(pyrolysisModel, noPyrolysis, dictionary);
void noPyrolysis::constructThermoChemistry()
{
solidThermo_.reset
(
solidReactionThermo::New(regionMesh()).ptr()
);
solidChemistry_.reset
(
basicSolidChemistryModel::New(regionMesh()).ptr()
basicSolidChemistryModel::New(solidThermo_()).ptr()
);
radiation_.reset(radiation::radiationModel::New
@ -97,6 +102,7 @@ noPyrolysis::noPyrolysis
)
:
pyrolysisModel(mesh, regionType),
solidThermo_(nullptr),
solidChemistry_(nullptr),
radiation_(nullptr)
{
@ -116,6 +122,7 @@ noPyrolysis::noPyrolysis
)
:
pyrolysisModel(mesh, regionType),
solidThermo_(nullptr),
solidChemistry_(nullptr),
radiation_(nullptr)
{

12
src/regionModels/pyrolysisModels/noPyrolysis/noPyrolysis.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2017 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -50,7 +50,7 @@ namespace pyrolysisModels
{
/*---------------------------------------------------------------------------*\
Class noPyrolysis Declaration
Class noPyrolysis Declaration
\*---------------------------------------------------------------------------*/
class noPyrolysis
@ -81,10 +81,13 @@ protected:
//- Reset solidChemistryModel and solidThermo pointers
void constructThermoChemistry();
//- Pointer to the solid chemistry model
//- Reference to solid thermo
autoPtr<solidReactionThermo> solidThermo_;
//- Reference to the solid chemistry model
autoPtr<basicSolidChemistryModel> solidChemistry_;
//- Pointer to radiation model
//- Pointer to radiation model
autoPtr<radiation::radiationModel> radiation_;
@ -148,7 +151,6 @@ public:
//- Evolve the pyrolysis equations
virtual void evolveRegion();
};

40
src/regionModels/pyrolysisModels/reactingOneDim/reactingOneDim.C
View File

@ -152,7 +152,7 @@ void reactingOneDim::updatePhiGas()
forAll(gasTable, gasI)
{
tmp<volScalarField> tHsiGas =
solidChemistry_->gasHs(solidThermo_.p(), solidThermo_.T(), gasI);
solidChemistry_->gasHs(solidThermo_->p(), solidThermo_->T(), gasI);
const volScalarField& HsiGas = tHsiGas();
@ -300,7 +300,7 @@ void reactingOneDim::solveEnergy()
InfoInFunction << endl;
}
tmp<volScalarField> alpha(solidThermo_.alpha());
tmp<volScalarField> alpha(solidThermo_->alpha());
fvScalarMatrix hEqn
(
@ -382,9 +382,9 @@ reactingOneDim::reactingOneDim
)
:
pyrolysisModel(modelType, mesh, regionType),
solidChemistry_(basicSolidChemistryModel::New(regionMesh())),
solidThermo_(solidChemistry_->solidThermo()),
radiation_(radiation::radiationModel::New(solidThermo_.T())),
solidThermo_(solidReactionThermo::New(regionMesh())),
solidChemistry_(basicSolidChemistryModel::New(solidThermo_())),
radiation_(radiation::radiationModel::New(solidThermo_->T())),
rho_
(
IOobject
@ -395,10 +395,10 @@ reactingOneDim::reactingOneDim
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
solidThermo_.rho()
solidThermo_->rho()
),
Ys_(solidThermo_.composition().Y()),
h_(solidThermo_.he()),
Ys_(solidThermo_->composition().Y()),
h_(solidThermo_->he()),
nNonOrthCorr_(-1),
maxDiff_(10),
minimumDelta_(1e-4),
@ -482,9 +482,9 @@ reactingOneDim::reactingOneDim
)
:
pyrolysisModel(modelType, mesh, dict, regionType),
solidChemistry_(basicSolidChemistryModel::New(regionMesh())),
solidThermo_(solidChemistry_->solidThermo()),
radiation_(radiation::radiationModel::New(solidThermo_.T())),
solidThermo_(solidReactionThermo::New(regionMesh())),
solidChemistry_(basicSolidChemistryModel::New(solidThermo_())),
radiation_(radiation::radiationModel::New(solidThermo_->T())),
rho_
(
IOobject
@ -495,10 +495,10 @@ reactingOneDim::reactingOneDim
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
solidThermo_.rho()
solidThermo_->rho()
),
Ys_(solidThermo_.composition().Y()),
h_(solidThermo_.he()),
Ys_(solidThermo_->composition().Y()),
h_(solidThermo_->he()),
nNonOrthCorr_(-1),
maxDiff_(10),
minimumDelta_(1e-4),
@ -641,13 +641,13 @@ const volScalarField& reactingOneDim::rho() const
const volScalarField& reactingOneDim::T() const
{
return solidThermo_.T();
return solidThermo_->T();
}
const tmp<volScalarField> reactingOneDim::Cp() const
{
return solidThermo_.Cp();
return solidThermo_->Cp();
}
@ -659,7 +659,7 @@ tmp<volScalarField> reactingOneDim::kappaRad() const
tmp<volScalarField> reactingOneDim::kappa() const
{
return solidThermo_.kappa();
return solidThermo_->kappa();
}
@ -703,12 +703,12 @@ void reactingOneDim::evolveRegion()
calculateMassTransfer();
solidThermo_.correct();
solidThermo_->correct();
Info<< "pyrolysis min/max(T) = "
<< gMin(solidThermo_.T().primitiveField())
<< gMin(solidThermo_->T().primitiveField())
<< ", "
<< gMax(solidThermo_.T().primitiveField())
<< gMax(solidThermo_->T().primitiveField())
<< endl;
}

6
src/regionModels/pyrolysisModels/reactingOneDim/reactingOneDim.H
View File

@ -77,12 +77,12 @@ protected:
// Protected data
//- Reference to solid thermo
autoPtr<solidReactionThermo> solidThermo_;
//- Reference to the solid chemistry model
autoPtr<basicSolidChemistryModel> solidChemistry_;
//- Reference to solid thermo
solidReactionThermo& solidThermo_;
//- Pointer to radiation model
autoPtr<radiation::radiationModel> radiation_;

3
src/thermophysicalModels/basic/basicThermo/basicThermo.H
View File

@ -255,6 +255,9 @@ public:
//- Update properties
virtual void correct() = 0;
//- Return the name of the thermo physics
virtual word thermoName() const = 0;
//- Return true if the equation of state is incompressible
// i.e. rho != f(p)
virtual bool incompressible() const = 0;

6
src/thermophysicalModels/basic/heThermo/heThermo.H
View File

@ -125,6 +125,12 @@ public:
return *this;
}
//- Return the name of the thermo physics
virtual word thermoName() const
{
return MixtureType::thermoType::typeName();
}
//- Return true if the equation of state is incompressible
// i.e. rho != f(p)
virtual bool incompressible() const

7
src/thermophysicalModels/chemistryModel/Make/files
View File

@ -1,10 +1,5 @@
chemistryModel/basicChemistryModel/basicChemistryModel.C
chemistryModel/psiChemistryModel/psiChemistryModel.C
chemistryModel/psiChemistryModel/psiChemistryModels.C
chemistryModel/rhoChemistryModel/rhoChemistryModel.C
chemistryModel/rhoChemistryModel/rhoChemistryModels.C
chemistryModel/BasicChemistryModel/BasicChemistryModels.C
chemistryModel/TDACChemistryModel/reduction/makeChemistryReductionMethods.C
chemistryModel/TDACChemistryModel/tabulation/makeChemistryTabulationMethods.C

40
src/thermophysicalModels/chemistryModel/chemistryModel/psiChemistryModel/psiChemistryModel.C → src/thermophysicalModels/chemistryModel/chemistryModel/BasicChemistryModel/BasicChemistryModel.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2017 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -23,46 +23,38 @@ License
\*---------------------------------------------------------------------------*/
#include "psiChemistryModel.H"
#include "fvMesh.H"
/* * * * * * * * * * * * * * * private static data * * * * * * * * * * * * * */
namespace Foam
{
defineTypeNameAndDebug(psiChemistryModel, 0);
defineRunTimeSelectionTable(psiChemistryModel, fvMesh);
}
#include "BasicChemistryModel.H"
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::psiChemistryModel::psiChemistryModel
template<class ReactionThermo>
Foam::BasicChemistryModel<ReactionThermo>::BasicChemistryModel
(
const fvMesh& mesh,
const word& phaseName
ReactionThermo& thermo
)
:
basicChemistryModel(mesh, phaseName),
thermo_(psiReactionThermo::New(mesh, phaseName))
basicChemistryModel(thermo),
thermo_(thermo)
{}
// * * * * * * * * * * * * * * * * Selectors * * * * * * * * * * * * * * * * //
Foam::autoPtr<Foam::psiChemistryModel> Foam::psiChemistryModel::New
(
const fvMesh& mesh,
const word& phaseName
)
template<class ReactionThermo>
Foam::autoPtr<Foam::BasicChemistryModel<ReactionThermo>>
Foam::BasicChemistryModel<ReactionThermo>::New(ReactionThermo& thermo)
{
return basicChemistryModel::New<psiChemistryModel>(mesh, phaseName);
return basicChemistryModel::New<BasicChemistryModel<ReactionThermo>>
(
thermo
);
}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::psiChemistryModel::~psiChemistryModel()
template<class ReactionThermo>
Foam::BasicChemistryModel<ReactionThermo>::~BasicChemistryModel()
{}

69
src/thermophysicalModels/chemistryModel/chemistryModel/rhoChemistryModel/rhoChemistryModel.H → src/thermophysicalModels/chemistryModel/chemistryModel/BasicChemistryModel/BasicChemistryModel.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2017 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -22,25 +22,23 @@ License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Class
Foam::rhoChemistryModel
Foam::BasicChemistryModel
Description
Chemistry model for density-based thermodynamics
Basic chemistry model templated on thermodynamics
SourceFiles
rhoChemistryModelI.H
rhoChemistryModel.C
newChemistryModel.C
BasicChemistryModelI.H
BasicChemistryModel.C
\*---------------------------------------------------------------------------*/
#ifndef rhoChemistryModel_H
#define rhoChemistryModel_H
#ifndef BasicChemistryModel_H
#define BasicChemistryModel_H
#include "basicChemistryModel.H"
#include "autoPtr.H"
#include "runTimeSelectionTables.H"
#include "rhoReactionThermo.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -51,72 +49,67 @@ namespace Foam
class fvMesh;
/*---------------------------------------------------------------------------*\
class rhoChemistryModel Declaration
class BasicChemistryModel Declaration
\*---------------------------------------------------------------------------*/
class rhoChemistryModel
template<class ReactionThermo>
class BasicChemistryModel
:
public basicChemistryModel
{
// Private Member Functions
//- Construct as copy (not implemented)
rhoChemistryModel(const rhoChemistryModel&);
//- Disallow default bitwise assignment
void operator=(const rhoChemistryModel&);
protected:
// Protected data
//- Thermo package
autoPtr<rhoReactionThermo> thermo_;
//- Thermo
ReactionThermo& thermo_;
public:
//- Runtime type information
TypeName("rho");
TypeName("BasicChemistryModel");
//- Thermo type
typedef ReactionThermo reactionThermo;
//- Declare run-time constructor selection tables
declareRunTimeSelectionTable
(
autoPtr,
rhoChemistryModel,
fvMesh,
(const fvMesh& mesh, const word& phaseName),
(mesh, phaseName)
BasicChemistryModel,
thermo,
(ReactionThermo& thermo),
(thermo)
);
// Constructors
//- Construct from mesh and phase name
rhoChemistryModel(const fvMesh& mesh, const word& phaseName);
//- Construct from thermo
BasicChemistryModel(ReactionThermo& thermo);
//- Selector
static autoPtr<rhoChemistryModel> New
static autoPtr<BasicChemistryModel<ReactionThermo>> New
(
const fvMesh& mesh,
const word& phaseName=word::null
ReactionThermo& thermo
);
//- Destructor
virtual ~rhoChemistryModel();
virtual ~BasicChemistryModel();
// Member Functions
//- Return access to the thermo package
inline rhoReactionThermo& thermo();
inline ReactionThermo& thermo();
//- Return const access to the thermo package
inline const rhoReactionThermo& thermo() const;
inline const ReactionThermo& thermo() const;
};
@ -126,7 +119,11 @@ public:
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#include "rhoChemistryModelI.H"
#ifdef NoRepository
#include "BasicChemistryModel.C"
#endif
#include "BasicChemistryModelI.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

15
src/thermophysicalModels/chemistryModel/chemistryModel/psiChemistryModel/psiChemistryModelI.H → src/thermophysicalModels/chemistryModel/chemistryModel/BasicChemistryModel/BasicChemistryModelI.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2012 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2017 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -23,17 +23,22 @@ License
\*---------------------------------------------------------------------------*/
#include "BasicChemistryModel.H"
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
inline Foam::psiReactionThermo& Foam::psiChemistryModel::thermo()
template<class ReactionThermo>
inline ReactionThermo& Foam::BasicChemistryModel<ReactionThermo>::thermo()
{
return *thermo_;
return thermo_;
}
inline const Foam::psiReactionThermo& Foam::psiChemistryModel::thermo() const
template<class ReactionThermo>
inline const ReactionThermo&
Foam::BasicChemistryModel<ReactionThermo>::thermo() const
{
return *thermo_;
return thermo_;
}

339
src/thermophysicalModels/chemistryModel/chemistryModel/BasicChemistryModel/BasicChemistryModels.C Normal file
View File

@ -0,0 +1,339 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-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/>.
InClass
Foam::psiChemistryModel
Description
Creates chemistry model instances templated on the type of thermodynamics
\*---------------------------------------------------------------------------*/
#include "makeChemistryModel.H"
#include "psiReactionThermo.H"
#include "rhoReactionThermo.H"
#include "StandardChemistryModel.H"
#include "TDACChemistryModel.H"
#include "thermoPhysicsTypes.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// Make base types
makeChemistryModel(psiReactionThermo);
makeChemistryModel(rhoReactionThermo);
// Chemistry moldels based on sensibleEnthalpy
makeChemistryModelType
(
StandardChemistryModel,
psiReactionThermo,
constGasHThermoPhysics
);
makeChemistryModelType
(
StandardChemistryModel,
psiReactionThermo,
gasHThermoPhysics
);
makeChemistryModelType
(
StandardChemistryModel,
psiReactionThermo,
constIncompressibleGasHThermoPhysics
);
makeChemistryModelType
(
StandardChemistryModel,
psiReactionThermo,
incompressibleGasHThermoPhysics
);
makeChemistryModelType
(
StandardChemistryModel,
psiReactionThermo,
icoPoly8HThermoPhysics
);
makeChemistryModelType
(
StandardChemistryModel,
rhoReactionThermo,
constGasHThermoPhysics
);
makeChemistryModelType
(
StandardChemistryModel,
rhoReactionThermo,
gasHThermoPhysics
);
makeChemistryModelType
(
StandardChemistryModel,
rhoReactionThermo,
constIncompressibleGasHThermoPhysics
);
makeChemistryModelType
(
StandardChemistryModel,
rhoReactionThermo,
incompressibleGasHThermoPhysics
);
makeChemistryModelType
(
StandardChemistryModel,
rhoReactionThermo,
icoPoly8HThermoPhysics
);
makeChemistryModelType
(
TDACChemistryModel,
psiReactionThermo,
constGasHThermoPhysics
);
makeChemistryModelType
(
TDACChemistryModel,
psiReactionThermo,
gasHThermoPhysics
);
makeChemistryModelType
(
TDACChemistryModel,
psiReactionThermo,
constIncompressibleGasHThermoPhysics
);
makeChemistryModelType
(
TDACChemistryModel,
psiReactionThermo,
incompressibleGasHThermoPhysics
);
makeChemistryModelType
(
TDACChemistryModel,
psiReactionThermo,
icoPoly8HThermoPhysics
);
makeChemistryModelType
(
TDACChemistryModel,
rhoReactionThermo,
constGasHThermoPhysics
);
makeChemistryModelType
(
TDACChemistryModel,
rhoReactionThermo,
gasHThermoPhysics
);
makeChemistryModelType
(
TDACChemistryModel,
rhoReactionThermo,
constIncompressibleGasHThermoPhysics
);
makeChemistryModelType
(
TDACChemistryModel,
rhoReactionThermo,
incompressibleGasHThermoPhysics
);
makeChemistryModelType
(
TDACChemistryModel,
rhoReactionThermo,
icoPoly8HThermoPhysics
);
// Chemistry moldels based on sensibleInternalEnergy
makeChemistryModelType
(
StandardChemistryModel,
psiReactionThermo,
constGasEThermoPhysics
);
makeChemistryModelType
(
StandardChemistryModel,
psiReactionThermo,
gasEThermoPhysics
);
makeChemistryModelType
(
StandardChemistryModel,
psiReactionThermo,
constIncompressibleGasEThermoPhysics
);
makeChemistryModelType
(
StandardChemistryModel,
psiReactionThermo,
incompressibleGasEThermoPhysics
);
makeChemistryModelType
(
StandardChemistryModel,
psiReactionThermo,
icoPoly8EThermoPhysics
);
makeChemistryModelType
(
StandardChemistryModel,
rhoReactionThermo,
constGasEThermoPhysics
);
makeChemistryModelType
(
StandardChemistryModel,
rhoReactionThermo,
gasEThermoPhysics
);
makeChemistryModelType
(
StandardChemistryModel,
rhoReactionThermo,
constIncompressibleGasEThermoPhysics
);
makeChemistryModelType
(
StandardChemistryModel,
rhoReactionThermo,
incompressibleGasEThermoPhysics
);
makeChemistryModelType
(
StandardChemistryModel,
rhoReactionThermo,
icoPoly8EThermoPhysics
);
makeChemistryModelType
(
TDACChemistryModel,
psiReactionThermo,
constGasEThermoPhysics
);
makeChemistryModelType
(
TDACChemistryModel,
psiReactionThermo,
gasEThermoPhysics
);
makeChemistryModelType
(
TDACChemistryModel,
psiReactionThermo,
constIncompressibleGasEThermoPhysics
);
makeChemistryModelType
(
TDACChemistryModel,
psiReactionThermo,
incompressibleGasEThermoPhysics
);
makeChemistryModelType
(
TDACChemistryModel,
psiReactionThermo,
icoPoly8EThermoPhysics
);
makeChemistryModelType
(
TDACChemistryModel,
rhoReactionThermo,
constGasEThermoPhysics
);
makeChemistryModelType
(
TDACChemistryModel,
rhoReactionThermo,
gasEThermoPhysics
);
makeChemistryModelType
(
TDACChemistryModel,
rhoReactionThermo,
constIncompressibleGasEThermoPhysics
);
makeChemistryModelType
(
TDACChemistryModel,
rhoReactionThermo,
incompressibleGasEThermoPhysics
);
makeChemistryModelType
(
TDACChemistryModel,
rhoReactionThermo,
icoPoly8EThermoPhysics
);
}
// ************************************************************************* //

83
src/thermophysicalModels/chemistryModel/chemistryModel/chemistryModel/chemistryModel.C → src/thermophysicalModels/chemistryModel/chemistryModel/StandardChemistryModel/StandardChemistryModel.C
View File

@ -23,21 +23,20 @@ License
\*---------------------------------------------------------------------------*/
#include "chemistryModel.H"
#include "StandardChemistryModel.H"
#include "reactingMixture.H"
#include "UniformField.H"
#include "extrapolatedCalculatedFvPatchFields.H"
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class CompType, class ThermoType>
Foam::chemistryModel<CompType, ThermoType>::chemistryModel
template<class ReactionThermo, class ThermoType>
Foam::StandardChemistryModel<ReactionThermo, ThermoType>::StandardChemistryModel
(
const fvMesh& mesh,
const word& phaseName
ReactionThermo& thermo
)
:
CompType(mesh, phaseName),
BasicChemistryModel<ReactionThermo>(thermo),
ODESystem(),
Y_(this->thermo().composition().Y()),
reactions_
@ -52,7 +51,14 @@ Foam::chemistryModel<CompType, ThermoType>::chemistryModel
nSpecie_(Y_.size()),
nReaction_(reactions_.size()),
Treact_(CompType::template lookupOrDefault<scalar>("Treact", 0.0)),
Treact_
(
BasicChemistryModel<ReactionThermo>::template lookupOrDefault<scalar>
(
"Treact",
0.0
)
),
RR_(nSpecie_),
c_(nSpecie_),
dcdt_(nSpecie_)
@ -68,33 +74,34 @@ Foam::chemistryModel<CompType, ThermoType>::chemistryModel
IOobject
(
"RR." + Y_[fieldi].name(),
mesh.time().timeName(),
mesh,
this->mesh().time().timeName(),
this->mesh(),
IOobject::NO_READ,
IOobject::NO_WRITE
),
mesh,
this->mesh(),
dimensionedScalar(dimMass/dimVolume/dimTime, Zero)
)
);
}
Info<< "chemistryModel: Number of species = " << nSpecie_
Info<< "StandardChemistryModel: Number of species = " << nSpecie_
<< " and reactions = " << nReaction_ << endl;
}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
template<class CompType, class ThermoType>
Foam::chemistryModel<CompType, ThermoType>::~chemistryModel()
template<class ReactionThermo, class ThermoType>
Foam::StandardChemistryModel<ReactionThermo, ThermoType>::
~StandardChemistryModel()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class CompType, class ThermoType>
void Foam::chemistryModel<CompType, ThermoType>::omega
template<class ReactionThermo, class ThermoType>
void Foam::StandardChemistryModel<ReactionThermo, ThermoType>::omega
(
const scalarField& c,
const scalar T,
@ -133,8 +140,8 @@ void Foam::chemistryModel<CompType, ThermoType>::omega
}
template<class CompType, class ThermoType>
Foam::scalar Foam::chemistryModel<CompType, ThermoType>::omegaI
template<class ReactionThermo, class ThermoType>
Foam::scalar Foam::StandardChemistryModel<ReactionThermo, ThermoType>::omegaI
(
const label index,
const scalarField& c,
@ -154,8 +161,8 @@ Foam::scalar Foam::chemistryModel<CompType, ThermoType>::omegaI
}
template<class CompType, class ThermoType>
Foam::scalar Foam::chemistryModel<CompType, ThermoType>::omega
template<class ReactionThermo, class ThermoType>
Foam::scalar Foam::StandardChemistryModel<ReactionThermo, ThermoType>::omega
(
const Reaction<ThermoType>& R,
const scalarField& c,
@ -266,8 +273,8 @@ Foam::scalar Foam::chemistryModel<CompType, ThermoType>::omega
}
template<class CompType, class ThermoType>
void Foam::chemistryModel<CompType, ThermoType>::derivatives
template<class ReactionThermo, class ThermoType>
void Foam::StandardChemistryModel<ReactionThermo, ThermoType>::derivatives
(
const scalar time,
const scalarField& c,
@ -316,8 +323,8 @@ void Foam::chemistryModel<CompType, ThermoType>::derivatives
}
template<class CompType, class ThermoType>
void Foam::chemistryModel<CompType, ThermoType>::jacobian
template<class ReactionThermo, class ThermoType>
void Foam::StandardChemistryModel<ReactionThermo, ThermoType>::jacobian
(
const scalar t,
const scalarField& c,
@ -458,9 +465,9 @@ void Foam::chemistryModel<CompType, ThermoType>::jacobian
}
template<class CompType, class ThermoType>
template<class ReactionThermo, class ThermoType>
Foam::tmp<Foam::volScalarField>
Foam::chemistryModel<CompType, ThermoType>::tc() const
Foam::StandardChemistryModel<ReactionThermo, ThermoType>::tc() const
{
tmp<volScalarField> ttc
(
@ -532,9 +539,9 @@ Foam::chemistryModel<CompType, ThermoType>::tc() const
}
template<class CompType, class ThermoType>
template<class ReactionThermo, class ThermoType>
Foam::tmp<Foam::volScalarField>
Foam::chemistryModel<CompType, ThermoType>::Qdot() const
Foam::StandardChemistryModel<ReactionThermo, ThermoType>::Qdot() const
{
tmp<volScalarField> tQdot
(
@ -572,9 +579,9 @@ Foam::chemistryModel<CompType, ThermoType>::Qdot() const
}
template<class CompType, class ThermoType>
template<class ReactionThermo, class ThermoType>
Foam::tmp<Foam::DimensionedField<Foam::scalar, Foam::volMesh>>
Foam::chemistryModel<CompType, ThermoType>::calculateRR
Foam::StandardChemistryModel<ReactionThermo, ThermoType>::calculateRR
(
const label ri,
const label si
@ -641,8 +648,8 @@ Foam::chemistryModel<CompType, ThermoType>::calculateRR
}
template<class CompType, class ThermoType>
void Foam::chemistryModel<CompType, ThermoType>::calculate()
template<class ReactionThermo, class ThermoType>
void Foam::StandardChemistryModel<ReactionThermo, ThermoType>::calculate()
{
if (!this->chemistry_)
{
@ -677,14 +684,14 @@ void Foam::chemistryModel<CompType, ThermoType>::calculate()
}
template<class CompType, class ThermoType>
template<class ReactionThermo, class ThermoType>
template<class DeltaTType>
Foam::scalar Foam::chemistryModel<CompType, ThermoType>::solve
Foam::scalar Foam::StandardChemistryModel<ReactionThermo, ThermoType>::solve
(
const DeltaTType& deltaT
)
{
CompType::correct();
BasicChemistryModel<ReactionThermo>::correct();
scalar deltaTMin = GREAT;
@ -748,8 +755,8 @@ Foam::scalar Foam::chemistryModel<CompType, ThermoType>::solve
}
template<class CompType, class ThermoType>
Foam::scalar Foam::chemistryModel<CompType, ThermoType>::solve
template<class ReactionThermo, class ThermoType>
Foam::scalar Foam::StandardChemistryModel<ReactionThermo, ThermoType>::solve
(
const scalar deltaT
)
@ -763,8 +770,8 @@ Foam::scalar Foam::chemistryModel<CompType, ThermoType>::solve
}
template<class CompType, class ThermoType>
Foam::scalar Foam::chemistryModel<CompType, ThermoType>::solve
template<class ReactionThermo, class ThermoType>
Foam::scalar Foam::StandardChemistryModel<ReactionThermo, ThermoType>::solve
(
const scalarField& deltaT
)

36
src/thermophysicalModels/chemistryModel/chemistryModel/chemistryModel/chemistryModel.H → src/thermophysicalModels/chemistryModel/chemistryModel/StandardChemistryModel/StandardChemistryModel.H
View File

@ -22,7 +22,7 @@ License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Class
Foam::chemistryModel
Foam::StandardChemistryModel
Description
Extends base chemistry model by adding a thermo package, and ODE functions.
@ -30,14 +30,15 @@ Description
terms.
SourceFiles
chemistryModelI.H
chemistryModel.C
StandardChemistryModelI.H
StandardChemistryModel.C
\*---------------------------------------------------------------------------*/
#ifndef chemistryModel_H
#define chemistryModel_H
#ifndef StandardChemistryModel_H
#define StandardChemistryModel_H
#include "BasicChemistryModel.H"
#include "Reaction.H"
#include "ODESystem.H"
#include "volFields.H"
@ -52,13 +53,13 @@ namespace Foam
class fvMesh;
/*---------------------------------------------------------------------------*\
Class chemistryModel Declaration
Class StandardChemistryModel Declaration
\*---------------------------------------------------------------------------*/
template<class CompType, class ThermoType>
class chemistryModel
template<class ReactionThermo, class ThermoType>
class StandardChemistryModel
:
public CompType,
public BasicChemistryModel<ReactionThermo>,
public ODESystem
{
// Private Member Functions
@ -69,16 +70,17 @@ class chemistryModel
scalar solve(const DeltaTType& deltaT);
//- Disallow copy constructor
chemistryModel(const chemistryModel&);
StandardChemistryModel(const StandardChemistryModel&);
//- Disallow default bitwise assignment
void operator=(const chemistryModel&);
void operator=(const StandardChemistryModel&);
protected:
typedef ThermoType thermoType;
// Protected data
//- Reference to the field of specie mass fractions
@ -119,17 +121,17 @@ protected:
public:
//- Runtime type information
TypeName("chemistryModel");
TypeName("standard");
// Constructors
//- Construct from mesh
chemistryModel(const fvMesh& mesh, const word& phaseName);
//- Construct from thermo
StandardChemistryModel(ReactionThermo& thermo);
//- Destructor
virtual ~chemistryModel();
virtual ~StandardChemistryModel();
// Member Functions
@ -272,12 +274,12 @@ public:
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#include "chemistryModelI.H"
#include "StandardChemistryModelI.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#ifdef NoRepository
#include "chemistryModel.C"
#include "StandardChemistryModel.C"
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

41
src/thermophysicalModels/chemistryModel/chemistryModel/chemistryModel/chemistryModelI.H → src/thermophysicalModels/chemistryModel/chemistryModel/StandardChemistryModel/StandardChemistryModelI.H
View File

@ -28,73 +28,74 @@ License
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class CompType, class ThermoType>
inline Foam::label Foam::chemistryModel<CompType, ThermoType>::nEqns() const
template<class ReactionThermo, class ThermoType>
inline Foam::label
Foam::StandardChemistryModel<ReactionThermo, ThermoType>::nEqns() const
{
// nEqns = number of species + temperature + pressure
return nSpecie_ + 2;
}
template<class CompType, class ThermoType>
template<class ReactionThermo, class ThermoType>
inline Foam::PtrList<Foam::DimensionedField<Foam::scalar, Foam::volMesh>>&
Foam::chemistryModel<CompType, ThermoType>::RR()
Foam::StandardChemistryModel<ReactionThermo, ThermoType>::RR()
{
return RR_;
}
template<class CompType, class ThermoType>
template<class ReactionThermo, class ThermoType>
inline const Foam::PtrList<Foam::Reaction<ThermoType>>&
Foam::chemistryModel<CompType, ThermoType>::reactions() const
Foam::StandardChemistryModel<ReactionThermo, ThermoType>::reactions() const
{
return reactions_;
}
template<class CompType, class ThermoType>
template<class ReactionThermo, class ThermoType>
inline const Foam::PtrList<ThermoType>&
Foam::chemistryModel<CompType, ThermoType>::specieThermo() const
Foam::StandardChemistryModel<ReactionThermo, ThermoType>::specieThermo() const
{
return specieThermo_;
}
template<class CompType, class ThermoType>
template<class ReactionThermo, class ThermoType>
inline Foam::label
Foam::chemistryModel<CompType, ThermoType>::nSpecie() const
Foam::StandardChemistryModel<ReactionThermo, ThermoType>::nSpecie() const
{
return nSpecie_;
}
template<class CompType, class ThermoType>
template<class ReactionThermo, class ThermoType>
inline Foam::label
Foam::chemistryModel<CompType, ThermoType>::nReaction() const
Foam::StandardChemistryModel<ReactionThermo, ThermoType>::nReaction() const
{
return nReaction_;
}
template<class CompType, class ThermoType>
template<class ReactionThermo, class ThermoType>
inline Foam::scalar
Foam::chemistryModel<CompType, ThermoType>::Treact() const
Foam::StandardChemistryModel<ReactionThermo, ThermoType>::Treact() const
{
return Treact_;
}
template<class CompType, class ThermoType>
template<class ReactionThermo, class ThermoType>
inline Foam::scalar&
Foam::chemistryModel<CompType, ThermoType>::Treact()
Foam::StandardChemistryModel<ReactionThermo, ThermoType>::Treact()
{
return Treact_;
}
template<class CompType, class ThermoType>
template<class ReactionThermo, class ThermoType>
inline const Foam::DimensionedField<Foam::scalar, Foam::volMesh>&
Foam::chemistryModel<CompType, ThermoType>::RR
Foam::StandardChemistryModel<ReactionThermo, ThermoType>::RR
(
const label i
) const
@ -102,9 +103,9 @@ Foam::chemistryModel<CompType, ThermoType>::RR
return RR_[i];
}
template<class CompType, class ThermoType>
template<class ReactionThermo, class ThermoType>
Foam::DimensionedField<Foam::scalar, Foam::volMesh>&
Foam::chemistryModel<CompType, ThermoType>::RR
Foam::StandardChemistryModel<ReactionThermo, ThermoType>::RR
(
const label i
)

84
src/thermophysicalModels/chemistryModel/chemistryModel/TDACChemistryModel/TDACChemistryModel.C
View File

@ -30,18 +30,21 @@ License
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class CompType, class ThermoType>
Foam::TDACChemistryModel<CompType, ThermoType>::TDACChemistryModel
template<class ReactionThermo, class ThermoType>
Foam::TDACChemistryModel<ReactionThermo, ThermoType>::TDACChemistryModel
(
const fvMesh& mesh,
const word& phaseName
ReactionThermo& thermo
)
:
chemistryModel<CompType, ThermoType>(mesh, phaseName),
StandardChemistryModel<ReactionThermo, ThermoType>(thermo),
variableTimeStep_
(
mesh.time().controlDict().lookupOrDefault("adjustTimeStep", false)
|| fv::localEulerDdt::enabled(mesh)
this->mesh().time().controlDict().lookupOrDefault
(
"adjustTimeStep",
false
)
|| fv::localEulerDdt::enabled(this->mesh())
),
timeSteps_(0),
NsDAC_(this->nSpecie_),
@ -54,13 +57,13 @@ Foam::TDACChemistryModel<CompType, ThermoType>::TDACChemistryModel
(
IOobject
(
IOobject::groupName("TabulationResults", phaseName),
thermo.phasePropertyName("TabulationResults"),
this->time().timeName(),
this->mesh(),
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
mesh,
this->mesh(),
dimensionedScalar(dimless, Zero)
)
{
@ -78,7 +81,7 @@ Foam::TDACChemistryModel<CompType, ThermoType>::TDACChemistryModel
specieComp_[i] = specComp[this->Y()[i].member()];
}
mechRed_ = chemistryReductionMethod<CompType, ThermoType>::New
mechRed_ = chemistryReductionMethod<ReactionThermo, ThermoType>::New
(
*this,
*this
@ -93,8 +96,8 @@ Foam::TDACChemistryModel<CompType, ThermoType>::TDACChemistryModel
IOobject header
(
this->Y()[i].name(),
mesh.time().timeName(),
mesh,
this->mesh().time().timeName(),
this->mesh(),
IOobject::NO_READ
);
@ -108,7 +111,7 @@ Foam::TDACChemistryModel<CompType, ThermoType>::TDACChemistryModel
}
}
tabulation_ = chemistryTabulationMethod<CompType, ThermoType>::New
tabulation_ = chemistryTabulationMethod<ReactionThermo, ThermoType>::New
(
*this,
*this
@ -136,15 +139,15 @@ Foam::TDACChemistryModel<CompType, ThermoType>::TDACChemistryModel
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
template<class CompType, class ThermoType>
Foam::TDACChemistryModel<CompType, ThermoType>::~TDACChemistryModel()
template<class ReactionThermo, class ThermoType>
Foam::TDACChemistryModel<ReactionThermo, ThermoType>::~TDACChemistryModel()
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class CompType, class ThermoType>
void Foam::TDACChemistryModel<CompType, ThermoType>::omega
template<class ReactionThermo, class ThermoType>
void Foam::TDACChemistryModel<ReactionThermo, ThermoType>::omega
(
const scalarField& c, // Contains all species even when mechRed is active
const scalar T,
@ -197,8 +200,8 @@ void Foam::TDACChemistryModel<CompType, ThermoType>::omega
}
template<class CompType, class ThermoType>
Foam::scalar Foam::TDACChemistryModel<CompType, ThermoType>::omega
template<class ReactionThermo, class ThermoType>
Foam::scalar Foam::TDACChemistryModel<ReactionThermo, ThermoType>::omega
(
const Reaction<ThermoType>& R,
const scalarField& c, // Contains all species even when mechRed is active
@ -306,8 +309,8 @@ Foam::scalar Foam::TDACChemistryModel<CompType, ThermoType>::omega
}
template<class CompType, class ThermoType>
void Foam::TDACChemistryModel<CompType, ThermoType>::derivatives
template<class ReactionThermo, class ThermoType>
void Foam::TDACChemistryModel<ReactionThermo, ThermoType>::derivatives
(
const scalar time,
const scalarField& c,
@ -390,8 +393,8 @@ void Foam::TDACChemistryModel<CompType, ThermoType>::derivatives
}
template<class CompType, class ThermoType>
void Foam::TDACChemistryModel<CompType, ThermoType>::jacobian
template<class ReactionThermo, class ThermoType>
void Foam::TDACChemistryModel<ReactionThermo, ThermoType>::jacobian
(
const scalar t,
const scalarField& c,
@ -575,8 +578,8 @@ void Foam::TDACChemistryModel<CompType, ThermoType>::jacobian
}
template<class CompType, class ThermoType>
void Foam::TDACChemistryModel<CompType, ThermoType>::jacobian
template<class ReactionThermo, class ThermoType>
void Foam::TDACChemistryModel<ReactionThermo, ThermoType>::jacobian
(
const scalar t,
const scalarField& c,
@ -594,9 +597,9 @@ void Foam::TDACChemistryModel<CompType, ThermoType>::jacobian
}
template<class CompType, class ThermoType>
template<class ReactionThermo, class ThermoType>
template<class DeltaTType>
Foam::scalar Foam::TDACChemistryModel<CompType, ThermoType>::solve
Foam::scalar Foam::TDACChemistryModel<ReactionThermo, ThermoType>::solve
(
const DeltaTType& deltaT
)
@ -625,7 +628,7 @@ Foam::scalar Foam::TDACChemistryModel<CompType, ThermoType>::solve
scalar nActiveSpecies = 0;
scalar nAvg = 0;
CompType::correct();
BasicChemistryModel<ReactionThermo>::correct();
scalar deltaTMin = GREAT;
@ -880,8 +883,8 @@ Foam::scalar Foam::TDACChemistryModel<CompType, ThermoType>::solve
}
template<class CompType, class ThermoType>
Foam::scalar Foam::TDACChemistryModel<CompType, ThermoType>::solve
template<class ReactionThermo, class ThermoType>
Foam::scalar Foam::TDACChemistryModel<ReactionThermo, ThermoType>::solve
(
const scalar deltaT
)
@ -895,8 +898,8 @@ Foam::scalar Foam::TDACChemistryModel<CompType, ThermoType>::solve
}
template<class CompType, class ThermoType>
Foam::scalar Foam::TDACChemistryModel<CompType, ThermoType>::solve
template<class ReactionThermo, class ThermoType>
Foam::scalar Foam::TDACChemistryModel<ReactionThermo, ThermoType>::solve
(
const scalarField& deltaT
)
@ -905,8 +908,9 @@ Foam::scalar Foam::TDACChemistryModel<CompType, ThermoType>::solve
}
template<class CompType, class ThermoType>
void Foam::TDACChemistryModel<CompType, ThermoType>::setTabulationResultsAdd
template<class ReactionThermo, class ThermoType>
void Foam::TDACChemistryModel<ReactionThermo, ThermoType>::
setTabulationResultsAdd
(
const label celli
)
@ -915,18 +919,16 @@ void Foam::TDACChemistryModel<CompType, ThermoType>::setTabulationResultsAdd
}
template<class CompType, class ThermoType>
void Foam::TDACChemistryModel<CompType, ThermoType>::setTabulationResultsGrow
(
const label celli
)
template<class ReactionThermo, class ThermoType>
void Foam::TDACChemistryModel<ReactionThermo, ThermoType>::
setTabulationResultsGrow(const label celli)
{
tabulationResults_[celli] = 1.0;
}
template<class CompType, class ThermoType>
void Foam::TDACChemistryModel<CompType, ThermoType>::
template<class ReactionThermo, class ThermoType>
void Foam::TDACChemistryModel<ReactionThermo, ThermoType>::
setTabulationResultsRetrieve
(
const label celli

33
src/thermophysicalModels/chemistryModel/chemistryModel/TDACChemistryModel/TDACChemistryModel.H
View File

@ -25,7 +25,7 @@ Class
Foam::TDACChemistryModel
Description
Extends chemistryModel by adding the TDAC method.
Extends StandardChemistryModel by adding the TDAC method.
References:
\verbatim
@ -64,7 +64,7 @@ SourceFiles
#ifndef TDACChemistryModel_H
#define TDACChemistryModel_H
#include "chemistryModel.H"
#include "StandardChemistryModel.H"
#include "chemistryReductionMethod.H"
#include "chemistryTabulationMethod.H"
#include "OFstream.H"
@ -78,10 +78,10 @@ namespace Foam
Class TDACChemistryModel Declaration
\*---------------------------------------------------------------------------*/
template<class CompType, class ThermoType>
template<class ReactionThermo, class ThermoType>
class TDACChemistryModel
:
public chemistryModel<CompType, ThermoType>
public StandardChemistryModel<ReactionThermo, ThermoType>
{
// Private member data
@ -97,10 +97,12 @@ class TDACChemistryModel
List<List<specieElement>> specieComp_;
Field<label> completeToSimplifiedIndex_;
DynamicList<label> simplifiedToCompleteIndex_;
autoPtr<chemistryReductionMethod<CompType, ThermoType>> mechRed_;
autoPtr<chemistryReductionMethod<ReactionThermo, ThermoType>>
mechRed_;
// Tabulation
autoPtr<chemistryTabulationMethod<CompType, ThermoType>> tabulation_;
autoPtr<chemistryTabulationMethod<ReactionThermo, ThermoType>>
tabulation_;
// Log file for the average time spent reducing the chemistry
autoPtr<OFstream> cpuReduceFile_;
@ -145,17 +147,13 @@ class TDACChemistryModel
public:
//- Runtime type information
TypeName("TDACChemistryModel");
TypeName("TDAC");
// Constructors
//- Construct from mesh
TDACChemistryModel
(
const fvMesh& mesh,
const word& phaseName
);
//- Construct from thermo
TDACChemistryModel(ReactionThermo& thermo);
//- Destructor
@ -202,7 +200,7 @@ public:
// Chemistry model functions (overriding functions in
// chemistryModel to use the private solve function)
// StandardChemistryModel to use the private solve function)
//- Solve the reaction system for the given time step
// and return the characteristic time
@ -213,8 +211,8 @@ public:
virtual scalar solve(const scalarField& deltaT);
// ODE functions (overriding functions in chemistryModel to take into
// account the variable number of species)
// ODE functions (overriding functions in StandardChemistryModel to take
// into account the variable number of species)
virtual void derivatives
(
@ -273,7 +271,8 @@ public:
inline List<List<specieElement>>& specieComp();
inline autoPtr<chemistryReductionMethod<CompType, ThermoType>>&
inline
autoPtr<chemistryReductionMethod<ReactionThermo, ThermoType>>&
mechRed();
tmp<volScalarField> tabulationResults() const

79
src/thermophysicalModels/chemistryModel/chemistryModel/TDACChemistryModel/TDACChemistryModelI.H
View File

@ -25,25 +25,26 @@ License
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
template<class CompType, class ThermoType>
template<class ReactionThermo, class ThermoType>
inline bool
Foam::TDACChemistryModel<CompType, ThermoType>::variableTimeStep() const
Foam::TDACChemistryModel<ReactionThermo, ThermoType>::variableTimeStep() const
{
return variableTimeStep_;
}
template<class CompType, class ThermoType>
template<class ReactionThermo, class ThermoType>
inline Foam::label
Foam::TDACChemistryModel<CompType, ThermoType>::timeSteps() const
Foam::TDACChemistryModel<ReactionThermo, ThermoType>::timeSteps() const
{
return timeSteps_;
}
template<class CompType, class ThermoType>
template<class ReactionThermo, class ThermoType>
inline Foam::autoPtr<Foam::OFstream>
Foam::TDACChemistryModel<CompType, ThermoType>::logFile(const word& name) const
Foam::TDACChemistryModel<ReactionThermo, ThermoType>::
logFile(const word& name) const
{
mkDir(this->mesh().time().path()/"TDAC"/this->group());
return autoPtr<OFstream>
@ -56,24 +57,25 @@ Foam::TDACChemistryModel<CompType, ThermoType>::logFile(const word& name) const
}
template<class CompType, class ThermoType>
template<class ReactionThermo, class ThermoType>
inline Foam::PtrList<Foam::volScalarField>&
Foam::TDACChemistryModel<CompType, ThermoType>::Y()
Foam::TDACChemistryModel<ReactionThermo, ThermoType>::Y()
{
return this->Y_;
}
template<class CompType, class ThermoType>
inline Foam::autoPtr<Foam::chemistryReductionMethod<CompType, ThermoType>>&
Foam::TDACChemistryModel<CompType, ThermoType>::mechRed()
template<class ReactionThermo, class ThermoType>
inline
Foam::autoPtr<Foam::chemistryReductionMethod<ReactionThermo, ThermoType>>&
Foam::TDACChemistryModel<ReactionThermo, ThermoType>::mechRed()
{
return mechRed_;
}
template<class CompType, class ThermoType>
inline void Foam::TDACChemistryModel<CompType, ThermoType>::setActive
template<class ReactionThermo, class ThermoType>
inline void Foam::TDACChemistryModel<ReactionThermo, ThermoType>::setActive
(
const label i
)
@ -82,8 +84,8 @@ inline void Foam::TDACChemistryModel<CompType, ThermoType>::setActive
}
template<class CompType, class ThermoType>
inline bool Foam::TDACChemistryModel<CompType, ThermoType>::active
template<class ReactionThermo, class ThermoType>
inline bool Foam::TDACChemistryModel<ReactionThermo, ThermoType>::active
(
const label i
) const
@ -92,81 +94,84 @@ inline bool Foam::TDACChemistryModel<CompType, ThermoType>::active
}
template<class CompType, class ThermoType>
inline void
Foam::TDACChemistryModel<CompType, ThermoType>::setNsDAC(const label newNsDAC)
template<class ReactionThermo, class ThermoType>
inline void Foam::TDACChemistryModel<ReactionThermo, ThermoType>::
setNsDAC(const label newNsDAC)
{
NsDAC_ = newNsDAC;
}
template<class CompType, class ThermoType>
inline void
Foam::TDACChemistryModel<CompType, ThermoType>::setNSpecie(const label newNs)
template<class ReactionThermo, class ThermoType>
inline void Foam::TDACChemistryModel<ReactionThermo, ThermoType>::
setNSpecie(const label newNs)
{
this->nSpecie_ = newNs;
}
template<class CompType, class ThermoType>
template<class ReactionThermo, class ThermoType>
inline Foam::DynamicList<Foam::label>&
Foam::TDACChemistryModel<CompType, ThermoType>::simplifiedToCompleteIndex()
Foam::TDACChemistryModel<ReactionThermo, ThermoType>::
simplifiedToCompleteIndex()
{
return simplifiedToCompleteIndex_;
}
template<class CompType, class ThermoType>
template<class ReactionThermo, class ThermoType>
inline Foam::Field<Foam::label>&
Foam::TDACChemistryModel<CompType, ThermoType>::completeToSimplifiedIndex()
Foam::TDACChemistryModel<ReactionThermo, ThermoType>::
completeToSimplifiedIndex()
{
return completeToSimplifiedIndex_;
}
template<class CompType, class ThermoType>
template<class ReactionThermo, class ThermoType>
inline const Foam::Field<Foam::label>&
Foam::TDACChemistryModel<CompType, ThermoType>::
Foam::TDACChemistryModel<ReactionThermo, ThermoType>::
completeToSimplifiedIndex() const
{
return completeToSimplifiedIndex_;
}
template<class CompType, class ThermoType>
template<class ReactionThermo, class ThermoType>
inline Foam::Field<bool>&
Foam::TDACChemistryModel<CompType, ThermoType>::reactionsDisabled()
Foam::TDACChemistryModel<ReactionThermo, ThermoType>::reactionsDisabled()
{
return reactionsDisabled_;
}
template<class CompType, class ThermoType>
template<class ReactionThermo, class ThermoType>
inline Foam::scalarField&
Foam::TDACChemistryModel<CompType, ThermoType>::completeC()
Foam::TDACChemistryModel<ReactionThermo, ThermoType>::completeC()
{
return completeC_;
}
template<class CompType, class ThermoType>
template<class ReactionThermo, class ThermoType>
inline Foam::scalarField&
Foam::TDACChemistryModel<CompType, ThermoType>::simplifiedC()
Foam::TDACChemistryModel<ReactionThermo, ThermoType>::simplifiedC()
{
return simplifiedC_;
}
template<class CompType, class ThermoType>
template<class ReactionThermo, class ThermoType>
inline Foam::List<Foam::List<Foam::specieElement>>&
Foam::TDACChemistryModel<CompType, ThermoType>::specieComp()
Foam::TDACChemistryModel<ReactionThermo, ThermoType>::specieComp()
{
return specieComp_;
}
template<class CompType, class ThermoType>
void Foam::TDACChemistryModel<CompType, ThermoType>::resetTabulationResults()
template<class ReactionThermo, class ThermoType>
void Foam::TDACChemistryModel<ReactionThermo, ThermoType>::
resetTabulationResults()
{
for (auto& res : tabulationResults_)
{

102
src/thermophysicalModels/chemistryModel/chemistryModel/TDACChemistryModel/reduction/chemistryReductionMethod/chemistryReductionMethodNew.C
View File

@ -36,55 +36,75 @@ Foam::chemistryReductionMethod<CompType, ThermoType>::New
TDACChemistryModel<CompType, ThermoType>& chemistry
)
{
IOdictionary thermoDict
(
IOobject
(
IOobject::groupName("thermophysicalProperties",dict.group()),
dict.db().time().constant(),
dict.db(),
IOobject::MUST_READ_IF_MODIFIED,
IOobject::NO_WRITE,
false
)
);
const dictionary& reductionDict(dict.subDict("reduction"));
word thermoTypeName;
const word methodName(reductionDict.lookup("method"));
if (thermoDict.isDict("thermoType"))
{
const dictionary& thermoTypeDict(thermoDict.subDict("thermoType"));
thermoTypeName =
word(thermoTypeDict.lookup("transport")) + '<'
+ word(thermoTypeDict.lookup("thermo")) + '<'
+ word(thermoTypeDict.lookup("equationOfState")) + '<'
+ word(thermoTypeDict.lookup("specie")) + ">>,"
+ word(thermoTypeDict.lookup("energy")) + ">";
}
else
{
FatalIOErrorInFunction(thermoDict)
<< "thermoType is in the old format and must be upgraded"
<< exit(FatalIOError);
}
Info<< "Selecting chemistry reduction method " << methodName << endl;
dictionary MRdict(dict.subDict("reduction"));
const word methodTypeName =
methodName
+ '<' + CompType::typeName + ',' + ThermoType::typeName() + '>';
word methodName =
word(MRdict.lookup("method")) + '<'
+ word(dict.subDict("chemistryType").lookup("chemistryThermo")) + ','
+ thermoTypeName + '>';
auto cstrIter = dictionaryConstructorTablePtr_->cfind(methodName);
auto cstrIter = dictionaryConstructorTablePtr_->cfind(methodTypeName);
if (!cstrIter.found())
{
FatalErrorInFunction
<< "Unknown chemistryReductionMethod type "
<< methodName << nl << nl
<< "Valid chemistryReductionMethod types :" << endl
<< dictionaryConstructorTablePtr_->sortedToc()
<< exit(FatalError);
<< "Unknown " << typeName_() << " type " << methodName << endl
<< endl;
const wordList names(dictionaryConstructorTablePtr_->toc());
wordList thisCmpts;
thisCmpts.append(word::null);
thisCmpts.append(CompType::typeName);
thisCmpts.append
(
basicThermo::splitThermoName(ThermoType::typeName(), 5)
);
wordList validNames;
forAll(names, i)
{
const wordList cmpts(basicThermo::splitThermoName(names[i], 7));
bool isValid = true;
for (label i = 1; i < cmpts.size() && isValid; ++ i)
{
isValid = isValid && cmpts[i] == thisCmpts[i];
}
if (isValid)
{
validNames.append(cmpts[0]);
}
}
FatalErrorInFunction
<< "Valid " << typeName_() << " types for this thermodynamic model "
<< "are:" << endl << validNames << endl;
List<wordList> validCmpts;
validCmpts.append(wordList(7, word::null));
validCmpts[0][0] = typeName_();
validCmpts[0][1] = "reactionThermo";
validCmpts[0][2] = "transport";
validCmpts[0][3] = "thermo";
validCmpts[0][4] = "equationOfState";
validCmpts[0][5] = "specie";
validCmpts[0][6] = "energy";
forAll(names, i)
{
validCmpts.append(basicThermo::splitThermoName(names[i], 7));
}
FatalErrorInFunction
<< "All " << validCmpts[0][0] << '/' << validCmpts[0][1]
<< "/thermoPhysics combinations are:" << endl << endl;
printTable(validCmpts, FatalErrorInFunction);
FatalErrorInFunction << exit(FatalError);
}
return autoPtr<chemistryReductionMethod<CompType, ThermoType>>

46
src/thermophysicalModels/chemistryModel/chemistryModel/TDACChemistryModel/reduction/makeChemistryReductionMethods.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2016 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2016-2017 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -27,71 +27,71 @@ License
#include "thermoPhysicsTypes.H"
#include "psiChemistryModel.H"
#include "rhoChemistryModel.H"
#include "psiReactionThermo.H"
#include "rhoReactionThermo.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// Chemistry solvers based on sensibleEnthalpy
makeChemistryReductionMethods(psiChemistryModel, constGasHThermoPhysics);
makeChemistryReductionMethods(psiChemistryModel, gasHThermoPhysics);
makeChemistryReductionMethods(psiReactionThermo, constGasHThermoPhysics);
makeChemistryReductionMethods(psiReactionThermo, gasHThermoPhysics);
makeChemistryReductionMethods
(
psiChemistryModel,
psiReactionThermo,
constIncompressibleGasHThermoPhysics
);
makeChemistryReductionMethods
(
psiChemistryModel,
psiReactionThermo,
incompressibleGasHThermoPhysics
);
makeChemistryReductionMethods(psiChemistryModel, icoPoly8HThermoPhysics);
makeChemistryReductionMethods(psiReactionThermo, icoPoly8HThermoPhysics);
makeChemistryReductionMethods(rhoChemistryModel, constGasHThermoPhysics);
makeChemistryReductionMethods(rhoChemistryModel, gasHThermoPhysics);
makeChemistryReductionMethods(rhoReactionThermo, constGasHThermoPhysics);
makeChemistryReductionMethods(rhoReactionThermo, gasHThermoPhysics);
makeChemistryReductionMethods
(
rhoChemistryModel,
rhoReactionThermo,
constIncompressibleGasHThermoPhysics
);
makeChemistryReductionMethods
(
rhoChemistryModel,
rhoReactionThermo,
incompressibleGasHThermoPhysics
);
makeChemistryReductionMethods(rhoChemistryModel, icoPoly8HThermoPhysics);
makeChemistryReductionMethods(rhoReactionThermo, icoPoly8HThermoPhysics);
// Chemistry solvers based on sensibleInternalEnergy
makeChemistryReductionMethods(psiChemistryModel, constGasEThermoPhysics);
makeChemistryReductionMethods(psiChemistryModel, gasEThermoPhysics);
makeChemistryReductionMethods(psiReactionThermo, constGasEThermoPhysics);
makeChemistryReductionMethods(psiReactionThermo, gasEThermoPhysics);
makeChemistryReductionMethods
(
psiChemistryModel,
psiReactionThermo,
constIncompressibleGasEThermoPhysics
);
makeChemistryReductionMethods
(
psiChemistryModel,
psiReactionThermo,
incompressibleGasEThermoPhysics
);
makeChemistryReductionMethods(psiChemistryModel, icoPoly8EThermoPhysics);
makeChemistryReductionMethods(psiReactionThermo, icoPoly8EThermoPhysics);
makeChemistryReductionMethods(rhoChemistryModel, constGasEThermoPhysics);
makeChemistryReductionMethods(rhoChemistryModel, gasEThermoPhysics);
makeChemistryReductionMethods(rhoReactionThermo, constGasEThermoPhysics);
makeChemistryReductionMethods(rhoReactionThermo, gasEThermoPhysics);
makeChemistryReductionMethods
(
rhoChemistryModel,
rhoReactionThermo,
constIncompressibleGasEThermoPhysics
);
makeChemistryReductionMethods
(
rhoChemistryModel,
rhoReactionThermo,
incompressibleGasEThermoPhysics
);
makeChemistryReductionMethods(rhoChemistryModel, icoPoly8EThermoPhysics);
makeChemistryReductionMethods(rhoReactionThermo, icoPoly8EThermoPhysics);
}

8
src/thermophysicalModels/chemistryModel/chemistryModel/TDACChemistryModel/reduction/makeChemistryReductionMethods.H
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2016 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2016-2017 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -54,7 +54,7 @@ License
add##chemistryReductionMethods##SS##Comp##Thermo##ConstructorToTable_;
#define makeChemistryReductionMethods(CompChemModel, Thermo) \
#define makeChemistryReductionMethods(CompChemModel, Thermo) \
\
typedef chemistryReductionMethod<CompChemModel, Thermo> \
chemistryReductionMethod##CompChemModel##Thermo; \
@ -62,7 +62,9 @@ License
defineTemplateTypeNameAndDebugWithName \
( \
chemistryReductionMethod##CompChemModel##Thermo, \
"chemistryReductionMethod<"#CompChemModel","#Thermo">", \
(word(chemistryReductionMethod##CompChemModel##Thermo::typeName_()) + \
'<' + word(CompChemModel::typeName_()) + "," + Thermo::typeName() + '>'\
).c_str(), \
0 \
); \
\

104
src/thermophysicalModels/chemistryModel/chemistryModel/TDACChemistryModel/tabulation/chemistryTabulationMethod/chemistryTabulationMethodNew.C
View File

@ -36,61 +36,81 @@ Foam::chemistryTabulationMethod<CompType, ThermoType>::New
TDACChemistryModel<CompType, ThermoType>& chemistry
)
{
IOdictionary thermoDict
(
IOobject
(
IOobject::groupName("thermophysicalProperties",dict.group()),
dict.db().time().constant(),
dict.db(),
IOobject::MUST_READ_IF_MODIFIED,
IOobject::NO_WRITE,
false
)
);
const dictionary& tabulationDict(dict.subDict("tabulation"));
word thermoTypeName;
const word methodName(tabulationDict.lookup("method"));
if (thermoDict.isDict("thermoType"))
{
const dictionary& thermoTypeDict(thermoDict.subDict("thermoType"));
thermoTypeName =
word(thermoTypeDict.lookup("transport")) + '<'
+ word(thermoTypeDict.lookup("thermo")) + '<'
+ word(thermoTypeDict.lookup("equationOfState")) + '<'
+ word(thermoTypeDict.lookup("specie")) + ">>,"
+ word(thermoTypeDict.lookup("energy")) + ">";
}
else
{
FatalIOErrorInFunction(thermoDict)
<< "thermoType is in the old format and must be upgraded"
<< exit(FatalIOError);
}
Info<< "Selecting chemistry tabulation method " << methodName << endl;
const word methodTypeName =
methodName + '<' + CompType::typeName + ',' + ThermoType::typeName()
+ '>';
dictionary tabdict(dict.subDict("tabulation"));
const word methodName =
word(tabdict.lookup("method")) + '<'
+ word(dict.subDict("chemistryType").lookup("chemistryThermo")) + ','
+ thermoTypeName + '>';
auto cstrIter = dictionaryConstructorTablePtr_->cfind(methodName);
auto cstrIter = dictionaryConstructorTablePtr_->cfind(methodTypeName);
if (!cstrIter.found())
{
FatalErrorInFunction
<< "Unknown chemistryTabulationMethodType type "
<< methodName << nl << nl
<< "Valid chemistryTabulationMethodType types :" << endl
<< dictionaryConstructorTablePtr_->sortedToc()
<< exit(FatalError);
<< "Unknown " << typeName_() << " type " << methodName << endl
<< endl;
const wordList names(dictionaryConstructorTablePtr_->toc());
wordList thisCmpts;
thisCmpts.append(word::null);
thisCmpts.append(CompType::typeName);
thisCmpts.append
(
basicThermo::splitThermoName(ThermoType::typeName(), 5)
);
wordList validNames;
forAll(names, i)
{
const wordList cmpts(basicThermo::splitThermoName(names[i], 7));
bool isValid = true;
for (label i = 1; i < cmpts.size() && isValid; ++ i)
{
isValid = isValid && cmpts[i] == thisCmpts[i];
}
if (isValid)
{
validNames.append(cmpts[0]);
}
}
FatalErrorInFunction
<< "Valid " << typeName_() << " types for this thermodynamic model "
<< "are:" << endl << validNames << endl;
List<wordList> validCmpts;
validCmpts.append(wordList(7, word::null));
validCmpts[0][0] = typeName_();
validCmpts[0][1] = "reactionThermo";
validCmpts[0][2] = "transport";
validCmpts[0][3] = "thermo";
validCmpts[0][4] = "equationOfState";
validCmpts[0][5] = "specie";
validCmpts[0][6] = "energy";
forAll(names, i)
{
validCmpts.append(basicThermo::splitThermoName(names[i], 7));
}
FatalErrorInFunction
<< "All " << validCmpts[0][0] << '/' << validCmpts[0][1]
<< "/thermoPhysics combinations are:" << endl << endl;
printTable(validCmpts, FatalErrorInFunction);
FatalErrorInFunction << exit(FatalError);
}
return autoPtr<chemistryTabulationMethod<CompType, ThermoType>>
(
cstrIter()(dict, chemistry)
);
}

46
src/thermophysicalModels/chemistryModel/chemistryModel/TDACChemistryModel/tabulation/makeChemistryTabulationMethods.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2016 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2016-2017 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -27,74 +27,74 @@ License
#include "thermoPhysicsTypes.H"
#include "psiChemistryModel.H"
#include "rhoChemistryModel.H"
#include "psiReactionThermo.H"
#include "rhoReactionThermo.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// Chemistry solvers based on sensibleEnthalpy
makeChemistryTabulationMethods(psiChemistryModel, constGasHThermoPhysics);
makeChemistryTabulationMethods(psiChemistryModel, gasHThermoPhysics);
makeChemistryTabulationMethods(psiReactionThermo, constGasHThermoPhysics);
makeChemistryTabulationMethods(psiReactionThermo, gasHThermoPhysics);
makeChemistryTabulationMethods
(
psiChemistryModel,
psiReactionThermo,
constIncompressibleGasHThermoPhysics
);
makeChemistryTabulationMethods
(
psiChemistryModel,
psiReactionThermo,
incompressibleGasHThermoPhysics
);
makeChemistryTabulationMethods(psiChemistryModel, icoPoly8HThermoPhysics);
makeChemistryTabulationMethods(psiReactionThermo, icoPoly8HThermoPhysics);
makeChemistryTabulationMethods(rhoChemistryModel, constGasHThermoPhysics);
makeChemistryTabulationMethods(rhoReactionThermo, constGasHThermoPhysics);
makeChemistryTabulationMethods(rhoChemistryModel, gasHThermoPhysics);
makeChemistryTabulationMethods(rhoReactionThermo, gasHThermoPhysics);
makeChemistryTabulationMethods
(
rhoChemistryModel,
rhoReactionThermo,
constIncompressibleGasHThermoPhysics
);
makeChemistryTabulationMethods
(
rhoChemistryModel,
rhoReactionThermo,
incompressibleGasHThermoPhysics
);
makeChemistryTabulationMethods(rhoChemistryModel, icoPoly8HThermoPhysics);
makeChemistryTabulationMethods(rhoReactionThermo, icoPoly8HThermoPhysics);
// Chemistry solvers based on sensibleInternalEnergy
makeChemistryTabulationMethods(psiChemistryModel, constGasEThermoPhysics);
makeChemistryTabulationMethods(psiReactionThermo, constGasEThermoPhysics);
makeChemistryTabulationMethods(psiChemistryModel, gasEThermoPhysics);
makeChemistryTabulationMethods(psiReactionThermo, gasEThermoPhysics);
makeChemistryTabulationMethods
(
psiChemistryModel,
psiReactionThermo,
constIncompressibleGasEThermoPhysics
);
makeChemistryTabulationMethods
(
psiChemistryModel,
psiReactionThermo,
incompressibleGasEThermoPhysics
);
makeChemistryTabulationMethods(psiChemistryModel, icoPoly8EThermoPhysics);
makeChemistryTabulationMethods(psiReactionThermo, icoPoly8EThermoPhysics);
makeChemistryTabulationMethods(rhoChemistryModel, constGasEThermoPhysics);
makeChemistryTabulationMethods(rhoReactionThermo, constGasEThermoPhysics);
makeChemistryTabulationMethods(rhoChemistryModel, gasEThermoPhysics);
makeChemistryTabulationMethods(rhoReactionThermo, gasEThermoPhysics);
makeChemistryTabulationMethods
(
rhoChemistryModel,
rhoReactionThermo,
constIncompressibleGasEThermoPhysics
);
makeChemistryTabulationMethods
(
rhoChemistryModel,
rhoReactionThermo,
incompressibleGasEThermoPhysics
);
makeChemistryTabulationMethods(rhoChemistryModel, icoPoly8EThermoPhysics);
makeChemistryTabulationMethods(rhoReactionThermo, icoPoly8EThermoPhysics);
}

4
src/thermophysicalModels/chemistryModel/chemistryModel/TDACChemistryModel/tabulation/makeChemistryTabulationMethods.H
View File

@ -57,7 +57,9 @@ License
defineTemplateTypeNameAndDebugWithName \
( \
chemistryTabulationMethod##CompChemModel##Thermo, \
"chemistryTabulationMethod<"#CompChemModel","#Thermo">", \
(word(chemistryTabulationMethod##CompChemModel##Thermo::typeName_()) + \
'<' + word(CompChemModel::typeName_()) + "," + Thermo::typeName() + '>'\
).c_str(), \
0 \
); \
\

Some files were not shown because too many files have changed in this diff Show More