by introducing a new specialised type, variable, derived from word with
additional valid characters. This avoids some complex type-juggling in the
parser and keyType in which string was used to represent either a string or a
variable.
solidChemistryModel is not implemented in a general way but specialised to form
the basis of the highly specific pyrolysis mode. The handling of reactions is
hard-coded for forward reactions only, the Jacobian was present but incomplete
so any ODE solvers requiring the Jacobian would either fail, diverge or produce
incorrect results. It is not clear if many or any parts of the
solidChemistryModel are correct, in particular there is no handling for the
solid surface area per unit volume. After a lot of refactoring work it has
become clear that solidChemistryModel needs a complete rewrite and can benefit
from all the recent development work done on the now more general
StandardChemistryModel.
Both the functionObject call context (the command line for postProcess, and the
controlDict path for run-time post-precessing) and the configuration file
context where the arguments are substituted are now printed in the error
message, e.g.
postProcess -func 'patchAverage(name=inlet, ields=(p U))'
generates the message
--> FOAM FATAL IO ERROR:
Essential value for keyword 'fields' not set in function entry
patchAverage(name=inlet, ields=(p U))
in command line postProcess -func patchAverage(name=inlet, ields=(p U))
Placeholder value is <field_names>
file: /home/dm2/henry/OpenFOAM/OpenFOAM-dev/etc/caseDicts/postProcessing/surfaceFieldValue/patchAverage from line 13 to line 17.
and with the following in controlDict
functions
{
#includeFunc patchAverage(name=inlet, ields=(p U))
}
generates the message
--> FOAM FATAL IO ERROR:
Essential value for keyword 'fields' not set in function entry
patchAverage(name=inlet, ields=(p U))
in file /home/dm2/henry/OpenFOAM/OpenFOAM-dev/tutorials/incompressible/pimpleFoam/RAS/pitzDaily/system/controlDict at line 55
Placeholder value is <field_names>
file: /home/dm2/henry/OpenFOAM/OpenFOAM-dev/etc/caseDicts/postProcessing/surfaceFieldValue/patchAverage from line 13 to line 17.
MPPIC requires significant extension for damping and packing modelling
to work on moving meshes. At present the predictor-corrector process
used by these models does not maintain a consistent time-state relative
to a moving mesh. The cloud needs to enact the correction track from the
original starting point, rather than from the end of the non-corrected
track. This will require additional tracking or storage and
communication steps.
Resolves bug report https://bugs.openfoam.org/view.php?id=3318
adding support for argument substitution into sub-dictionaries for
e.g. pressureDifferencePatch, white space before, in and after the argument list
and continuation lines, for example:
functions
{
#includeFunc flowRatePatch(name=inlet)
#includeFunc flowRatePatch ( name = outlet )
#includeFunc pressureDifferencePatch \
( \
patch1 = inlet, \
patch2 = outlet \
)
#includeFunc yPlus
#includeFunc residuals
}
This provides a virtual layer for which to evaluate properties of
individual species, across the entire domain. This is necessary when
computing the properties of reactions and phase changes, and this
provides a means of doing so without templating the sub-modelling on the
thermodynamics type, or performing an inefficient cell-loop over the
equivalent scalar methods.
Absolute enthalpy functions have also been added into basicThermo and
heThermo. Again, this information is likely to be necessary when
computing thermal aspects of phase changes.
A number of templated generic property calculation methods have also
been implemented in heThermo, and the various specific functions
rewritten in terms of them. This has removed the duplication of the code
associated with constructing the field types.
kappa is now obtained from the fluidThermo for laminar regions, the turbulence
model for turbulent regions and the solidThermo for solid regions. The "lookup"
option previously supported allowed for energy-temperature inconsistent and
incorrect specification of kappa and was not used. Without this incorrect
option there is now no need to specify a kappaMethod thus significantly
simplifying the use boundary conditions derived from temperatureCoupledBase.
Added new reaction rate fluxLimitedLangmuirHinshelwoodReactionRate which is a
variant of the standard LangmuirHinshelwoodReactionRate but with a surface flux
limiter dependent on the surface area per unit volume Av which can be supplied
either as a uniform value or a field name which is looked-up from the region
database (objectRegistry).
Description
Langmuir-Hinshelwood reaction rate for gaseous reactions on surfaces
including the optional flux limiter of Waletzko and Schmidt.
References:
\verbatim
Hinshelwood, C.N. (1940).
The Kinetics of Chemical Change.
Oxford Clarendon Press
Waletzko, N., & Schmidt, L. D. (1988).
Modeling catalytic gauze reactors: HCN synthesis.
AIChE journal, 34(7), 1146-1156.
\endverbatim
Now that the reaction system is separated from the mixture thermodynamics it is
possible to rationalise singleStepCombustion so that it instantiates a single
reaction as it should. This simplifies the code, maintenance and the user
interface not that the combustionProperties file contains a single reaction
rather than a list.
This allows much greater flexibility in the instantiation of reaction system
which may in general depend on fields other than the thermodynamic state. This
also simplifies mixture thermodynamics removing the need for the reactingMixture
and the instantiation of all the thermodynamic package combinations depending on
it.
which are now read directly from the thermophysicalProperties dictionary for
consistency with non-reacting mixture thermodynamics. The species thermo and
reactions lists can still be in separate files if convenient and included into
the thermophysicalProperties file using the standard dictionary #include.
This formalises the flexible and extensible OpenFOAM thermodynamics and reaction
format as the direct input to OpenFOAM solvers. The CHEMKIN format is still
supported by first converting to the OpenFOAM format using the chemkinToFoam
utility.
In chemistryModel "li" is set to the current cell index but for other reacting
systems it should be set to the current index of the element for which the
reaction system is being evaluated.
In the ODESolver "li" is the current index of the element for which the ODE
system is being solved if there is a list of related systems being solved,
otherwise it can be set to 0.
The various temporary fields used to create the nuTilda equation sources are now
internal fields to avoid unnecessary evaluation of boundary conditions, lowering
storage and reducing CPU time, particularly when running in parallel. These
temporary fields are now named with respect to the model so that they can be
cached conveniently and written as required.
The LESRegion field can now be contructed on demand if it is requested as a
cached temporary field and written out for diagnostics if needed, for example in
the tutorials/incompressible/pisoFoam/LES/motorBike tutorial:
cacheTemporaryObjects
(
SpalartAllmarasDDES:LESRegion
);
functions
{
writeCachedObjects
{
type writeObjects;
libs ("libutilityFunctionObjects.so");
writeControl writeTime;
writeOption anyWrite;
objects
(
SpalartAllmarasDDES:LESRegion
);
}
#include "cuttingPlane"
#include "streamLines"
#include "forceCoeffs"
}
which provides a very convenient mechanism to process and write any temporary
fields created during a time-step, either within models the construction of
equations and matrices or any other intermediate processing step within an
OpenFOAM application. The cached fields can relate to physical properties in
models, e.g. the generation term or other terms in the turbulence models, or
numerical, e.g. the limiters used on convection schemes. This mechanism
provides a new very powerful non-intrusive way of analysing the internals of an
OpenFOAM application for diagnosis and general post-processing which cannot be
easily achieved by any other means without adding specific diagnostics code to
the models or interest and recompiling.
For example to cache the kEpsilon:G field in
tutorials/incompressible/simpleFoam/pitzDaily add the dictionary entry
cacheTemporaryObjects
(
grad(k)
kEpsilon:G
);
to system/controlDict and to write the field add a writeObjects entry to the
functions list:
functions
{
writeCachedObjects
{
type writeObjects;
libs ("libutilityFunctionObjects.so");
writeControl writeTime;
writeOption anyWrite;
objects
(
grad(k)
kEpsilon:G
);
}
#includeFunc streamlines
}
If a name of a field which in never constructed is added to the
cacheTemporaryObjects list a waning message is generated which includes a useful
list of ALL the temporary fields constructed during the time step, e.g. for the
tutorials/incompressible/simpleFoam/pitzDaily case:
--> FOAM Warning : Could not find temporary object dummy in registry region0
Available temporary objects
81
(
(((0.666667*C1)-C3)*div(phi))
div(phi)
(interpolate(nuEff)*magSf)
surfaceIntegrate(phi)
(interpolate(DepsilonEff)*magSf)
((interpolate(((1|((1|(1|A(U)))-H(1)))-(1|A(U))))*snGrad(p))*magSf)
grad(p)
((interpolate(nuEff)*magSf)*snGradCorr(U))
(interpolate((1|((1|(1|A(U)))-H(1))))*magSf)
((1|((1|(1|A(U)))-H(1)))-(1|A(U)))
((Cmu*sqr(k))|epsilon)
interpolate(HbyA)
interpolate(DkEff)
interpolate(U)
phiHbyA
weights
div(((interpolate((1|((1|(1|A(U)))-H(1))))*magSf)*snGradCorr(p)))
(phiHbyA-flux(p))
MRFZoneList:acceleration
average(interpolate(max(epsilon,epsilonMin)))
div(((interpolate(DepsilonEff)*magSf)*snGradCorr(epsilon)))
nuEff
kEpsilon:G
grad(k)
interpolate((1|((1|(1|A(U)))-H(1))))
(nuEff*dev2(T(grad(U))))
grad(U)
interpolate(epsilon)
(phi*linearUpwind::correction(U))
((interpolate(DepsilonEff)*magSf)*snGradCorr(epsilon))
grad(k)Cached
(HbyA-((1|((1|(1|A(U)))-H(1)))*grad(p)))
pos0(phi)
-div((nuEff*dev2(T(grad(U)))))
H(1)
interpolate(k)
((nut|sigmak)+nu)
snGrad(p)
(0.666667*div(phi))
surfaceIntegrate(((interpolate((1|((1|(1|A(U)))-H(1))))*magSf)*snGradCorr(p)))
DepsilonEff
(1|A(U))
surfaceIntegrate(((interpolate(DepsilonEff)*magSf)*snGradCorr(epsilon)))
limitedLinearLimiter(epsilon)
surfaceIntegrate(((interpolate(DkEff)*magSf)*snGradCorr(k)))
grad(epsilon)
(interpolate(DkEff)*magSf)
div(((interpolate(DkEff)*magSf)*snGradCorr(k)))
surfaceSum(magSf)
((1|A(U))-(1|((1|(1|A(U)))-H(1))))
(1|((1|(1|A(U)))-H(1)))
((interpolate((1|((1|(1|A(U)))-H(1))))*magSf)*snGradCorr(p))
mag(div(phi))
surfaceSum((magSf*interpolate(max(epsilon,epsilonMin))))
interpolate(DepsilonEff)
-grad(p)
snGradCorr(p)
interpolate(p)
interpolate(max(epsilon,epsilonMin))
dev(twoSymm(grad(U)))
surfaceIntegrate((phi*linearUpwind::correction(U)))
(magSf*interpolate(max(epsilon,epsilonMin)))
limitedLinearLimiter(k)
(nut+nu)
HbyA
max(epsilon,epsilonMin)
surfaceIntegrate(((interpolate(nuEff)*magSf)*snGradCorr(U)))
surfaceIntegrate(phiHbyA)
DkEff
(((C1*kEpsilon:G)*epsilon)|k)
(mag(S)+2.22507e-308)
(((1|A(U))-(1|((1|(1|A(U)))-H(1))))*grad(p))
((nut|sigmaEps)+nu)
((interpolate(DkEff)*magSf)*snGradCorr(k))
(nut*(dev(twoSymm(grad(U)))&&grad(U)))
interpolate(nuEff)
((C2*epsilon)|k)
interpolate((nuEff*dev2(T(grad(U)))))
(epsilon|k)
div(phiHbyA)
div(((interpolate(nuEff)*magSf)*snGradCorr(U)))
)
Multiple regions are also supported by specifying individual region names in a
cacheTemporaryObjects dictionary, e.g. in the
tutorials/heatTransfer/chtMultiRegionFoam/heatExchanger case
cacheTemporaryObjects
{
air
(
kEpsilon:G
);
porous
(
porosityBlockage:UNbr
);
}
functions
{
writeAirObjects
{
type writeObjects;
libs ("libutilityFunctionObjects.so");
region air;
writeControl writeTime;
writeOption anyWrite;
objects (kEpsilon:G);
}
writePorousObjects
{
type writeObjects;
libs ("libutilityFunctionObjects.so");
region porous;
writeControl writeTime;
writeOption anyWrite;
objects (porosityBlockage:UNbr);
}
}
which constructs the name for a field property associated with the model by
pre-pending the given field name with <modelType>: e.g. the generation term in
the kEpsilon model is named kEpsilon:G
The filtering level for an iso-surface can now be selected. The keyword
is "filtering", and the options are "full", "partial" or "none". The
default is "full". The other options are only retained for debugging and
to provide a fallback if robustness of the full filtering algorithm is
an issue. As of commit 2ee8b7ac, "full" filtering has no known
disadvantages and is recommended in all usage cases.
This setting replaces the "regularise" entry, which switched between
what are now the "full" and "none" settings. "partial" was not
previously an option.
This is a slight rework of commit c81abfef. Instead of adapting tet
base points cell-by-cell, the dangling points are pre-computed and then
the adaptations to the base points are made face-by-face. This correctly
adapts faces which have different dangling points relative to the owner
and neighbour cells.
