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.
When running in parallel the decomposed dictionary files are read from the
case directory in either un-collated or collated format and changed dictionaries
written in the form specified by the selected fileHandler.
The instance directory of the dictionary file is obtained from the file path
argument, e.g.
mpirun -np 4 foamDictionary 0.5/U \
-entry boundaryField.movingWall.value \
-set "uniform (2 0 0)" -parallel
If the -case option is specified time is created from the case
system/controlDict enabling support for parallel operation, e.g.
mpirun -np 4 \
foamDictionary -case . 0/U -entry boundaryField.movingWall.value \
-set "uniform (2 0 0)" \
-parallel
This will read and modify the 0/U field file from the processor directories even
if it is collated. To also write the 0/U file in collated format the collated
fileHandler can be specified, e.g.
mpirun -np 4 \
foamDictionary -case . 0/U -entry boundaryField.movingWall.value \
-set "uniform (2 0 0)" \
-fileHandler collated -parallel
This provides functionality for field manipulation equivalent to that provided
by the deprecated changeDictionary utility but in a more flexible and efficient
manner and with the support of fileHandlers for collated parallel operation.
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
Added support for patchwise evaluation of surface tension to the
phaseSystem.
Filled out submodel interfaces to make it easier to add new models.
Made submodel parameters user modifiable in LemmertChawla model.
Added Kocamustafaogullari-Ishii nucleation site density and departure
frequency models and renamed the existing KocamustafaogullariIshii
departure diameter model to KocamustafaogullariIshiiDepartureDiameter.
Relaxation is now also applied to the quenching heat flux to be
consistent with the evaporative heat flux.
Improved iteration loop diagnostics. The maximum wall temperature change
on the last iteration is printed out if the maximum number of iterations
(10) is reached.
Patch contributed by Juho Peltola, VTT.
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.
Added limiters for the phase temperatures to prevent divergence, and
monitors to report the minimum and maximum values. Removed the
setTimeStep functionObject as the temperature limiters make this
unnecessary. Dereased the number of energy correctors and set a higher
Courant number limit to reduce the execution-time of the case.
Patch contributed by Juho Peltola, VTT.
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.
Refactored the function for scaling the size group volume fractions to
better handle situations in which their sum drifts away from unity.
Scaling is now turned on by default, and can be turned off in the
solution dictionary for the population balance.
Additional revision and renaming of *Polydisperse tutorials
Patch contributed by Institute of Fluid Dynamics,
Helmholtz-Zentrum Dresden - Rossendorf (HZDR)
Removed unnecessary clutter in header descriptions for models that are
only required for testing purposes.
Patch contributed by Institute of Fluid Dynamics,
Helmholtz-Zentrum Dresden - Rossendorf (HZDR)
This fix also required a generalization of the corresponding base class,
which allows the user to specify the number of daughter particles per
breakup event separately.
Patch contributed by Institute of Fluid Dynamics,
Helmholtz-Zentrum Dresden - Rossendorf (HZDR)
Following this commit, a coalescence event leading to a size larger than
that of the last size group is not discarded anymore, but leads to an
accumulation of volume fraction in the last size group.
Patch contributed by Institute of Fluid Dynamics,
Helmholtz-Zentrum Dresden - Rossendorf (HZDR)
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);
}
}
