The phase systems tables for multiphase solvers create conflict
between each other as they are defined in the same namespace and using
similar class names.
Therefore a special htc function object for reactingEulerSolver was
added (reactingEulerHtcModel), located under
src/phaseSystemModels/reactingEulerFoam/functionObjects/
This commit includes the following:
- Relocate solvers/reactingEulerFoam functionObjects to
src/phaseSystemModels
- Remove links for fieldFunctionObject to multiphase libs to avoid
conflicts
- New FO for htc for reactingEulerFoam called reactingEulerHtcModel
- previously introduced `getOrDefault` as a dictionary _get_ method,
now complete the transition and use it everywhere instead of
`lookupOrDefault`. This avoids mixed usage of the two methods that
are identical in behaviour, makes for shorter names, and promotes
the distinction between "lookup" access (ie, return a token stream,
locate and return an entry) and "get" access (ie, the above with
conversion to concrete types such as scalar, label etc).
- Favour use of argList methods that are more similar to dictionary
method names with the aim of reducing the cognitive load.
* Silently deprecate two-parameter get() method in favour of the
more familiar getOrDefault.
* Silently deprecate opt() method in favour of get()
These may be verbosely deprecated in future versions.
- before (-lreactingPhaseSystem -ltwoPhaseReactingTurbulenceModels)
after (-ltwoPhaseReactingTurbulenceModels -lreactingPhaseSystem)
to fix symbol resolution issue on clang.
- similar to the behaviour of std::ignore and consistent with the
no input / no output nature of nullObject. Similarly accept a
const reference for its Istream operator.
- make most nullObject methods constexpr
- mostly wraps std::chrono so can inline much of it, which is potentially
helpful when used for inner timings.
- add elapsedTime() method for direct cast to double and for
naming similarity with wall-clock method.
Potential breaking change (minor):
- clockValue construct with a bool parameter is now simply tagged
dispatch (value is ignored) and always queries the current clock
value. This avoids needless branching.
Since this constructor form has primarily been used internally (eg,
clockTime), breakages in user code are not expected.
- have printBuildInfo output to std::ostream
- removed extraneous include "stdFoam.H"
ENH: revert to pre-processor defines for hard-coded paths (#1712)
- redundant information, but more robust at run-time without relying
on initialization order
- previously could only run from the project directory
- strip surrounding double quotes on input of path names
since they are added automatically when editing.
- previously relied on presence/absence of command-line options.
Can now explicitly disable individually
- provide shorter constructors for dealing with these types of cases.
Make construction with non-default names for "system" and "constant"
lengthier so there is no ambiguity.
multiphaseReactingTurbulenceModels and twoPhaseReactingTurbulenceModels
add models to the same table TurbulenceModel. These two libs were removed
from libreactingPhaseSystem which created the conflict.
The multiphaseReactingTurbulenceModels was added to
reactingMultiPhaseEulerFoam solver and twoPhaseReactingTurbulenceModels to
twoPhaseReactingEulerFoam solver
The FO heatTransferCoeffs for libfieldFunctionObjects needs
twoPhaseReactingTurbulenceModels.
These change avoids linking conflict from multiphaseReactingTurbulenceModels
and twoPhaseReactingTurbulenceModels being linked in the same lib.
- Provide Allwmake-mpi scripts for handling the MPI-only build segment.
- Adjust Make/options to support a FOAM_MPI_LIBBIN target location.
This will simply default to FOAM_LIBBIN/FOAM_MPI, but allows different
types of builds with out-of-tree targets.
Example,
Build OpenFOAM with default MPI settings (eg, system openmpi)
```
./Allwmake
```
Rebuild MPI-layers with different MPI.
For any given and known type
```
othermpi()
{
export WM_MPLIB=OPENMPI
export FOAM_MPI=openmpi-3.1.3
export OPAL_PREFIX=$WM_THIRD_PARTY_DIR/platforms/$WM_ARCH$WM_COMPILER/$FOAM_MPI
export MPI_ARCH_PATH="$OPAL_PREFIX"
}
```
May wish to build/rebuild ptscotch
```
(
othermpi
$WM_THIRD_PARTY_DIR/makeSCOTCH
)
```
Rebuild the mpi-dependent parts. Can also provide install location
```
for script in $(find src -name Allwmake-mpi)
do
(
other_mpi
export FOAM_MPI_LIBBIN="$HOME/tmp/install-prefix/lib/$FOAM_MPI"
)
done
```
The final leak can only be decided once all cells have been
deleted. So only exit on final invocation and give warning-only
beforehand. This avoids a lot of false positives.
The tutorial itself didn't actually produce a mesh with leakage
with the old settings. Upped the refinement level to force it
to go through the hole in the geometry.
- scripts/wmake.wmake-args partial logic for Allwmake scripts.
- handle '-quiet' as synonym for '-silent'
- Do not specify '-j' option for wrapped cmake creation to avoid
the warning:
make[1]: warning: -jN forced in submake: disabling jobserver mode.
ENH: defaulting for destructors where possible
STYLE: clear() instead of setSize(0) for plain Lists
STYLE: use bool operator instead of valid()/empty() for autoPtr tests
- enumerated values are (points | topology) which can be optionally
specified in the blockMeshDict. Default is 'topology'.
If the command-line option `blockMesh -merge-points` is specified,
this has absolute priority over any blockMeshDict entry.
STYLE: changed blockMesh "-blockTopology" option to "-write-obj"
- this is more specific to what it does. Potentially wish to add a
"-write-vtk" option in the future.
TUT: adjust tutorials to use preferred or necessary merge strategies:
* channel395DFSEM - topology
* nozzleFlow2D - points
* pipeCyclic - points
- dependency handling relocated from cmakeFunctions to wmakeFunctions
and reused for mpi-versioned builds. This allows more checks for
configuration parameters and removes hard-code build path
information.
CONFIG: remove spurious mplibHPMPI entries
CONFIG: remove ADIOS1 rules (antiquated)
- initial split of wmake-related commands into "plumbing" and
"porcelain" akin to how git handles things.
- wmakeBuildInfo (very low-level), now relocated to the wmake/scripts
and accessible for the user as "wmake -build-info".
This satisfies a long-standing desire to access build information
in a fashion similar to the api/patch information.
CONFIG: avoid git information when building with a debian/ directory
- when a 'debian/' directory exists, there is a high probability that
the '.git/' directory is from debian and not from OpenFOAM (ie,
useless here). This corresponds to an implicit '-no-git', which has
no effect when building from pristine sources.
ENH: wmakeCheckPwd becomes scripts/wmake-check-dir
- accessible for the user as "wmake -check-dir" and with 1 or 2
directory names. A wmakeCheckPwd symlink left for compatibility.
- less frequently used, but the information was previously inaccessible
under etcFiles.C.
Now exposed within the foamVersion namespace and defined under
<global.Cver> to improve configuration possibilities.
- convenient way to use alternative plugin installations
- provide separate -help-build information and reduce the noisy output
when a reader module cannot be located.
- adds into the include-quoted search list instead the general (-Idir)
search list.
* makes it less subject to ordering (since it will now generally be
searched first) and makes it less subject to how duplicate removal
is implemented. In some compilers (#1627), the last instance of
a duplicate directory would be used and not the first instance.
* removes clutter in some Make/options files
COMP: add missing linkage libraries
- improve handling of changes in ParaView/VTK or cmake parameters (#1693)
* adjust internals to support recording of an unlimited number of
configuration parameters and use file `cmp` instead of trying
to check strings ourselves.
ENH: new wmake/scripts/wmake.cmake-args handler
- additional handling of -prefix=... as CMAKE_INSTALL_PREFIX export.
- in some contexts, can use instead of AllwmakeParseArguments
- this specifically arises in the case we have used the `#eval` syntax
to generate a value.
However, since the expressions produce scalar/vector/tensor etc, the
tokenized value will *not* be introduced into the dictionary as a
label, even if it appears to be an integer value.
Eg, eval "2*5", eval "sqrt(100)" both yield `scalar(100)`, which
will not be suitable for any consumer expecting a label value.
With the `#calc` version, this problem is glossed over since it uses a
string buffer for the output (which can suppress the decimal)
and re-parses the string into tokens, which causes a label to be
recognized.
- Since we obviously already support implicit handling of ints as
floats (when reading), now also allow conversion of float
representations of integral values.
Uses the ad hoc value of 1e-4 for deciding if the value deviates too
far from being integral.
- As a side-effect, can now also support scientific notation when
specifying integers. Eg, (10 100 1e+3) for cell counts.
- simplified templating, which cleans up code and does not appear to
break any normal user coding.
ENH: unique_ptr instead of homegrown demand-driven handling.
For a given point within a given mesh, the existing `meshWave` method gives
the orthogonal distance to a patch. In meshes with very steep terrain (e.g.
a hill of 90 [deg], this might be problematic for the fields that require
the distance to the patch associated with the terrain surface.
`directionalMeshWave` is a variant of `meshWave` distance-to-patch method,
which ignores the component in the specified direction. Can be used e.g. to
calculate the distance in the z-direction only.
TUT: add example of directionalMeshWave to mesh/moveDynamicMesh/SnakeCanyon
Requirement by CENER
Implementation by Mattijs Janssens
- takes a search string and a replacement character.
The replacement character can also be a nul char ('\0'), which
simply removes the characters.
Possible uses:
* Replace reserved characters
str.replaceAny("<>:", '_');
* Remove shell meta-characters or reserved filesystem characters
str.replaceAny("*?<>{}[]:", '\0');
- construct from dimensioned/value, defaulting name from value.
Can be convenient for these type of operations:
max(.., dimensionedScalar(somedims, 0.5))
- construct from dimensioned/one, forwarding to pTraits::one.
Can be convenient for constructors:
volScalarField( ..., dimensionedScalar(somedims, one{}))
ENH: minor updates to zero/one classes.
- add global 'One' constant for symmetry with 'Zero'.
- clearer than passing a reference to a dummy variable,
or relying on move occuring within the copy constructor
(historical, but should be deprecated)
STYLE: consistent autoPtr syntax for uncollated file operations
- can help in circumstances when an zero-sized entry is written on
some processors, but the compound-type may be useful for determining
a particular code path when re-reading the files. Ensures that the
information is consistent on all processors.
STYLE: adjust separation of includes between List.H and UList.H
- bin/tools/create-mpi-config to query/write values for system openmpi.
In some cases this can be used to avoid an mpicc requirement at runtime.
- adjust openfoam session to include -test-tutorial forwarding to the
tutorials/AutoTest. This helps with writing installation tests.
- adjust foamConfigurePaths to latest version
- removal of gperftools default config, as per develop
1) Add interfaceHeatResistance model to icoReactingMultiphaseInterFoam
This model uses a spread source for the continuity Eq.
It is recommended for cases with good mesh resolution.
2) Adding iso-surface type of calculation for the interface for
the kineticGasEvaporation model
3) Add switch for option to take into account volume change
4) Add poolEvaporation tutorial
- remove MSWindows components (code and makefiles)
- use cxx, hxx extensions to reduce possible confusion with other
"list" and "vector" classes
- use C++ versions for C headers
- align wmake have_* scripts to support version query as per current
develop branch
- use config.sh/ fallbacks when the corresponding *_ARCH_PATH is empty
(eg, BOOST, CGAL, FFTW).
This aids when building outside of the regular OpenFOAM environment.
- add '[-+.~]' to the recognized qualifiers.
This allows simple readable names such as
WM_COMPILER=Clang-vendor
but also opens the FUTURE (not yet supported) possibility of
combining in additional information. For example,
WM_COMPILER=Clang~openmp
WM_COMPILER=Clang+cuda~openmp
by using '+' (add) and '~' (subtract) notation similar to what
spack uses.
CONFIG: support 'override' rules
- if present, compiler-family 'override' rules are included after
compiler-family 'general' rules have been included. This allows a
central means for including dynamically generated content to
override some values.
Some examples:
To handle different gcc versions (system compiler):
wmake/rules/...Gcc/override
```
ifneq (,$(findstring 9, $(WM_COMPILER)))
cc := gcc-9
CC := g++-9 -std=c++11
endif
```
To handle different openmp on Darwin (#1656):
wmake/rules/darwin64Clang/override
```
# Use libomp (not libgomp) unless openmp is disabled
ifeq (,$(findstring "~openmp", "$(WM_COMPILER)"))
COMP_OPENMP = -DUSE_OMP -Xpreprocessor -fopenmp
LINK_OPENMP = -lomp
else
include $(GENERAL_RULES)/no-openmp
endif
```
This treatment arguably fits into wmake/rules/darwin64Clang/general,
but it serves to illustrate a possible use case.
1) The sign of radiative flux (qr) for modes Power and HeatFlux was
corrected.
2) Relaxation factor implementation was incomplete. Now caching
valueFraction and refValue from the previous time step.
- use Clang instead of Gcc for Darwin since this is its system
compiler. The user can force use of Gcc by using Gcc92 etc.
- make etc/cshrc sed check more robust.
- replace tcsh (${%var}) syntax with ("${var}" != "")
[Fixes and ideas from Alexey Matveichev]
CONFIG: do not source the gperftools environment by default
- this is now an used feature, but can be re-enabled by advanced users
if required.
- as a side-effect of recent changes, command-line stripping of .gz
extensions on input was lost. For example,
OK: surfaceTransformPoints file.stl ...
Fail: surfaceTransformPoints file.stl.gz ...
- restore the previous behaviour of silently stripping the '.gz'
extension on input.
ENH: add triSurface::New selector entry point
- for symmetry with MeshedSurface
Now the thermal baffle can be extrapolated from a patch which is
coupled to the bottom patch of the solid region.
The user can set the T bc on the 'top' patch of the solid.
The new keyword is 'internal' and its default is true. Check new
tutorial for an example:
tutorials/heatTransfer/buoyantSimpleFoam/roomWithThickCeiling/
- reads/write shell elements
Output elements are "bunched" according to type and their set
without reordering.
- preliminary reading of solids without extraction.
Handling of *Surface specifications is not implemented
- enhancement and potential breaking change.
Nastran surface writer previously used the keyword 'scale' for
field scaling, which was applied uniformly to all output fields.
Change the meaning of 'scale' to be geometric scaling
(consistent with reading triSurfaceMesh etc).
New 'fieldScale' entry is an optional dictionary of scaling
parameters.
Example,
nastran
{
scale 1000; // [m] -> [mm]
fieldScale
{
"p.*" 0.01; // [Pa] -> [mbar]
}
}
- adjustments to internal handling to improve run-time addition of
other formats (eg, with additional user library)
For example, to write a binary STL with a '.stl' extension:
$ surfaceMeshConvert input.obj -write-format stlb output.stl
Or in a sampler,
to specify the input type without ambiguity:
surf
{
type meshedSurface;
surface sampling.inp;
fileType starcd;
scale 0.001;
...
}
STYLE: regularize naming for input/output scaling
* -read-scale (compat: -scaleIn)
* -write-scale (compat: -scaleOut)
CONFIG: change edge/surface selection name for STARCD format
- now select as "starcd" instead of "inp" to avoid naming ambiguity
with abaqus
- had a PrimitivePatch with SubField, but now use const pointField&.
There is no derivation path from a pointIOField to SubField<point>,
so a const reference makes more sense.
- face_type, point_type (similar to STL value_type, etc).
The naming avoids potential confusion with template parameters.
- rename private typedef from ParentType to MeshReference for more
consistency with polySurface etc.
- regression introduced by 431c9632f9
The triSurface dictionary constructor applies the scaling,
and thus it can be reported, but not applied in triSurfaceMesh
- previously used a Pstream::exit() invoked from the argList
destructor to handle all MPI shutdown, but this has the unfortunate
side-effect of using a fixed return value for the program exit.
Instead use the Pstream::shutdown() method in the destructor and allow
the normal program exit codes as usual. This means that the
following code now works as expected.
```
argList args(...);
if (...)
{
InfoErr<< "some error\n";
return 1;
}
```
- preferentially handle Allwmake.override, which allows packaging
tools to define alternative make scripts, or selectively disable
components.
- remove legacy handling of 'Optional' directory.
Conditionals have since migrated into scripts themselves and/or
use the wmake/scripts/have_* framework.
BUG: missed passing -debug for Allwmake scripts
- missed detection of system libraries when installed with multiarch
paths like /usr/lib/x86_64-linux-gnu
CONFIG: improve handling of group/user config files (#928)
- changed bashrc handling of FOAM_CONFIG_NOUSER to use
FOAM_CONFIG_MODE instead. Propagate into foamEtcFile to make this
a stickier control.
This change allows better control, but also enables cluster
installations to define their own value within the OpenFOAM prefs.sh
file to prevent users accidentally mis-configuring things if
necessary.
- remove undocumented handling of an (a)ll mode in foamEtcFile to
avoid potential pitfalls.
- add support for FOAM_CONFIG_ETC handling.
This allows injection of an extra search layer when finding
project etc files
ENH: improvements to foamConfigurePaths (#928)
- handle FOAM_CONFIG_ETC implicitly, or explicitly with the new
-etc option.
STYLE: more explicit wording in foamConfigurePaths usage (#1602)
- document that an absolute path (eg, -scotch-path) overrides/ignores
the equivalent ThirdParty setting (eg, -scotch)
- longer options -system-compiler and -third-compiler for -system
and -third, respectively. Clearer as to their purpose.
- adjust the location sanity check to look for META-INFO directory.
- '-c' option (as per shell), '-Dkey[=value]' option to provide
preferences via the command-line. For example,
etc/openfoam -DWM_COMPILER=Clang -int64 ./Allwmake -j -s -l
These can also be combined with other options. Eg,
etc/openfoam -DWM_COMPILER=Clang \
-c 'wmake -show-path-cxx -show-cxxflags'
- relocated from bin/tools/ => etc/ for easier access
- bin/tools/openfoam.in : for autoconfig-style installation
- Auto-detect if the shell script was executed with openfoam and
interpret accordingly.
Simple example,
--------------
#!/usr/bin/openfoam
cd "${0%/*}" || exit # Run -*-sh-*- from this dir
blockMesh
simpleFoam
--------------
Note it is NOT currently possible to provide any other parameters
this way. Eg,
`#!/usr/bin/openfoam -sp` (NOT)
This will either fail to run, or result in infinite recursion.
- base level surface container is now a meshedSurface instead of
a triSurface. This avoid automatic triangulation of surfaces
when they are read, and simplifies the internals.
- sampling types:
* "meshedSurface" (compat: "sampledTriSurfaceMesh")
* "meshedSurfaceNormal" (compat: "sampledTriSurfaceMeshNormal")
- uses MeshedSurface instead of triSurface to prevent automatic
triangulation.
- supports '-patches' and '-excludePatches' controls as per foamToVTK.
For example,
surfaceSplitByPatch -patches '( ".*rider.*" )' motorBike.obj
ENH: use MeshedSurface for surfaceSubset
- removed swapZones method (unused, potentially fragile)
- add subsetMesh by name
BUG: incorrect zone assignment in MeshedSurface::subsetMesh
- used the new (zero-sized) zone when determining the old zone ending
instead of the original zone bounds.
- refactor logic from triSurfaceMesh for triSurface, MeshedSurface,
UnsortedMeshedSurface.
Makes it easier to locate and use surface files without the
triSurfaceMesh (meshTools) infrastructure.
STYLE: remove unused sampledTriSurfaceMesh constructors
Often we want to copy a field and replace boundary conditions, e.g. change type
to calculated for some patches. This has typically been achieved by creating a
word list of new patch types which are then fed through to the fvPatchField::New
factory method. This is OK for types that require no additional input (usually
from dictionary) but leaves other more complex types partially
constructed/usable.
The new constructor clones all BCs except those with indices specified, for
which the fvPatchField::New method is called for the supplied patch field type.
- avoid face copying.
Maintain separate offsets/list for non tri/quad face decomposition,
which eliminates copying for tri/quad types that represent the bulk
of geometries
- report inappropriate use of PLOAD2 for higher-ranks only once per
field instead of per face. For this case, write its magnitude
instead of 0.
- perform field output scaling prior to calling the write face
function. This will make it easier to handle different per-field
scaling in the future (#1612)
BUG: nastran quad written as "CTRIA3" instead of "CQUAD4"
- missed detection of system libraries when installed with multiarch
paths like /usr/lib/x86_64-linux-gnu
CONFIG: improve handling of group/user config files (#928)
- changed bashrc handling of FOAM_CONFIG_NOUSER to use
FOAM_CONFIG_MODE instead. Propagate into foamEtcFile to make this
a stickier control.
This change allows better control, but also enables cluster
installations to define their own value within the OpenFOAM prefs.sh
file to prevent users accidentally mis-configuring things if
necessary.
- remove undocumented handling of an (a)ll mode in foamEtcFile to
avoid potential pitfalls.
- add support for FOAM_CONFIG_ETC handling.
This allows injection of an extra search layer when finding
project etc files
ENH: improvements to foamConfigurePaths (#928)
- handle FOAM_CONFIG_ETC implicitly, or explicitly with the new
-etc option.
STYLE: more explicit wording in foamConfigurePaths usage (#1602)
- document that an absolute path (eg, -scotch-path) overrides/ignores
the equivalent ThirdParty setting (eg, -scotch)
- longer options -system-compiler and -third-compiler for -system
and -third, respectively. Clearer as to their purpose.
- adjust the location sanity check to look for META-INFO directory.
- string expansions have supported "${var:-default}" syntax for
several versions, but this did not apply plain dictionary expansions.
Eg, the following did not parse
massFlow ${entry1:-100};
ENH: remove content and length restriction on '${..}' quoted variables
- allows this type of content:
velocity2 ${velocity1:- ( 0 -100 10) };
- accept empty parameter strings for entries. This allows the
following expansion to work as expected:
hex (n1 n2..) ${inletBlock:-} (10 10 10) simpleGrading (1 1 1)
ie, optionally define the cellZone name for a given block
ENH: add single parameter dictionary writeEntry method.
- the dictionary knows its own name (dictName), which can be used
when writing content
Style changes:
- use std algorithm for some stringOps internals
- pass SubStrings iterators by const reference
ENH: special nullptr handling for ISstream getLine
- pass through to istream::ignore to support read and discard
1) Adding interfaceHeight FO
2) Adding interfaceHeatResistance mass transfer model to
interCondensatingEvaporatingFoam with spread source approach
3) Reworking framework for icoReactingMultiphaseInterFoam
* Support default values for format/compress enum lookups.
- Avoids situations where the preferred default format is not ASCII.
For example, with dictionary input:
format binar;
The typing mistake would previously have caused formatEnum to
default to ASCII. We can now properly control its behaviour.
IOstream::formatEnum
(
dict.get<word>("format"), IOstream::BINARY
);
Allowing us to switch ascii/binary, using BINARY by default even in
the case of spelling mistakes. The mistakes are flagged, but the
return value can be non-ASCII.
* The format/compression lookup behave as pass-through if the lookup
string is empty.
- Allows the following to work without complaint
IOstream::formatEnum
(
dict.getOrDefault("format", word::null), IOstream::BINARY
);
- Or use constructor-like failsafe method
IOstream::formatEnum("format", dict, IOstream::BINARY);
- Apply the same behaviour with setting stream format/compression
from a word.
is.format("binar");
will emit a warning, but leave the stream format UNCHANGED
* Rationalize versionNumber construction
- constexpr constructors where possible.
Default construct is the "currentVersion"
- Construct from token to shift the burden to versionNumber.
Support token as argument to version().
Now:
is.version(headerDict.get<token>("version"));
or failsafe constructor method
is.version
(
IOstreamOption::versionNumber("version", headerDict)
);
Before (controlled input):
is.version
(
IOstreamOption::versionNumber
(
headerDict.get<float>("version")
)
);
Old, uncontrolled input - has been removed:
is.version(headerDict.lookup("version"));
* improve consistency, default behaviour for IOstreamOption construct
- constexpr constructors where possible
- add copy construct with change of format.
- construct IOstreamOption from streamFormat is now non-explicit.
This is a commonly expected result with no ill-effects
- align Switch more with Enum.
Now have find(), found() static methods.
Constructors with failsafe option.
The find() method makes for clearer coding:
OLD
Switch sw(some_string, true); // NB: true = allowBad
if (sw.valid()) ...
NOW
Switch sw = Switch::find(some_string);
if (sw.good()) ...
or
if (Switch::found(some_string)) ...
- improve construct from dictionary to handle all valid token types.
Previously just read in a word.
- Remove asText() method - replaced by c_str() and str() several
versions ago.
- renamed 'core/' -> 'base/' to avoid gitignore masking when re-adding
files
- rename 'nas/' to 'nastran/' for more clarity
- relocated OBJstream from surfMesh to fileFormats
STYLE: remove unused parseNASCoord. Was deprecated 2017-09
- `tensor` and `tensor2D` returns complex eigenvalues/vectors
- `symmTensor` and `symmTensor2D` returns real eigenvalues/vectors
- adds new test routines for eigendecompositions
- improves numerical stability by:
- using new robust algorithms,
- reordering the conditional branches in root-type selection
- In the course of time, global funcs/opers of Tensor types expanded
leaving funcs/opers unordered.
- Therefore, by following the order designated in Matrix class, the order
of global funcs and global opers are reordered:
- oper+ oper- oper* oper/ inner-product double-inner-product outer-product
- ensures each Tensor-container operates for the following base types:
- floatScalar
- doubleScalar
- complex
- adds/improves test applications for each container and base type:
- constructors
- member functions
- global functions
- global operators
- misc:
- silently removes `invariantIII()` for `tensor2D` and `symmTensor2D`
since the 3rd invariant does not exist for 2x2 matrices
- fixes `invariantII()` algorithm for `tensor2D` and `symmTensor2D`
- adds `Cmpt` multiplication to `Vector2D` and `Vector`
- adds missing access funcs for symmetric containers
- improves func/header documentations
- includes restructuring and simplification of low-level ensight part
handling and refactor of backends to improve code reuse.
foamToEnsight
-------------
* new cellZone support.
This was previously only possible via a separate foamToEnsightParts
utility that was not parallelized.
* support for point fields.
* `-nearCellValue` option (as per foamToVTK)
* data indexing now uses values from the time index.
This is consistent with the ensightWrite function object and
can help with restarts.
* existing ensight directories are removed, unless the -no-overwrite
option is supplied
foamToEnsightParts
------------------
* now redundant and removed.
ensightOutputSurface (new class)
--------------------------------
* a lightweight wrapper for point/face references that is tailored
for the ensightSurfaceWriter. It uses compact face/point information
and is serial only, since this is the format requirements from the
surfaceWriter class.
ensightMesh (revised class)
---------------------------
* now only holds a polyMesh reference, which removes its dependency
on finiteVolume and allows it to be relocated under fileFormats
instead of conversion.
Removed classes: ensightParts, ensighPartFaces, ensightPartCells
- these were used by foamToEnsightParts, but not needed anymore.
- incorrectly set BINARY format in the construction of the received
data (a side-effect of the parameter ordering).
Now use the same default parameters as IFstream and set the correct
filename subsequent to construction.
- '-c' option (as per shell), '-Dkey[=value]' option to provide
preferences via the command-line. For example,
etc/openfoam -DWM_COMPILER=Clang -int64 ./Allwmake -j -s -l
These can also be combined with other options. Eg,
etc/openfoam -DWM_COMPILER=Clang \
-c 'wmake -show-path-cxx -show-cxxflags'
- relocated from bin/tools/ => etc/ for easier access
- bin/tools/openfoam.in : for autoconfig-style installation
- Auto-detect if the shell script was executed with openfoam and
interpret accordingly.
Simple example,
--------------
#!/usr/bin/openfoam
cd "${0%/*}" || exit # Run -*-sh-*- from this dir
blockMesh
simpleFoam
--------------
Note it is NOT currently possible to provide any other parameters
this way. Eg,
`#!/usr/bin/openfoam -sp` (NOT)
This will either fail to run, or result in infinite recursion.
- simplifies code, covers most cases.
Can use wmake -show-api or wmakeBuildInfo to query the make rules.
STYLE: Allwmake script adjustments
- use bin/foamEtcFile instead of relying on PATH.
The make environment may not have the OpenFOAM bin/ in it.
- simpler shell syntax
Issues:
- neighbouring processors use different ray since always from
owner cc to nbr cc
- growing cellZones did not correctly unmark intersections
- stand-alone baffles now always removed (if inside 'grow' region,
i.e. within 1 cell of cellZone)
- the foamConfigurePaths script is quite simplistic and aggressive in
what it changes. This was particularly evident when using it to
change gcc/clang versions.
Restructured the corresponding compiler settings to define default
versions (eg, "default_gcc_version") that limits the scope of
changes performed by foamConfigurePaths and makes it easier to
understand if changing manually.
- the foamConfigurePaths script is quite simplistic and aggressive in
what it changes. This was particularly evident when using it to
change gcc/clang versions.
Restructured the corresponding compiler settings to define default
versions (eg, "default_gcc_version") that limits the scope of
changes performed by foamConfigurePaths and makes it easier to
understand if changing manually.
- provides an indirect access to a sub-section of a list that is
somewhat less efficient than a Foam::SubList, but supports the
following:
* adjustment of its addressing range after construction
* recovery of the original, underlying list at any time
This can be more convenient for some coding cases.
For example,
template<class Addr>
void renumberFaces(IndirectListBase<face, Addr>& faces, ...);
which can be called for
* Specific faces:
UIndirectList<face>(mesh.faces(), facesToChange)
* A sub-range of faces:
IndirectSubList<face>(mesh.faces(), pp.range())
* All faces:
IndirectSubList<face>(mesh.faces())
CONFIG: added IndirectListsFwd.H with some common forwarding
- the gcc c++/9 includes now inline strncpy, which obliterates
the previous method of suppressing the warning.
Now simply allocate additional space for the nul character.
COMP: silence some icc warnings
- make read construct from Istream explicit
BUG: sph(const SymmTensor2D<Cmpt>&)
- had incorrect constant, but the 2D routines still need more attention
(#1575)
- the vtkCellArray internal structure was still largely oriented on
the VTK legacy format, but has now been revised.
https://gitlab.kitware.com/vtk/vtk/merge_requests/5682
The `VTK_CELL_ARRAY_V2` define from vtkCellArray.h indicates
that the newer version is being used.
* In VTK-8.2.0 and older, sizes are interwoven (prefixed) in the
connectivity.
Connectivity: [n1, verts..., n2, verts... ]
When using these in vtkUnstructuredGrid, also needed a secondary
list of offsets for each of the starting locations.
* The update version now resembles a CompactListList. For example
Connectivity: [verts..., verts... ]
Offsets: [0, n1, n1+n2, n1+n2+n3... ]
The offsets are properly handled within vtkCellArray, and dropped as
an additional input for vtkUnstructuredGrid.
- indexing error in the output of values resulted in uniform output in
most cases.
- allocation error for on-the-fly triangulation
ENH: changed decomposed storage from DynamicList to plain faceList for
clearer allocation control and better overhead
- make stream constructors explicit
- remove "using std::ifstream", "using std::iofstream" statements
for a cleaner namespace.
* copy/move assignments for ITstream
* IStringStream: default construct and construct from std::string
instead of Foam::string
- reduce some overhead in masterOFstream
- simplify Pstream handling of string variants (#1525)
- this submodule (https://develop.openfoam.com/modules/visualization)
consolidates VTK-related visualization routines:
* catalyst
* paraview-plugins
* runTimePostProcessing
A benefit of this is make it easier to mix and match
different combinations of VTK/ParaView versions and capabilities
(Eg, MESA, MPI etc).
The catalyst submodule is now obsolete
OpenQBMM is a suite of solvers to simulate polydisperse multiphase flows using
Quadrature-Based Moment Methods (QBMM). For more information, please see
https://www.openqbmm.org/
Main author: Alberto Passalacqua
- avoid stealing autoPtr in interpolationTable copy operations
- improve local memory requirements of readers
- make OpenFOAM table reader default constructible
- more code alignment between csvTableReader and Function1::CSV
(fix#1498 for csvTableReader as well)
Including `nu` in `DphitEff` even though it is not present in (LUU:Eq. 17)
provided higher level of resemblance to benchmarks for the tests considered,
particularly for the peak skin friction (yet, pressure-related predictions
were unaffected). Users can switch off `nu` in `DphitEff` by using
`includeNu` entry in `kEpsilonPhitFCoeffs` in order to follow the
reference paper thereat. `includeNu` is left `true` by default.
See GitLab issue #1560,
LUU: Laurence, D. R., Uribe, J. C., & Utyuzhnikov, S. V. (2005).
- remove (unused) Istream constructors, prune some unused methods,
rationalize write() vs writeDict().
Deprecate inconsistent construction order.
- handle empty names for ".ftr" surface patches (for plain triSurface
format) with double-quoted strings for more reliable streaming.
Written on a single line.
This is _backward_ compatible, but if users have been parsing these
files manually, they will need to adjust their code.
Previously:
```
(
frt-fairing:001%1
empty
windshield:002%2
empty
...
)
```
Updated (with example handling of empty name):
```
(
frt-fairing:001%1 empty
windshield:002%2 ""
...
)
```
- was in surfMesh/triSurface/patches/
now in OpenFOAM/meshes/Identifiers/surface/
This places the code closer to other identifier classes,
which aids in maintaining consistency
When more than one volumetric B-Splines control boxes are present, the
sensitivity constituents corresponding to the non-active design
variables were not bounded(zeroed) correctly. The resultant
sensitivities, used in the optimization, were bounded correctly, so this
was more a bug pertaining to the output file of the sensitivities rather
than a functional one.
- previously the store() method just set the ownedByRegistry flag.
Now ensure that it is indeed registered first.
- support register/store of tmp<> items.
The tmp parameter is not cleared, but changed from PTR to CREF
to allow further use.
The implicit registration allows code simplification using the
GeometricField::New factory method, for example.
Old Code
========
volScalarField* ptr = new volScalarField
(
IOobject
(
fieldName,
mesh.time().timeName(),
mesh,
IOobject::NO_READ,
IOobject::NO_WRITE,
true // Register
),
mesh,
dimless,
zeroGradientFvPatchField<scalar>::typeName
);
ptr->store();
New Code
========
auto tptr = volScalarField::New
(
fieldName,
mesh,
dimless,
zeroGradientFvPatchField<scalar>::typeName
);
regIOobject::store(tptr);
or even
regIOobject::store
(
volScalarField::New
(
fieldName,
mesh,
dimless,
zeroGradientFvPatchField<scalar>::typeName
)
);
The collated container ('decomposedBlockData') is always binary
but the 'payload' might be ascii so use that header information
instead of the decomposeBlockData header.
- kEpsilonPhitF is a kEpsilon-based model which originated
from (Durbin, 1995)’s v2-f methodology. However, the majority of
v2-f model variants proved to be numerically stiff for segregated
solution algorithms due to the coupled formulations of v2 and f fields,
particularly on wall boundaries.
The v2-f variant (i.e. OpenFOAM’s v2f model) due to
(Lien and Kalitzin, 2001) reformulated the original v2-f model to enable
segregated computations; however, a number of shortcomings regarding
the model fidelity were reported in the literature.
To overcome the shortcomings of the v2-f methodology, the v2-f approach
was re-evaluated by (Laurence et al., 2005) by transforming v2 scale into
its equivalent non-dimensional form, i.e. phit, to reduce the numerical
stiffness.
This variant, i.e. kEpsilonPhitF, is believed to provide numerical
robustness, and insensitivity to grid anomalies while retaining the
theoretical model fidelity of the original v2-f model.
Accordingly the v2f RANS model is deprecated in favour of the variant
kEpsilonPhitF model.
When activeDesignVariables are not set explicitly, all design variables
are treated as active. These were allocated properly when starting from
0 but not when starting from an intermediate optimisation cycle
(e.g. running 5 optimisation cycles, stopping and restarting).
TUT: added a new tutorial including the restart of an optimisation run
to help identify future regression
The controlBoxes wordList was removed from NURBS3DVolume in the
pre-release phase but writeMorpherCPs was not updated accordingly.
TUT: added the invocation of writeMorpherCPs in one of the tutotials to
help identify future regression
- The core of the FatalIOError message was not printed due to exiting
with FatalError instead of FatalIOError
- Changed the TypeName in all derived classes of displacementMethod so
that the toc printed by the FatalIOError corresponds to what the user
should add in dynamicMeshDict
When a contact resistance is used the T field on each coupled
patch is different due to the thermal resistance. Thus, instead
of solving for a unique Tw at the wall, we solve for Tw1 at one side
then, the Tnbr internal becomes Tw2, which is the T of the nbr
patch.
When a contact resistance is used the T field on each coupled
patch is different due to the thermal resistance. Thus, instead
of solving for a unique Tw at the wall, we solve for Tw1 at one side
then, the Tnbr internal becomes Tw2, which is the T of the nbr patch.
Many possibilities:
- use as a simple calculator with vectors, tensors etc.
- test validity of expression syntax
As a calculator:
foamCalc '(vector(1,2,3) ^ vector(4,5,6)) * sqrt(34)'
The same, but with debugging:
foamCalc -debug-switch fieldExpr=6 \
'mag((vector(1,2,3) ^ vector(4,5,6))) * sqrt(34)'
- previously just reported gcc/clang versions, but these are not
necessarily the ones actually being used (eg, clang-9 vs clang).
Now use the path from `wmake -show-path-cxx` to improve the accuracy,
and also support other compiler types.
1) New skewCorrectedSnGrad for non-orthogonal and skewness corrector
2) New freeSurfacePressure and freeSurfacePressure working with
interfaceTrackingFvMesh
3) New interfaceTrackingFvMesh
- now use debug 2 for scanner and debug 4 for parser.
Provided better feedback about what is being parsed (debug mode)
- relocate debug application to applications/tools/foamExprParserInfo
See GL #1433
Applies corrections to turbulence kinetic energy equation and turbulence
viscosity field for incompressible multiphase flow cases.
Turbulence kinetic energy is over-predicted in VOF solvers at the phase
interface and throughout the water column in nearly-potential flow regions
beneath surface waves.
This fvOption applies corrections based on the references:
Buoyancy source term in turbulence kinetic energy equation:
Devolder, B., Rauwoens, P., and Troch, P. (2017).
Application of a buoyancy-modified k-w SST turbulence model to
simulate wave run-up around a monopile subjected to regular waves
using OpenFOAM.
Coastal Engineering, 125, 81-94.
Correction to turbulence viscosity field:
Larsen, B.E. and Fuhrman, D.R. (2018).
On the over-production of turbulence beneath surface waves in
Reynolds-averaged Navier-Stokes models
J. Fluid Mech, 853, 419-460
Example usage:
multiphaseStabilizedTurbulence1
{
type multiphaseStabilizedTurbulence;
active yes;
multiphaseStabilizedTurbulenceCoeffs
{
// Optional coefficients
lambda2 0.1; // A value of 0 sets the nut correction to 0
Cmu 0.09; // from k-epsilon model
C 1.51; // model coefficient from k-omega model
alpha 1.36; // 1/Prt
}
}
Thanks go to the Turbulence Technical Committee, and the useful discussions
with and code testing by Bjarke Eltard-Larsen and David Fuhrman (Technical
University of Denmark).
ENH: modify fWallFunction for kEpsilonPhitF model
The k-epsilon-phit-f turbulence closure model for incompressible and
compressible flows.
The model is a three-transport-equation linear-eddy-viscosity turbulence
closure model alongside an elliptic relaxation equation:
- Turbulent kinetic energy, \c k,
- Turbulent kinetic energy dissipation rate, \c epsilon,
- Normalised wall-normal fluctuating velocity scale, \c phit,
- Elliptic relaxation factor, \c f.
Reference:
\verbatim
Standard model (Tag:LUU):
Laurence, D. R., Uribe, J. C., & Utyuzhnikov, S. V. (2005).
A robust formulation of the v2−f model.
Flow, Turbulence and Combustion, 73(3-4), 169–185.
DOI:10.1007/s10494-005-1974-8
\endverbatim
The default model coefficients are (LUU:Eqs. 19-20):
\verbatim
kEpsilonPhitFCoeffs
{
Cmu 0.22, // Turbulent viscosity constant
Ceps1a 1.4, // Model constant for epsilon
Ceps1b 1.0, // Model constant for epsilon
Ceps1c 0.05, // Model constant for epsilon
Ceps2 1.9, // Model constant for epsilon
Cf1 1.4, // Model constant for f
Cf2 0.3, // Model constant for f
CL 0.25, // Model constant for L
Ceta 110.0, // Model constant for L
CT 6.0, // Model constant for T
sigmaK 1.0, // Turbulent Prandtl number for k
sigmaEps 1.3, // Turbulent Prandtl number for epsilon
sigmaPhit 1.0, // Turbulent Prandtl number for phit = sigmaK
}
\endverbatim
Note
The name of the original variable replacing 'v2' is 'phi' (LUU:Eq. 14).
However, the name 'phi' preexisted in OpenFOAM; therefore, this name was
replaced by 'phit'
qem and qin were not set to zero for the wideBand model BC.
qin was used in the grey model BC to calculate Ir(the total
incoming heat flux). As it is now set to zero, the grey model
loops over the incoming rays to calculate Ir instead of relaying
on qin stored in radiativeIntensityRay.
- follows the principle of least surprise if the expansion behaviour
for #eval and expressions (eg, exprFixedValue) are the same. This
is possible now that we harness the regular stringOps::expand()
within exprString::expand()
Adding check for p.active at the end of KinematicParcel::move.
p.hitFace() is called only for active parcels.
Setting to zero the initialization for stored lists of stick and
escape parcels
in LocalInteraction and StandardWallInteraction models
NOTE: KinematicParcel::hitPatch counts overall system escaped
parcels and mass based on polyPatch type and not on type of
patchInteractionModel. Thus, if a patch is a Wall for fluid
but escape for parcel the overall report will be wrong but
the local report for each patch is correct
- the PDRsetFields utility processes a set of geometrical obstructions
to determine the equivalent blockage effects.
These fields are necessary inputs for PDRFoam calculations.
After setting up the geometries, the -dry-run option can be used to
generate a VTK file for diagnosis and post-processing purposes.
- this is an initial release, with improvements slated for the future.
NOTE
- the field results may be less than fully reliable when run in
single-precision. This howver does not represent a realistic
restriction since the prepared fields target a combustion
application which will invariably be double-precision.
- locate where the user is less tempted to change it (#1515).
It really should be considered an invariant environment variable.
STYLE: wmake -help information to stdout, die errors to stderr
- The wmake -show-path-{c,cxx} options return the fully qualified
paths to the respective compilers. This can be useful when verifying
that the correct compiler is indeed configured.
- The -help-full to display the "advanced" options, but in the normal
case just show the basic options.
- reuse more of stringOps expansions to reduce code and improve the
syntax flexiblity.
We can now embed "pre-calculated" values into an expression.
For example,
angle 35;
valueExpr "vector(${{cos(degToRad($angle))}}, 2, 3)";
and the ${{..}} will be evaluated with the regular string evaluation
and used to build the entire expression for boundary condition
evaluation.
Could also use for fairly wild indirect referencing:
axis1 (1 0 0);
axis2 (0 1 0);
axis3 (0 0 1);
index 100;
expr "$[(vector) axis${{ ($index % 3) +1 }}] / ${{max(1,$index)}}";
- Failed due to double*Matrix<float> multiplication.
Style changes
- use SquareMatrix with Identity on construction
- use Zero in constructors
- remove trailing space and semi-colons
- skip processing OSspecific/MSwindows since this can cause duplicate
doxygen entries
STYLE: adjust formatting in code templates
STYLE: use std::string methods without extra qualifications
- ensure that the updateControl is "non-sticky" on re-read,
even if we do not support runtime-modifiable here
STYLE: add syntax example (wingMotion), but with updateInterval 1
- synchronize the scalar interval value with the integer version.
This ensures that the interval() method returns the correct
representative value.
- added clear() method to reset to 'always' (pass-through)
- ensure that the updateControl is "non-sticky" on re-read,
even if we do not support runtime-modifiable here
STYLE: add syntax example (wingMotion), but with updateInterval 1
The adjoint library is enhanced with new functionality enabling
automated shape optimisation loops. A parameterisation scheme based on
volumetric B-Splines is introduced, the control points of which act as
the design variables in the optimisation loop [1, 2]. The control
points of the volumetric B-Splines boxes can be defined in either
Cartesian or cylindrical coordinates.
The entire loop (solution of the flow and adjoint equations, computation
of sensitivity derivatives, update of the design variables and mesh) is
run within adjointOptimisationFoam. A number of methods to update the
design variables are implemented, including popular Quasi-Newton methods
like BFGS and methods capable of handling constraints like loop using
the SQP or constraint projection.
The software was developed by PCOpt/NTUA and FOSS GP, with contributions from
Dr. Evangelos Papoutsis-Kiachagias,
Konstantinos Gkaragounis,
Professor Kyriakos Giannakoglou,
Andy Heather
[1] E.M. Papoutsis-Kiachagias, N. Magoulas, J. Mueller, C. Othmer,
K.C. Giannakoglou: 'Noise Reduction in Car Aerodynamics using a
Surrogate Objective Function and the Continuous Adjoint Method with
Wall Functions', Computers & Fluids, 122:223-232, 2015
[2] E. M. Papoutsis-Kiachagias, V. G. Asouti, K. C. Giannakoglou,
K. Gkagkas, S. Shimokawa, E. Itakura: ‘Multi-point aerodynamic shape
optimization of cars based on continuous adjoint’, Structural and
Multidisciplinary Optimization, 59(2):675–694, 2019
- when using VTK from ParaView sources it can better to tag them as
such, but simultaneously not mask the ParaView with hardware
rendering.
The additional ParaView_MESA_DIR variable allows this.
The balance of library and path setup is unaffected by this.
DOC: update doc/BuildIssues
- `Pkt` was directed to `GName` to allow wall functions
are usable by kkLOmega model
- `Pkt` was changed to a non-const object, so that omegaWallFunc
can modify `Pkt` at the wall, if need be.
- Elementwise backward compatibility was checked by
pimpleFoam/RAS/ellipsekkLOmega
- New implementation was checked by changing omega:hole boundary
in pimpleFoam/RAS/ellipsekkLOmega to omegaWallFunction
QRMatrix (i.e. QR decomposition, QR factorisation or orthogonal-triangular
decomposition) decomposes a scalar/complex matrix \c A into the following
matrix product:
\verbatim
A = Q*R,
\endverbatim
where
\c Q is a unitary similarity matrix,
\c R is an upper triangular matrix.
Usage
Input types:
- \c A can be a \c SquareMatrix<Type> or \c RectangularMatrix<Type>
Output types:
- \c Q is always of the type of the matrix \c A
- \c R is always of the type of the matrix \c A
Options for the output forms of \c QRMatrix (for an (m-by-n) input matrix
\c A with k = min(m, n)):
- outputTypes::FULL_R: computes only \c R (m-by-n)
- outputTypes::FULL_QR: computes both \c R and \c Q (m-by-m)
- outputTypes::REDUCED_R: computes only reduced \c R (k-by-n)
Options where to store \c R:
- storeMethods::IN_PLACE: replaces input matrix content with \c R
- storeMethods::OUT_OF_PLACE: creates new object of \c R
Options for the computation of column pivoting:
- colPivoting::FALSE: switches off column pivoting
- colPivoting::TRUE: switches on column pivoting
Direct solution of linear systems A x = b is possible by solve() alongside
the following limitations:
- \c A = a scalar square matrix
- output type = outputTypes::FULL_QR
- store method = storeMethods::IN_PLACE
Notes
- QR decomposition is not unique if \c R is not positive diagonal \c R.
- The option combination:
- outputTypes::REDUCED_R
- storeMethods::IN_PLACE
will not modify the rows of input matrix \c A after its nth row.
- Both FULL_R and REDUCED_R QR decompositions execute the same number of
operations. Yet REDUCED_R QR decomposition returns only the first n rows
of \c R if m > n for an input m-by-n matrix \c A.
- For m <= n, FULL_R and REDUCED_R will produce the same matrices
- handle zero or negative values as being identical to 1.
As per timeStep control and what the comments suggested.
- drop old outputTime enumeration, since this is covered by the
writeTime enumeration and a corresponding Enum name.
- support construction of a "pass-through" control object that always
executes and add some method to test for these conditions and be able
to output some meaning full information.
Eg,
if (ctrl.execute())
{
if (!ctrl.always())
{
Info<< "Sampling executed based on " << ctrl.type() << nl;
}
...
}
To produce "Sampling executed based on runTime"
Calculates the acoustic power due to the volume of isotropic turbulence
using Proudman's formula
The acoustic power \f$ P_A \f$ [W/m3] in terms of turbulence \f$ k \f$
and \f$ \epsilon \f$ is given as:
\f[
P_A = alpha_\epsilon \rho \epsilon M_t^5
\f]
where \f$ alpha_\epsilon \f$ is a constant (0.1) and
\f[
M_t = \frac{\sqrt{2 k}}{a_0}
\f]
with \f$ a_0 \f$ the speed of sound. The acoustic power is also output in
dB using:
\f[
L_P = 10 \log \frac{P_A}{P_ref}
\f]
where \f$ P_ref \f$ is a constant (1e-12 W/m3)
Usage
Example of function object specification to calculate the Proudman acoustic
power
proudmanAcousticPower1
{
type proudmanAcousticPower;
libs ("libfieldFunctionObjects.so");
...
// Required additional entries for incompressible calculations
rhoInf 1.225;
aRef 340;
}
Where the entries comprise:
Property | Description | Required | Default value
type | type name: proudmanAcousticPower | yes |
rhoInf | Freestream density for incompressible cases | no |
aRef | Reference spped of sound for incompressible cases | no |
alphaEps | Model coefficient | no | 0.1
Note
- The freestream density and reference speed of sound are only necessary
when a thermodynamics package is unavailable, typically for incompressible
cases.
- Allows user-defined control of when the mesh motion occurs,
which can be especially useful in situations where the mesh motion
is much slower than any of the fluid physics.
For example, in constant/dynamicMeshDict:
updateControl runTime;
updateInterval 0.5;
to have mesh motion triggered every 1/2 second.
Note that the _exact_ time that the mesh motion actually occurs may
be slightly differently since the "runTime" triggering is fuzzy in
nature. It will trigger when the threshold has been crossed, which
will depend on the current time-step size.
- The -Wno-deprecated-copy flag for gcc-9.2.0
In the future we may indeed wish to explicitly request default
generated constructors and assignment operators, but at the moment
these are still acceptable.
- The -Wno-alloc-size-larger-than flag for mingw compilations
Related to differences in PTRDIFF_MAX vs SIZE_MAX on the target.
Several issues related to this can be found in the gcc bug reports
and on stackoverflow etc.
COMP: delay evaluation of fieldToken enumeration types
- lazy evaluation at runTime instead of compile-time to make the code
independent of initialization order.
Otherwise triggers problems on gcc-4.8.5 on some systems where
glibc is the same age, or older.
Feature particle patch postpro filtering
### Summary
Adds options to write particle-patch interactions to file, and to select particle fields to post-process for the `patchPostProcessing` cloud function object
### Resolved bugs (If applicable)
none
### Details of new models (If applicable)
Cloud patch interaction models:
Optionally write patch interaction statistics, e.g. number and mass of particles that stick, escape etc. to file using the optional `writeToFile` entry, e.g.
```
localInteractionCoeffs
{
patches
(
"(walls|cyc.*)"
{
type rebound;
}
"inlet|outlet"
{
type escape;
}
);
// New optional entry
writeToFile yes;
}
```
Cloud function objects:
New `fields` optional entry can be used to select which particle fields to post-process; if empty or the entry is not given all fields are written (to provide backwards compatibility)
```
patchPostProcessing1
{
type patchPostProcessing;
// Optional new entry
fields (position "U.*" d T nParticle);
maxStoredParcels 20;
patches
(
cycLeft_half0
cycLeft_half1
);
}
```
See the `$FOAM_TUTORIALS/lagrangian/reactingParcelFilm/filter` tutorial for an example
### Risks
Low risk
See merge request Development/openfoam!301
Feature expressions
### Summary
This branch represents an implementation of what is considered to be the most useful aspects of swak4Foam ([Swiss-Army-Knife for FOAM](https://openfoamwiki.net/index.php/Contrib/swak4Foam)) from Bernhard Gschaider, namely the ability to use text-based expressions instead of coding in C++ for the following cases:
- expression-based boundary conditions (also known as _groovy_ boundary conditions)
- expression-based setFields (also known as _funky_ set fields)
The idea of what we currently term *expressions* was pioneered by
(Bernhard Gschaider) and is now firmly established in `swak4Foam`.
Among other things, expressions attempt to bridge the gap between
using standard, predefined boundary conditions and writing dedicated,
special-purpose ones. Although part of this gap is now covered within
OpenFOAM by using dynamically compiled user coding (eg, coded boundary
conditions), there remains substantial areas where it can be
significantly more convenient to have a series of predefined functions
and expression sytax with some access to base OpenFOAM field
functionality that enables rapid deployment of boundary conditions, or
custom-defined `setFields` without writing code.
A significant portion of `swak4Foam` expressions has been adapted for
direct integration into OpenFOAM. During the integration and rewrite,
we have tried to pare things down to a smaller subset with the aim of
covering 90% or more of the common cases. The remaining cases are left
to be reassessed for extending the *expressions* functionality in the
future, but they also may be better served with other approaches (eg,
with coded conditions) that were not available when `swak4Foam` was
originally conceived.
To the greatest extent possible, the integrated *expressions* have
been designed to avoid name clashes with `swak` so it should remain
possible to use the most recent versions of `swak` without problem.
### Risks
- New functionality, so low chance of regression.
- The scope of the functionality will be revised in the future
### Naming (for `swak4Foam` users)
The following are the *expressions* correspondences to `swak`:
- The `exprFixedValue` and `exprGradient` boundary conditions are
roughly equivalent to the _groovy_ boundary conditions.
- The utilities `setExprFields` and `setExprBoundaryFields` are
roughly equivalent to the _funky_ utilities of similar name.
The naming of the boundary conditions and utilities not only reflects
the slightly different input requirements, but simultaneously seeks to
avoid any potential name-clash with `swak4Foam` in a mixed
environment.
The names for the boundary condition dictionary entries tend be
shorter and slightly different (eg, `valueExpr` vs `valueExpression`)
to serve as a small reminder that the *expressions* syntax is slightly
different than the *groovy* equivalents. It also allows the user to
fashion dictionary entries that are sufficient for **both** boundary
condition variants and quickly toggle between them simply by changing
the boundary condition `type`.
See merge request Development/openfoam!300
Limits fields to user-specified min and max bounds
Usage
Example of function object specification:
limitFields1
{
type limitFields;
libs ("libfieldFunctionObjects.so");
...
fields (U);
limit max;
max 100;
}
Where the entries comprise:
Property | Description | Required | Default
type | type name: limitFields | yes |
fields | list of fields to process | yes |
limit | bound to limit - see below | yes |
min | min limit value | partly |
max | max limit value | partly |
The "limit" entry can take the value:
- min : specify a minimum value
- max : specify a maximum value
- both : specify a minimum value and a maximum value
The optional 'fields' entry can be used to limit which particle fields are
written to file. If empty/not specified, all properties are written to
maintain backwards compatibility.
patchPostProcessing1
{
type patchPostProcessing;
maxStoredParcels 20;
fields (position "U.*" d T nParticle);
patches
(
cycLeft_half0
cycLeft_half1
);
}
- replace stringOps::toScalar with a more generic stringOps::evaluate
method that handles scalars, vectors etc.
- improve #eval to handle various mathematical operations.
Previously only handled scalars. Now produce vectors, tensors etc
for the entries. These tokens are streamed directly into the entry.
This condition applies a scalar multiplier to the value of another
boundary condition.
Usage
Property | Description | Required | Default value
scale | Time varing scale | yes |
patch | patchField providing the raw patch value | yes |
Example of the boundary condition specification to scale a reference
velocity of (15 0 0) supplied as a fixedValue by a table of values
that ramps the scale from 0 to 1 over 1 second:
<patchName>
{
type scaledFixedValue;
scale table
(
( 0 0)
( 1.0 1.0)
(100.0 1.0)
);
patch
{
type fixedValue;
value uniform (15 0 0);
}
}
- The previous option 'write-nut' controlled the writing of turbulence
nut, but other turbulence fields were always written.
These have been shown to be a source of instability for many cases.
This commit replaces the 'write-nut' option by a 'writeTurbulenceFields'
option that controls the writing of all turbulence fields.
If not set, only the velocity field is written.
For compatibility, the old 'write-nut' option is still recognized
but is redirected to 'writeTurbulenceFields'.
Set the m4 -I include accordingly to have the folllowing:
- the directory of the parser.
- include/ in the top-level source tree of the current target
(eg, src/finiteVolume/include-m4/ when compiling libfiniteVolume)
- include/ from OpenFOAM
Additional -dry-run option for makeParser, wrap-lemon for expanding m4
only.
Extend m4 wrapping support to include bison as well.
- include the trailing newline for the "// comment" form, but also add
in leading space removal. This ensure that we do not introduce odd
indentation, while also eliminating lines that are solely C++
comments.
- output the "uniform", "nonuniform" Field entry tags as words instead
of raw character strings, which can help for direct tokenization or
when sending/receiving via Pstreams.
- some support for "uniform" bool fields. Calculating an averaged
value for a boolField does not work very well, but we simply define
that the field average is 'true' when more than 1/2 of its values
are true. Not exactly true, but allows templated definitions to work
smoothly.
- additional output method writeValue().
This outputs the single (uniform) value or the first value of the
field.
- ITstream append() would previously have used the append from the
underlying tokenList, which leaves the tokenIndex untouched and
renders the freshly appended tokens effectively invisible if
interspersed with primitiveEntry::read() that itself uses tokenIndex
when building the list.
The new append() method makes this hidden ITstream bi-directionality
easier to manage. For efficiency, we only append lists
(not individual tokens) and support a 'lazy' resizing that allows
the final resizing to occur later when all tokens have been appended.
- The new ITstream seek() method provides a conveniently means to move
to the end of the list or reposition to the middle.
Using rewind() and using seek(0) are identical.
ENH: added OTstream to output directly to a list of tokens
---
BUG: List::newElem resized incorrectly
- had a simple doubling of the List size without checking that this
would indeed be sufficient for the requested index.
Bug was not triggered since primitiveEntry was the only class using
this call, and it added the tokens sequentially.
This adds automatic deletion of cells inside small gaps. This is
generally used to avoid having excessive numbers of cells in irrelevant
areas of a geometry. It is nearly the opposite of automatic gap refinement
- that refines cells to resolve the gap; this functionality removes cells
to not mesh the gap.
The proximity handling will remove those cells which are inside 'thin' gaps
where 'thin' is defined as a distance of 2*'blockLevel'
It will
- detect surfaces which have the new 'blockLevel' specification
- convert this to a minimum gap distance
- detect cells which are inside this gap
- remove these cells and add exposed faces to the nearest 'real' patch
- The case files may contain #... comment lines
- The geometry file may contain an optional "extents" entry
- Properly handle element id specifications (off|assign|ignore|given).
- Partially handle node id specifications (off|assign|ignore|given).
Treat "given" like "ignore", since results in the lightest amount of
coding and in many cases the "given" node ids are in fact 1-based
contiguous values and thus no different than "ignore" for our
purposes.
- allows use of Enum in more situations where a tiny Map/HashTable
replacement is desirable. The new methods can be combined with
null constructed for to have a simple low-weight caching system
for words/integers instead of fitting in a HashTable.
ENH: downgrade error on type-mismatch to a warning
- Ensight data files generated by OpenFOAM will start with the name of
the data type (Eg, "scalar", "vector" etc), but this convention may
fail for data files that have been generated elsewhere.
- since pointPatchField is not derived from Field, methods such as
negate() or a unary min(), max() are missing.
These have apparently not been needed thus far, but are used
indirectly via GeometricField.
- improves similarity to autoPtr. Simplifies coding.
Example,
tmp<volScalarField> tfield;
// sometime later...
tfield.reset
(
volScalarField::New("myfield", mesh, dimensionedScalar(Zero))
);
- as per tmp, disallow tmpNrc assignment from literal nullptr
- as per autoPtr, allow explicit test as bool (same as valid).
- can be useful when a scalarField has been used to store booleans and
we need to recover a bool directly and deal with potential rounding
issues.
ENH: support "any" as a Switch counterpart to "none"
- now indicate that the dictionary entry is missing, not that it is
an unknown function type.
STYLE: adjust PatchFunction1New.C to have logic structure look similar
- save in META-INFO/build-info for later re-compilation without git.
This improves tracking beyond simply referring to the the patch level.
The information is tagged with an underscore to distinguish from
"real" build information when git is available.
STYLE: improved shell syntax, pushd/popd guards etc.
- Previously, the default mapping method was `planarInterpolation` which was
silently suppressed by the default 'interpolate{R,U,L}=false'.
STYLE: changes:
`0` to `Zero`,
`lookupOrDefault` to `getOrDefault`
improves header documentation
- silently deprecate 'startsWith', 'endsWith' methods
(added in 2016: 2b14360662), in favour of
'starts_with', 'ends_with' methods, corresponding to C++20 and
allowing us to cull then in a few years.
- handle single character versions of starts_with, ends_with.
- add single character version of removeEnd and silently deprecate
removeTrailing which did the same thing.
- drop the const versions of removeRepeated, removeTrailing.
Unused and with potential confusion.
STYLE: use shrink_to_fit(), erase()
Example - create p-rgh from p:
pressure-p-rgh
{
type pressure;
libs (fieldFunctionObjects);
writeControl writeTime;
mode static;
rho rhoInf;
rhoInf 1;
hydrostaticMode subtract;
g (0 -9.81 0);
hRef 0;
}
- the hydrostaticMode entry is optional - setting is shown during construction
- g and/or hRef values are retrieved from the database if not specified
- This scheme is useful to calculate the face interpolation values for
the Gauss gradient when the diffussion coefficient is discontinuous
across a face. This sheme is used for Gauss grad.
- foamExec was removed as part of commit 6c68c34e1a but
overlooked the fact that it is partly still needed by foamJob.
When running in parallel, it is used to source the etc/bashrc env.
Reinstated a stripped down form, which has been relocated to
bin/tools directory (it should not be directly called by the user).
The previous version switching functionality has nonetheless be
dropped since it only worked only when a rigid naming convention for
OpenFOAM installations was followed.
ENH: add foamJob log=, -log-app, -no-log options, improved coding quality
- use sed instead of foamDictionary and avoid log file
- ensure consistent behaviour with plot script
GIT: added missing 0/k field : inlet values still need adjustment
- can be helpful, for example, when the refCast has been used on a
boundary patch. Knowing which patch index triggered the problem
helps with isolating the issue.
For example,
$ someSolver -info-switch writeOptionalEntries
- note that values changed via the command-line are changed after the
etc/controlDict entries, but *before* any case-local
system/controlDict entries.
However, in many testing cases the command-line options eliminate
the need for such local file modifications.
ENH: cleanup handling of local debug switches in Time
- add as methods directly on simpleObjectRegistry to avoid code
duplication
STYLE: adjust internal naming of ITstream parameters
- now reports the dictionary, entry, default. For example,
Dictionary: <case>/0/nut.boundaryField.wall Entry: Cmu Default: 0.09
Dictionary: <case>/0/nut.boundaryField.wall Entry: kappa Default: 0.41
Dictionary: <case>/0/nut.boundaryField.wall Entry: E Default: 9.8
- suppress reporting for debug, optimisation switches since this
generates extremely noisy output
- Now accept '/' when reading variables without requiring
a surrounding '{}'
- fix some degenerate parsing cases when the first character is
already bad.
Eg, $"abc" would have previously parsed as a <$"> variable, even
although a double quote is not a valid variable character.
Now emits a warning and parses as a '$' token and a string token.
- add toScalar evaluation, embedded as "${{EXPR}}".
For example,
"repeat ${{5 * 7}} times or ${{ pow(3, 10) }}"
- use direct string concatenation if primitive entry is only a string
type. This prevents spurious quotes from appearing in the expansion.
radius "(2+4)";
angle "3*15";
#eval "$radius*sin(degToRad($angle))";
We want to have
'(2+4)*sin(degToRad(3*15))'
and not
'"(2+4)"*sin(degToRad("3*15"))'
ENH: code refactoring
- refactored expansion code with low-level service routines now
belonging to file-scope. All expansion routines use a common
multi-parameter backend to handle with/without dictionary etc.
This removes a large amount of code duplication.
- add floor/ceil/round methods
- support evaluation of sub-strings
STYLE: add blockMeshDict1.calc, blockMeshDict1.eval test dictionaries
- useful for testing and simple demonstration of equivalence
- SubField and SubList assign from zero
- SubField +=, -=, *=, /= operators
- SubList construct from UList (as per SubField)
Note: constructing an anonymous SubField or SubList with a single
parameter should use '{} instead of '()' to avoid compiler
ambiguities.
- drop plugin support for Qt4 (old paraview)
- handle upcoming changes in VTK version naming in CMake files
* VTK_MAJOR_VERSION becomes VTK_VERSION_MAJOR etc.
- Improves header file documentations
- Adds const specifier to various objects
- Allows various model constants to be user-defined
- Changes from lookupOrDefault() to getOrDefault()
- Consistent namespace usage:
- If the WF belongs to only Foam:: namespace, use Foam:: explicitly
- If the WF belongs to more than one namespaces, put the WF in namespace
parentheses
- Adds the missing dashes in comments required by Doxygen
- Corrects capitalisation in comments
- The terminology 'viscous sublayer' was preferred over 'laminar sublayer'
due to the fact that the sublayer is not laminar.
- The order of initialisation of fields is changed to be the same across all.
OpenFOAM.org commits for
src/TurbulenceModels/turbulenceModels/derivedFvPatchFields/wallFunctions
were reviewed.
The parts of the commits made by OpenFOAM.org removing various code
duplications across wall functions were picked up by keeping the remaining
functionalities the same.
The duplications were mainly due to:
- wall function model coefficients
- yPlusLam(), checkPatch(), write() methods
The duplications were united under the base nutWallFunction.
- since a zero-sized FixedList is disallowed, the accessors to the
first/last elements are always known.
This allows Pair second() to be noexcept as well (as per Tuple2)
- the #eval directive is similar to the #calc directive, but for evaluating
string expressions into scalar values. It uses an internal parser for
the evaluation instead of dynamic code compilation. This can make it
more suitable for 'quick' evaluations.
The evaluation supports the following:
- operations: - + * /
- functions: exp, log, log10, pow, sqrt, cbrt, sqr, mag, magSqr
- trigonometric: sin, cos, tan, asin, acos, atan, atan2, hypot
- hyperbolic: sinh, cosh, tanh
- conversions: degToRad, radToDeg
- constants: pi()
- misc: rand(), rand(seed)
- previously allowed mapped value modification with a const iterator.
However, this can lead to incorrect access patterns.
Now tie the constness of the mapped value to that of the iterator.
- Remove deprecated iterator object() method.
Was only used internally and was superseded by the val() method
in an earlier version.
ENH: change isPointer to isPointerLike
- can distinguish between real pointers and wrapped pointers
- this largely reverts 3f0f218d88 and 4ee65d12c4.
Consistent addressing with support for wrapped pointer types (eg,
autoPtr, std::unique_ptr) has proven to be less robust than desired.
Thus rescind HashTable iterator '->' dereferencing (from APR-2019).
- for special cases when normal writing is to be completely disabled
and replaced with alternate means (eg, via a function object).
- support "adjustable" as "adjustableRunTime" alias to reduce typing
for writeControl or outputControl
- use HashTable emplace instead of insert to avoid unneeded argument
(for HashSet).
- use emplace when generating zero-initialized values for
HashTable::operator()
- drop unused parameter from Detail::HashTableSingle,
adjust templates parameter names
- forward HashTable::operator[] to the semantically identical
HashTable::at() to avoid code duplication
- call also be used non-interactively for simple 'one-shot' use of
OpenFOAM utilities or solvers
STYLE: use dash instead of brackets for '- see www.OpenFOAM.com'
- less cluttered in combination with API information
- now maintains a correct list of geometry instances, without assuming
contiguous file numbering. However, if the numbering is contiguous,
the more compact case representation will be used.
- an advanced feature, for example when sampling on a static patch
while some motion occurs elsewhere. [use with caution]
- If the sampled surface dictionary is modified during run-time, the
ensight file indexing for the geometry will become out of sync.
This is addressed in a subsequent commit.
- this can be useful for preloading of libraries, or for utilities
that don't use system/controlDict.
The additional libraries can be specified individually:
myUtil -lib lib1 -lib lib2 -lib lib3
When specified like this, the options add up.
Or as a 'captured' list using OpenFOAM's standard arg list handling:
myUtil -lib '(' lib1 lib2 lib3 ')'
myUtil -lib \( lib1 lib2 lib3 \)
or as single argument list:
myUtil -lib '("lib1" "lib2" "lib3")'
When specified as a single argument, would normally take advantage
of the transparent handling of word vs fileName and omit the string
quotes:
myUtil -lib '(lib1 lib2 lib3)'
ENH: dlOpen error messages now propagated into dlLibraryTable
- this makes the context more relevant and also avoids the previous
annoyance of double warnings (one from the POSIX loader, and one
from dlLibraryTable)
STYLE: mark -noFunctionObjects and -withFunctionObjects as 'advanced'
- reduces clutter. Still visible with -help-full
- add additional rule (ending '.ll') for the combination of
flex for C-code but compiling the result as C++.
This can be needed for re-entrant parsers.
- update bison rule to handle renaming of skeleton files.
Use a wrap-bison script to manage this.
- relax casting rules
* down-cast of labelToken to boolToken
* up-cast of wordToken to stringToken.
Can use isStringType() test for word or string types
- simplify constructors, move construct etc.
- expose reset() method as public, which resets to UNDEFINED and
clears allocated storage etc.
DEFEATURE: remove assign from word or string pointer.
- This was deprecated 2017-11 and now removed.
For this type of content transfer, move assignment should be used
instead of stealing pointers.
1) Add softWall rigidBody restrain
2) Add linearSpringDamper sixDoF restrain to work as soft rope
3) dynamicMotionSolverListFvMesh changed to dictionary based input
4) Add Time reference access to sixDof restraints
5) Add drivenLinearMotion to solidBodyMotionFunctions.
- synchronization, reduction only makes sense on processor-coupled
patches. Since cyclic baffles are within a single processor domain,
they are not reduced. So need to skip the sanity test for these.
- the use of 'paraview --version' can be fail if the build host
doesn't have the necessary graphics. For this case, try to obtain
the ParaView API number from the associated include directory.
- the read offset missed the tag_ member entirely and thus the entire
particle information would be corrupt (incorrectly interpreted) as
well as potential violation of adjacent (trailing) memory locations.
- allows some internal handling for reading dissimilar storage types.
Eg, scalars written as float (WM_SP), but read as double (WM_DP)
- reading binary parcel coordinates with dissimilar storage types is
still pending
- change contiguous from a series of global functions to separate
templated traits classes:
- is_contiguous
- is_contiguous_label
- is_contiguous_scalar
The static constexpr 'value' and a constexpr conversion operator
allow use in template expressions. The change also makes it much
easier to define general traits and to inherit from them.
The is_contiguous_label and is_contiguous_scalar are special traits
for handling data of homogeneous components of the respective types.
- in addition to m() and n(), provide Matrix mRows()/nRows(), nCols()
methods. These provide unambiguous access names.
'mRows()' == for internal consistency with MatrixSpace.
'nRows()' == a commonly used naming.
- with 1906, OpenFOAM is purely C++ code and the last toolchain bits C
code have been avoided. Thus relax the wmake C rule for including
WM_COMPILE_OPTION. This makes it much easier to add different
compiler options with fewer files.
For example, for Broadwell-specific options:
cd wmake/rules/linux64Gcc
cp c++Opt c++OptBdw
edit this file and then use WM_COMPILE_OPTION=OptBdw
- ensure that WM_COMPILE_OPTION is always non-empty
- a top-level cloud::nParcels() virtual, which is overloaded by the
first level of Cloud inheritance. This permits quick determination of
cloud sizes, even when retrieved from registry with the base level.
Eg,
cloud* cldPtr = mesh.cfindObject<cloud>("myCloud");
label nParcels = (cldPtr ? cldPtr->nParcels() : 0);
- make writeLagrangianPositions on by default unless explicitly
disabled in the InfoSwitches.
Flag output errors (where neither coordinates nor positions are
written) with Fatal.
- additional IOField helper functions in cloud
STYLE: simplify iterator inheritance
- can now specify literal matches for sub-dictionary methods:
isDict(key, keyType::REGEX)
optionalSubDict(key, keyType::REGEX)
subDict(key, keyType::REGEX)
subOrEmptyDict(key, keyType::REGEX, mandatory)
There is no change in behaviour of the methods, just the search option
is now exposed as an optional parameter.
NOTE: minor breaking change for subOrEmptyDict()
old: subOrEmptyDict(key, bool=false)
new: subOrEmptyDict(key, keyType::option=keyType::REGEX, bool=false)
This affects code that previously explicitly set the bool parameter.
Within OpenFOAM itself, this only affected a single file:
KinematicCloud.C
- this is principally for cases where reduced indentation is desired,
such as when streaming to a memory location. If the indentation size
is zero or one, only a single space will be used to separate the
key/value.
This change does not affect the stream allocation size, since the
extra data falls within the padding.
ENH: relocate label/scalar sizes from Istream to IOstream.
- could allow future use for output streams as well?
Due to padding, reorganization has no effect on allocated size
of output streams.
STYLE: add read/write name qualifier to beginRaw, endRaw
- removes ambiguity for bi-directional streams
STYLE: fix inconsistent 'const' qualifier on std::streamsize
- base Ostream was without const, some derived streams with const
- allows full recovery of allocated space, not just addressable range.
This can be particularly useful for code patterns that repeatedly
reuse the same buffer space. For example,
DynamicList<char> buf(1024);
// some loop
{
OListStream os(std::move(buf));
os << ...
os.swap(buf);
}
Can read back from this buffer as a second operation:
{
UIListStream is(buf);
is >> ...
}
- When building OpenFOAM for different platform combinations
(single/double, int32/int64) the build information that is compiled
into the OpenFOAM lib can become out of sync.
This is because the update trigger (wmakeBuildInfo -check) is
independent of the targetted platform. The added file
'src/OpenFOAM/Alltouch' provides a direct means of forcing a rebuild
of the version information. Eg,
src/OpenFOAM/Alltouch
wmake src/OpenFOAM
Also provide an additional 'wmakeBuildInfo -remove' to forcibly
remove META-INFO/build-info, if that is desired.
- symmetric with writeRaw() etc for the output stream. These are
methods that are not required by normal users, but which provide
a finer granularity for reading.
- additional information about the current stream position when
endList fails. This may help when tracing errors.
STYLE: change return type of beginRaw()/endRaw() to bool
- was of type Ostream& for output, but return value was unused.
Having bool may be better for encapsulating logic
STYLE: remove unused Istream::readEndBegin() function
- in InterfaceCompositionPhaseChangePhaseSystem, the mass transfer
rates are updated as a side-effect of the massTransfer() method,
which makes these fields non-const.
- adapted openfoam.org code. Original commit message:
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.
- treat the faces that would be exposed on a subset as boundary faces
for the erosion algorithm
STYLE: adjust code for consistency between isoSurfaceCell and isoSurfaceTopo
- the behaviour of std::rename with overwriting an existing file is
implementation dependent:
- POSIX: it overwrites.
- Windows: it does not overwrite.
- for Windows need to use the ::MoveFileEx() routine for overwriting.
More investigation is needed for proper handling of very long names.
- this cannot be left as a configurable value (on windows), since it
needs to be enabled even prior to reading the etc/controlDict file,
in case the OpenFOAM installation path itself contains spaces.
- add an 'isoAlgorithm' keyword to distance surface and cutting plane
to advance further testing of the isoSurfaceTopo algorithm.
Does not yet handle the full spectrum of bound boxes, cellZones etc.
- unfriend HashSet, HashTable IO operators
- global min(), max(), minMax() functions taking a labelHashSet and an
optional limit. For example,
labelHashSet set = ...;
Info<< "min is " << min(set) << nl;
Info<< "max (non-negative) " << max(set, 0) << nl;
- make HashTable iterator '->' dereferencing more consistent by also
supporting non-pointer types as well.
- read HashTable values in-situ to avoid copying
- the Enum::readEntry() method was previously as bit sloppy with
respect to the enumeration that it accepted. If the input was
non-mandatory, typos would go unnoticed. Now tighten things so that
if an enumeration is found, it must also be valid.
STYLE: remove unused/deprecated Enum::lookupOrFailsafe() method
- this was only used in a few places internally in 1712 and 1806 but
has since then been superseded by getOrDefault() with an optional
'failsafe' flag.
- An identity is often useful when generating connectivity and offset
information.
- The optional repeat value for vtk::write() allows it to also be used
as a fill method.
- when searching for a file that may not actually exist,
the short-cut optimization could lead to the 'constant' directory
being ignored.
STYLE: simplify logic in points0MotionSolver::points0IO
- the scotch interface still uses non-const pointers when passing in
values. For the ConstPrecisionAdaptor this means that we need to cheat
with a constCast(). Using ref() will rightly trigger complaints about
trying to modify a const object.
Modifications to help avoid inadvertent overwriting of tutorialsTest:
- new '-force' option to overwrite existing directory
- generate a 'tutorialsTest/Alltest' script that disallows the
possibilty of self-recursion
- reverse mapping for the original point ids. This can be useful
when searching a subset of points, but needing to store access to
the original point index.
- move constructor.
- Allow use/not-use subset as an optional constructor argument for
more convenient caller logic.
- changed for 1906 to have a regIOobject always cleanup its
objectRegistry entry. No need to explicitly 'release' ownership
for this to now happen.
- doxygen formatting for MeshObject
- add a '-SPDP' option
- remove the '-archOption' for forcing a '-m32' build on 64-bit
architecture, which is now considered too obscure.
Must edit files manually if this option is really required.
The following three synthetic turbulence inflow boundary conditions are
examined through single-cell-domain smooth-wall plane channel flow setup:
- turbulentDFSEMInlet
- turbulentDigitalFilterInlet variant=digitalFilter
- turbulentDigitalFilterInlet variant=reducedDigitalFilter
The examinations are performed in terms of the first-/second-order turbulence
statistics provided by (Moser et al., (1999)) doi.org/10.1063/1.869966
from smooth-wall plane channel flow direct numerical simulations at Re=395.
Serial executing:
./Allrun
Parallel (decompositionMethod=scotch) executing:
./Allrunparallel
A set of libraries and executables creating a workflow for performing
gradient-based optimisation loops. The main executable (adjointOptimisationFoam)
solves the flow (primal) equations, followed by the adjoint equations and,
eventually, the computation of sensitivity derivatives.
Current functionality supports the solution of the adjoint equations for
incompressible turbulent flows, including the adjoint to the Spalart-Allmaras
turbulence model and the adjoint to the nutUSpaldingWallFunction, [1], [2].
Sensitivity derivatives are computed with respect to the normal displacement of
boundary wall nodes/faces (the so-called sensitivity maps) following the
Enhanced Surface Integrals (E-SI) formulation, [3].
The software was developed by PCOpt/NTUA and FOSS GP, with contributions from
Dr. Evangelos Papoutsis-Kiachagias,
Konstantinos Gkaragounis,
Professor Kyriakos Giannakoglou,
Andy Heather
and contributions in earlier version from
Dr. Ioannis Kavvadias,
Dr. Alexandros Zymaris,
Dr. Dimitrios Papadimitriou
[1] A.S. Zymaris, D.I. Papadimitriou, K.C. Giannakoglou, and C. Othmer.
Continuous adjoint approach to the Spalart-Allmaras turbulence model for
incompressible flows. Computers & Fluids, 38(8):1528–1538, 2009.
[2] E.M. Papoutsis-Kiachagias and K.C. Giannakoglou. Continuous adjoint methods
for turbulent flows, applied to shape and topology optimization: Industrial
applications. 23(2):255–299, 2016.
[3] I.S. Kavvadias, E.M. Papoutsis-Kiachagias, and K.C. Giannakoglou. On the
proper treatment of grid sensitivities in continuous adjoint methods for shape
optimization. Journal of Computational Physics, 301:1–18, 2015.
Integration into the official OpenFOAM release by OpenCFD
- now only needed when specify compiling -m32 on a 64-bit system.
Internally use the __SIZEOF_LONG__ compiler macro (gcc, icc, llvm)
to define when long is actually an int32_t.
- remove make target for wmdep (flex-based scanner), which eliminates
a bootstrap dependency on flex.
As of OpenFOAM-v1806, wmdep has been superseded by wmdepend
(ragel-based scanner).
- replace dirToString binary with shell/awk equivalent for simpler
maintenance. The utility is very rarely used (auto scanning to
create Make/files) so there is no performance difference.
Integration of VOF MULES new interfaces. Update of VOF solvers and all instances
of MULES in the code.
Integration of reactingTwoPhaseEuler and reactingMultiphaseEuler solvers and sub-models
Updating reactingEuler tutorials accordingly (most of them tested)
New eRefConst thermo used in tutorials. Some modifications at thermo specie level
affecting mostly eThermo. hThermo mostly unaffected
New chtMultiRegionTwoPhaseEulerFoam solver for quenching and tutorial.
Phases sub-models for reactingTwoPhaseEuler and reactingMultiphaseEuler were moved
to src/phaseSystemModels/reactingEulerFoam in order to be used by BC for
chtMultiRegionTwoPhaseEulerFoam.
Update of interCondensatingEvaporatingFoam solver.
- overload the ref() method to allow modification of the referenced
(non-const) field directly. Same as constCast(), but less typing
and less prone to error.
- construct ConstPrecisionAdaptor from tmp for improved efficiency.
- the updated surface writers must be explicitly tagged as being
Time-aware (useTimeDir) to have them splice Time (in this case freq)
into the output path.
The older writers worked in the opposite way. They extracted a time
value from the naming of the output directory (which was fragile).
- If applied:
This commit allows the user to compute:
- the Lamb vector (https://en.wikipedia.org/wiki/Lamb_vector),
- on-the-fly or via postProcess utility
- for a given volVectorField (one per functionObject entry)
- Why:
The motivation is the literature-reported quantitative connection
between the Lamb vector (divergence) and the spatially localised
instantaneous fluid motions, e.g. high- and low-momentum fluid
parcels, which possess considerable level of capacity to affect
the rate of change of momentum, and to generate forces such as drag.
- Verification:
- Smooth-wall plane channel flow case (Moser et al. 1999) by
# Curtis et al. (2008) On the Lamb vector divergence
in Navier–Stokes flows, doi:10.1017/S0022112008002760
- What's next:
- The verification-show case
- Extended code guide entry titled "Lamb vector"
- remove registration and ownership before deleting a regIOobject
from within objectRegistry to avoid possible recursion.
- regIOobject destructor now removes any registered object from
registry regardless if ownedByRegistry or not. It also removes
always removes the ownership flag to avoid possible recursion.
- the regIOobject::checkOut() now unconditionally clears file watches.
These will only be there if the object is registered (a no-op for an
unregistered object), but this additional safety is needed to manage
case where the registration has been modified elsewhere (eg, by the
objectRegistry).
ENH: define addition/subtraction operations for scalar and complex
- required since construct complex from scalar is explicit
- additional tests in Test-complex
- forces c++DBUG='-DFULLDEBUG -g -O0' for the compilation, to allow
localized debugging during development without file editing and
while retaining the WM_COMPILE_OPTION (eg, Opt)
Note that switching between 'wmake' and 'wmake -debug' will not
cause existing targets to be rebuilt. As before, these are driven by
the dependencies. An intermediate wclean may thus be required.
- additional coefficients:
- Side force coefficient: direction in curl(lift,drag),
- Yaw moment coefficient: rotation axis in dir(lift)
- Roll moment coefficient: rotation axis in dir(drag)
Order of output
- forces(drag,side,lift)
- moments(roll,pitch,yaw)
Note
- For force coeffs, front and rear axles' contributions are computed
Calculates and outputs the pressure fields p_rgh and ph_rgh based on the
option that was previously hard-coded in the fireFoam solver
Usage
Example of function object specification to calculate hydrostatic pressure:
\verbatim
hydrostaticPressure1
{
type hydrostaticPressure;
libs ("libinitialisationFunctionObjects.so");
...
}
\endverbatim
Where the entries comprise:
\table
Property | Description | Required | Default value
log | Log to standard output | no | yes
p_rgh | Name of p_rgh field | no | p_rgh
ph_rgh | Name of ph_rgh field | no | ph_rgh
pRef | Name of pressure ref field | no | pRef
rho | Name of density field | no | rho
U | Name of velocity field | no | U
gh | Name of gravity*height volume field | no | gh
ghf | Name of gravity*height surface field | no | ghf
nCorrectors | Number of correctors when solving ph_rgh | no | 5
\endtable
Note
Calculates the hydrostatic pressure on construction/re-initialisation;
the execute and write functions are not used.
- generalize identity matrix constructors for non-scalar types
- add constructors using labelPair for the row/column sizing information.
For a SquareMatrix, this provides an unambiguous parameter resolution.
- reuse assignment operators
STYLE: adjust matrix comments
- adjust naming of quaternion 'rotationSequence' to be 'eulerOrder'
to reflect its purpose.
- provide rotation matrices directly for these rotation orders in
coordinateRotations::euler for case in which the rotation tensor
is required but not a quaternion.
Modified revert of commit 6c6f777bd5.
- The "alphaContactAngleFvPatchScalarField" occurs in several
places in the code base:
- as abstract class for two-phase properties
- in various multiphase solvers
To resolve potential linking conflicts, renamed the abstract class
as "alphaContactAngleTwoPhaseFvPatchScalarField" instead.
This permits potential linking of two-phase and multi-phase
libraries without symbol conflicts and has no effect on concrete
uses of two-phase alphaContactAngle boudary conditions.
- support move insert/set and emplace insertion.
These adjustments can be used for improved memory efficiency, and
allow hash tables of non-copyable objects (eg, std::unique_ptr).
- extend special HashTable output treatment to include pointer-like
objects such as autoPtr and unique_ptr.
ENH: HashTable::at() method with checking. Fatal if entry does not exist.
All remote contributions to interpolation stencils now
get added as 'processor' type lduInterfaces. This guarantees
a consistent matrix, e.g. initial residual is normalised to 1.
Second change is the normalisation of the interpolation discretisation
which uses the diagonal from the unmodified equation. This helps
GAMG.
- for codedFunctionObject and CodedSource the main code snippets
were not included in the SHA1 calculation, which meant that many
changes would not be noticed and no new library would be compiled.
As a workaround, a dummy 'code' entry could be used solely for the
purposes of generating a SHA1, but this is easily forgotten.
We now allow tracking of the dynamicCodeContext for the coded
objects and append to the SHA1 hasher with specific entries.
This should solve the previous misbehaviour.
We additionally add information about the ordering of the code
sections. Suppose we have a coded function object (all code
segments are optional) with the following:
codeExecute "";
codeWrite #{ Info<< "Called\n"; #};
which we subsequently change to this:
codeExecute #{ Info<< "Called\n"; #};
codeWrite "";
If the code strings are simply concatenated together, the SHA1 hashes
will be identical. We thus 'salt' with their semantic locations,
choosing tags that are unlikely to occur within the code strings
themselves.
- simplify the coded templates with constexpr for the SHA1sum
information.
- Correct the CodedSource to use 'codeConstrain' instead of
'codeSetValue' for consistency with the underlying functions.
- amalgamate dlSym() and dlSymFound() into a single dlSymFind() backend
with optional 'required' argument. This makes it possible to
query and assign at once.
- previously would have different SHA1 depending on whether the
string was a C-string, a C++-string or if the SHA1 was calculated
directly or via the OSHA1stream.
- SHA1("string")
- OSHA1stream << "string";
- OSHA1stream << string("string");
By avoiding string quoting on output, they now all deliver the same
result. This also means that the following will no longer change the SHA1
content, since it does not add anything:
osha<< string() << string() << string() << string();
This would have previously add a pair of double quotes each time!
- Eg, with surface writers now in surfMesh, there are fewer libraries
depending on conversion and sampling.
COMP: regularize linkage ordering and avoid some implicit linkage (#1238)
- in case of cell overlapping a patch : set cell to hole always
- in case of cell changing from hole to calculated: set to hole
and continue. Do so before 'flood filling' holes.
Patch supplied by Nicolas Edh.
- unnecessary. Can deduce labelRange from the pair of labels.
These are all the same:
list[labelRange(18,3)] = 100;
list[labelRange{18,3}] = 100;
list[{18,3}] = 100;
Removing the run-time handling of std::initializer_list in favour of
compile-time deduction allows the future use of sliceRange as well.
Eg,
list[sliceRange{18,3,2}] = 100;
list[{18,3,2}] = 100;
- Enhancements provided by Y. Inoue at RIST (http://www.hpci-office.jp)
- Use allToAll to only swap local data (excludes master processor; saves memory)
- Memory saving is noticeable >= 4000 cores
- fix typo in makefiles/info that affected wmake -show-compile-c
- additional safeguard in src/OpenFOAM/Make/options against self-linking.
This is not normally required unless PROJECT_LIBS has been added into
the link stage.
- extracts values from the arch "LSB;label=32;scalar=64" header entry
to provision for managing dissimilar primitive sizes.
Compensate for the additional IOobject members by narrowing the types
for the (objectState, readOption, writeOption) enumerations
- with the changes added in #1256 and corresponding updates to
ThirdParty we can stop exporting these variables:
WM_CC WM_CFLAGS WM_CXX WM_CXXFLAGS WM_LDFLAGS
solaris:
- rename WM_ARCH from SunOS to solaris64 for consistency with wmake/rules
- drop non-64 solaris from wmake/rules
- remove automatic selection of FJMPI. This should be done in the bashrc
or prefs.sh file instead.
- remove old (likely inaccurate) exported flags, rely on wmake -show-xyz
or user config instead
darwin:
- remove '-Ddarwin' from the exported WM_CFLAGS, WM_CXXFLAGS.
Not used elsewhere (ThirdParty)
- the only code location using BiIndirectList are debug sections
within polyTopoChange.
No need to construct/assign directly from a BiIndirectList since
the '()' method provides a simple alternative.
- use an IndirectListBase class for various indirect list types.
- new SortList type
In some places the SortList can be used as a lightweight alternative
to SortableList to have the convenience of bundling data and sort
indices together, but while operating on existing data lists.
In other situations, it can be useful as an alternative to
sortedOrder. For example,
pointField points = ...;
labelList order;
sortedOrder(points, order);
forAll(order, i)
{
points[order[i]] = ...;
}
Can be replaced with the following (with the same memory overhead)
pointField points = ...;
SortList<point> sortedPoints(points);
for (point& pt : sortedPoints)
{
pt = ...;
}
- new SliceList type (#1220), which can be used for stride-based
addressing into existing lists
- change from UpdateableMeshObject to TopologicalMeshObject
- change inheritance order to have MeshObject be registered first
and mark the IOobject descriptor as unregistered
- the objectRegistry destructor seems to be called too late.
Explicitly clear the objectRegistry within the Time destructor to
ensure that it always happens.
- used fallback of 0 instead of the results time.
This discrepancy caused the case file to have two timesets that
only differed by the first (incorrect) entry.
- used fallback of 0 instead of the results time.
This discrepancy caused the case file to have two timesets that
only differed by the first (incorrect) entry.
- when running in serial but within a processor directory,
argList::globalPath() is to be used instead of Time.globalPath()
For other cases there is no difference.
- this is somewhat like labelRange, but with a stride.
Can be used to define slices (of lists, fields, ..) or as a range specifier
for a for-loop. For example,
for (label i : sliceRange(0, 10, 3))
{
...
}
- with the wmake rules we may have some compiler options bound to the
internal compiler variable. For example,
CC = g++ -std=c++11 -m64
c++FLAGS = ...
So shift any flags from CC to CXXFLAGS for the output of
'wmake -show-cxx', 'wmake -show-cxxflags', etc.
This makes it much easier to handle the values correctly elsewhere.
Eg,
CXX="$(wmake -show-cxx)" CXXFLAGS="$(wmake -show-cxxflags)" \
./configure
- provide dedicated detection 'have_ptscotch' function that can be
used after the 'have_scotch' function.
It sets the PTSCOTCH_ARCH_PATH, PTSCOTCH_INC_DIR, PTSCOTCH_LIB_DIR
and helps when the serial and parallel versions are located with
different logic.
- file-local static for saving the old action, which moves system
dependencies out of the header files.
- set/reset of signals as file-local functions
STYLE: use csignal header instead of signal.h
- this adds support for various STL operations including
* sorting, filling, find min/max element etc.
* for-range iteration
STYLE: use constexpr for VectorSpace rank
- similar to the global '/' operator, but taking raw strings and not
performing any stripping.
Was previously a local function within POSIX.C, but it is useful enough
to be in fileName itself.
- having whitespace in fileName can be somewhat fragile since it means
that the fileName components do not necessarily correspond to a
'Foam::word'. But in many cases it will work provided that spaces
are not present in the final portion of the simulation directory
itself.
InfoSwitches
{
// Allow space character in fileName (use with caution)
allowSpaceInFileName 0;
}
- now use doClean=true as default for fileName::validate(). Was false.
Unlike fileName::clean() this requires no internal string rewrite
since the characters are being copied. Also handle any path
separator transformations (ie, backslash => forward slash) at the
same time. This makes it resemble the std::filesystem a bit more.
- can be useful for retrieving the compilation flags for use with other
make systems (eg, cmake)
* wmake -show-compile (C++ not C)
* wmake -show-cxx
* wmake -show-cxxflags
- operators are still incomplete, as are dimensioned fields,
field-fields etc.
- split complexFields into separate complexField, complexVectorField files
- add construction from and conversion to std::complex, which allows
easier wrapping of functions
- add Foam:: functions for complex versions of sin, cos, ...
- The 'used()' method was for transitional compatibility with the now
defunct PackedBoolList.
The canonical method name for returning a labelList of 'on' bits is
toc().
- was historically defined as (1 1), but it is more consistent with
the concept of one to have a real component only.
Now defined as (1 0): 1+0i
STYLE: remove obscure '!' operator for complex conjugate
- either use the member function or the '~' operator
- These are not defined in the C++ standard for cmath, so allow for
compilation without them. Will need to provide replacements in the
future or rework.
- new regExpCxx wrapper for C++11 regex support with drop-in
compatibility with existing code.
- regExpPosix (was regExp), for future phase out in favour of regExpCxx.
- The regExp header will continue to be used for defining an
appropriate typedef corresponding to the preferred implementation.
- instead of deciding beforehand if a surface format requires a separate
geometry file (or if a geometry file should be written if no fields were
written) now determine afterwards if something was written.
This improves the overall reliability (consistency) and is more
convenient for the caller as well.
- PtrDynList support for move append list:
can be used to concatenate pointer lists into a single one
- include resize in PtrDynList squeezeNull as being a natural
combination
- support sorting operations for pointer lists (PtrListOps)
- comparison operator, for sorting based on the position of the origin.
- allow modification of the origin.
- zero-initialise for null constructor: base components are vectors
and cheap to initialise.
- 'unfriend' the output operator: it uses public access methods
- remove writeGeometry() in favour of write() and make it pure virtual
so that all writers must explicitly deal with it.
- establish proxy extension at construction time and treated as an
invariant thereafter. This avoids potentially surprising changes in
behaviour when writing.
- with -mcpu=native for automatic detection and -armpl for linking in
the performance libraries
STYLE: relocate -mcpu into compiler instead of compiler-flags (#1225)
- prior to sampledSurface supporting different interpolation schemes a
workaround means was used to simulate cellPoint -> face
interpolation, with averaging of vertex interpolation.
We instead now use cellPoint interpolation directly for the face
values when 'interpolate=true'.
- normally findInstance will 'bottom out' with the constant directory
while doing its reverse time search. This mechanism however fails
when searching for negative start values (if there are none in the
list). Add additional logic for this so that constant will also be
used in these situations.
Note: to have decomposePar work for all times, may need the -constant option
to trigger the proper time list.
- construct from positions
- reset positions, minEdgeLen, find grid index
ENH: add accessor for obtaining the size of a single i-j-k dimension
- eg, obtain the 'i' dimension with any of these methods:
ijkAddr.size(vector::X)
ijkAddr.sizes().x()
ijkAddr.sizes()[0]
- this is a simple container for fields with i-j-k addressing.
It does not support field operations directly, but is primarily
intended to be used when assembling field information with i-j-k
logic. After assembly, the field can be transferred to a regular
field for normal operations. Eg,
IjkField<scalar> assemble({15, 16, 200});
// .. fill in i-j-k fields
Field<scalar> final(std::move(assemble));
assemble.clear(); // be pedantic
...
- While a rectilinear mesh can be created with blockMesh, not every mesh
created with blockMesh will satisfy the requirements for being a
rectilinear mesh.
This alternative to blockMesh uses a single block that is aligned
with the xy-z directions and specifications of the control points,
mesh divisions and expansion ratios. For example,
x
{
points ( -13.28 -0.10 6.0 19.19 );
nCells ( 10 12 10 );
ratios ( 0.2 1 5 );
}
y { ... }
z { ... }
With only one block, the boundary patch definition is simple and the
canonical face number is used directly. For example,
inlet
{
type patch;
faces ( 0 );
}
outlet
{
type patch;
faces ( 1 );
}
sides
{
type patch;
faces ( 2 3 );
}
...
- After a mesh is defined, it is trivial to retrieve mesh-related
information such as cell-volume, cell-centres for any i-j-k location
without an actual polyMesh.
STYLE: remove -noFunctionObjects from blockMesh
- no time loop, so function objects cannot be triggered anyhow.
- PtrList::release() method.
Similar to autoPtr and unique_ptr and clearer in purpose than
using set(i,nullptr)
- Construct from List of pointers, taking ownership.
Useful when upgrading code. Eg,
List<polyPatch*> oldList = ...;
PtrList<polyPatch> newList(oldList);
...
BUG: incorrect resizing method names (PtrDynList) in previously unused code
- this functionality was originally added to allow sampling of volume
fields onto a surface in order to perform calculations on them.
However, the sampling framework essentially mirrored the
sampledSurface, but was less complete.
It is now possible to store sampled surfaces on a registry and
do calculation with their fields. This is the preferred method,
and thus removing the surfMeshSample duplicate code.
- previously wrapped raw points/faces with a meshedSurfRef on input,
but now handle the raw -> meshedSurf logic directly within
surfaceWriter to avoid holding references to temporaries
Since the updated meshedSurfRef is now modifiable, it can be used
directly as a redirection mechanism within surfaceWriter.
- add explicit close() in destructor
- A negative expansion ratio is geometrically invalid and will
normally cause issues (FatalError).
However, we can trap this type of input and interpret it as the
inverse expansion ratio - ie, the expansion ratio in the opposite
direction. This can be especially convenient when generating a blockMesh
with a symmetrical expansion. It permits using the same expansion
ratio (with a sign change) instead of providing the reciprocal values
manually.
COMP: revert demand-driven point creation in blockMesh (db9b35b50d)
- appears to have caused a dangling reference on some systems
ENH: add a lightweight ijkAddressing class
- it can be used for an i-j-k to linear lookup of meshes or fields,
where applicable.
Velocity boundary condition generating synthetic turbulence-alike
time-series for LES and DES turbulent flow computations.
To this end, two synthetic turbulence generators can be chosen:
- Digital-filter method-based generator (DFM)
\verbatim
Klein, M., Sadiki, A., and Janicka, J.
A digital filter based generation of inflow data for spatially
developing direct numerical or large eddy simulations,
Journal of Computational Physics (2003) 186(2):652-665.
doi:10.1016/S0021-9991(03)00090-1
\endverbatim
- Forward-stepwise method-based generator (FSM)
\verbatim
Xie, Z.-T., and Castro, I.
Efficient generation of inflow conditions for large eddy simulation of
street-scale flows, Flow, Turbulence and Combustion (2008) 81(3):449-470
doi:10.1007/s10494-008-9151-5
\endverbatim
In DFM or FSM, a random number set (mostly white noise), and a group
of target statistics (mostly mean flow, Reynolds stress tensor profiles and
length-scale sets) are fused into a new number set (stochastic time-series,
yet consisting of the statistics) by a chain of mathematical operations
whose characteristics are designated by the target statistics, so that the
realised statistics of the new sets could match the target.
Random number sets ---->-|
|
DFM or FSM ---> New stochastic time-series consisting
| turbulence statistics
Turbulence statistics ->-|
The main difference between DFM and FSM is that the latter replaces the
streamwise convolution summation in DFM by a simpler and a quantitatively
justified equivalent procedure in order to reduce computational costs.
Accordingly, the latter potentially brings resource advantages for
computations involving relatively large length-scale sets and small
time-steps.
pointNormals calculation gets triggered through processorfvPatches
so on processors that don't have these bypass this. This leads
to the global reduction hanging.
- avoid potential ambiguities in naming of mesh faces/edges
vs. block faces/edges
- additional methods characterizing the number of faces
(internal, boundary, total) associated with a blockDescriptor
- cellLabel() accessor and checkIndex() methods
- restore demand-driven behaviour of block, cache the calculated cells
and refactor generation of block boundary faces to improve potential
reuse.
- construct from MinMax, optional start index for identity factory
method to match Foam::identity()
- use GREAT instead of VGREAT in inverted scalarRange.
Consistent with boundBox - to reduce the potential of overflow
if calculating the span.
- add min()/max() methods to labelRange
- Extended runTimePostProcessing to include access to "live"
simulation objects such a geometry patches and sampled surfaces
stored on the "functionObjectObjects" registry.
- Add 'live' runTimePostProcessing of cloud data.
Extracts position and fields from the cloud via its objectRegistry writer
- For the "live" simulation objects, there are two new volume filters
that work directly with the OpenFOAM volume fields:
* iso-surface
* cutting planes
Both use the VTK algorithms directly and support multiple values.
Eg, can make multiple iso-levels or multiple planes parallel to each
other.
- When VTK has been compiled with MPI-support, parallel rendering will
be used.
- Additional title text properties (shadow, italic etc)
- Simplified handling of scalar-bar and visibility switches
- Support multiple text positions. Eg, for adding watermark text.
- fits better into the general sampling framework, improves flexibilty
and allows code reduction.
ENH: include surface fields on sampledSurfaces that support it
- The writers have changed from being a generic state-less set of
routines to more properly conforming to the normal notion of a writer.
These changes allow us to combine output fields (eg, in a single
VTK/vtp file for each timestep).
Parallel data reduction and any associated bookkeeping is now part
of the surface writers.
This improves their re-usability and avoids unnecessary
and premature data reduction at the sampling stage.
It is now possible to have different output formats on a per-surface
basis.
- A new feature of the surface sampling is the ability to "store" the
sampled surfaces and fields onto a registry for reuse by other
function objects.
Additionally, the "store" can be triggered at the execution phase
as well
- when windows portable executables (.exe or .dll) files are loaded,
their dependent libraries not fully loaded. For OpenFOAM this means
that the static constructors which are responsible for populating
run-time selection tables are not triggered, and most of the run-time
selectable models will simply not be available.
Possible Solution
=================
Avoid this problem by defining an additional library symbol such as
the following:
extern "C" void libName_Load() {}
in the respective library, and tag this symbol as 'unresolved' for
the linker so that it will attempt to resolve it at run-time by
loading the known libraries until it finds it. The link line would
resemble the following:
-L/some/path -llibName -ulibName_Load
Pros:
- Allows precise control of forced library loading
Cons:
- Moderately verbose adjustment of some source files (even with macro
wrapping for the declaration).
- Adjustment of numerous Make/options files and somewhat ad hoc
in nature.
- Requires additional care when implementing future libraries and/or
applications.
- This is the solution taken by the symscape patches (Richard Smith)
Possible Solution
=================
Avoid this problem by simply force loading all linked libraries.
This is done by "scraping" the information out of the respective
Make/options file (after pre-processing) and using that to define
the library list that will be passed to Foam::dlOpen() at run-time.
Pros:
- One-time (very) minimal adjustment of the sources and wmake toolchain
- Automatically applies to future applications
Cons:
- Possibly larger memory footprint of application (since all dependent
libraries are loaded).
- Possible impact on startup time (while loading libraries)
- More sensitive to build failures. Since the options files are
read and modified based on the existence of the dependent
libraries as a preprocessor step, if the libraries are initially
unavailable for the first attempt at building the application,
the dependencies will be inaccurate for later (successful) builds.
- This is solution taken by the bluecape patches (Bruno Santos)
Adopted Solution
================
The approach taken by Bruno was adopted in a modified form since
this appears to be the most easily maintained.
Additional Notes
================
It is always possible to solve this problem by defining a corresponding
'libs (...)' entry in the case system/controlDict, which forces a dlOpen
of the listed libraries. This is obviously less than ideal for large-scale
changes, but can work to resolve an individual problem.
The peldd utility (https://github.com/gsauthof/pe-util), which is
also packaged as part of MXE could provide yet another alternative.
Like ldd it can be used to determine the library dependencies of
binaries or libraries. This information could be used to define an
additional load layer for Windows.
- reduces some dictionary clutter and probably looks less confusing
than having an ending that may not correspond to the current OS.
Eg, "fvOptions" instead of "libfvOptions.so", "libfvOptions.dylib" ...
- convenience dlOpen method for multiple files
- add iterators, begin/end, empty() methods for STL behaviour.
Use standard algorithms where possible
* std::fill, std::copy
* std::min_element, std::max_element
- access methods consistent with other OpenFOAM containers:
* data(), cdata(), uniform()
- Use ListPolicy to impose output line breaks
- Can recover matrix storage for re-use elsewhere.
For example, to populate values with 2D i-j addressing and later
release it as flat linear storage.
- construct/assign moveable
- added minMax() function for Matrix
- additional inplace +=, -=, *=, /= operations
- add named methods at() and rowData() to Matrix.
Allows a better distinction between linear and row-based addressing
- low-level matrix solve on List/UList instead of Field
- can be used to check the validity of input values.
Example:
dict.getCheck<label>("nIters", greaterOp1<label>(0));
dict.getCheck<scalar>("relax", scalarMinMax::zero_one());
- use 'get' prefix for more regular dictionary methods.
Eg, getOrDefault() as alternative to lookupOrDefault()
- additional ops for convenient construction of predicates
ENH: make dictionary writeOptionalEntries integer
- allow triggering of Fatal if default values are used
ENH: additional scalarRange static methods: ge0, gt0, zero_one
- use GREAT instead of VGREAT for internal placeholders
- additional MinMax static methods: gt, le
- in addition to managing different vendors and versions, it may also
be necessary or desirable to have a particular variant
(eg, profiling, release, etc).
Devise a new meaningful name for the variant and create a
corresponding wmake rule.
Eg, SYSTEMOPENMPI-profiling with a corresponding
"wmake/rules/linux64Gcc/mplibSYSTEMOPENMPI-profiling" file
that has suitable content for your system.
CONFIG: intel-mpi use intel64/ paths only for config and wmake rules (#1153)
- previously adjusted the config files, but missed the changes
required for the wmake rules too.
Now simply migrate to using "intel64/{include,bin,lib}"
instead of the older naming "{include,bin,lib}64"
These changes work since at least intel-mpi 2015 (5.x), but possibly
earlier as well
- This simple container provides a means of storing faces/points
(ie, surfaces) with registered dimensioned fields.
The main registry is used to hold face-based data, a secondary
sub-registry is used to hold point-based data. This allows the same
name for CellData and PointData fields without name collisions.
ENH: Several modifycations to avoid erroneuos rays to be shot
from wrong faces.
ENH: Updating tutorials and avoiding registration of the
coarse singleCellFvMesh
Adding solarLoad tutorial case simpleCarSolarPanel
ENH: Changes needed for the merge
- was WM_PROJECT_API in the environment and FOAM_API in dictionaries.
Make these both consistently FOAM_API.
This is a non-breaking change, since the value of WM_PROJECT_API
(added in 1812) and/or FOAM_API is purely informative.
For the current correct values, always use
* foamEtcFile -show-api
* wmakeBuildInfo -show-api
- If using a non-clang compiler suite (gcc, intel, etc) the additional
lbraries required for mesa with llvm pipelines may not be found.
Provide a mesa_llvm configuration with in the 'vtk' config file.
Can use the usual types of settings
* mesa_llvm=llvm-4.0.1
* mesa_llvm=none
* mesa_llvm=system
- Note: mpich now builds libmpi.so instead of libmpich.so
- define both -DMPICH_SKIP_MPICXX and -DOMPI_SKIP_MPICXX regardless of
using openmpi or mpich. This simplifies the files and does not harm.
- previously just removed duplicate literals, but now remove any
duplicates.
- Replace previous wordHashSet implementation with a linear search
instead. The lists are normally fairly small and mostly just have
unique entries anyhow. This reduces the overall overhead.
- simplifies their use when reordering lists etc.
(word, fileName, keyType, wordRe)
- "unfriend" IO operators for string types. They require no internal access
- add compile/uncompile methods to keyType for symmetry with wordRe
- when outputting keyType/wordRe, be more explicit about them using
writeQuoted()
- delay dereferencing of optional subRegion entries until an
objectRegistry is required.
This improves usabilty when reference objects do not yet exist
at the time of construction.
The occurrence is from cells with vertices that are shared between two faces
only (these vertices can originate from hex refinement). Decomposing both faces
can occasionally produce triangles with identical vertices and this results in a
non-manifold edge which triggers the erosion procedure.
Avoided by detecting cells with these special vertices and making sure the tet-decomposition
never uses the same points on the faces using them.
Patch contributed by Mattijs Janssens
- can now safely use labelList::null() instead of emptyLabelList for
return values. No special treatment required for lists.
Possible replacements:
if (notNull(list) && list.size()) -> if (list.size())
if (isNull(list) || list.empty()) -> if (list.empty())
The receiver may still wish to handle differently to distinguish
between a null list and an empty list, but no additional special
protection is required when obtaining sizes, traversing, outputting
etc.
- relocate zone IO from Detail::MeshedSurfaceIOAllocator into surfMesh
directly to allow re-purposing of MeshedSurfaceIOAllocator
- provide meshedSurf::emptySurface zero-sized placeholder implementation
- add concrete implementation of meshedSurf::zoneIds() to simplify
overloading
- previously had a single pointer/value zeros (8 bytes), this meant
that the reinterpret cast to a List would yield a reference that
could be unsafe under certain conditions.
Eg,
const labelList& myList = labelList::null();
Info<< myList.size() << nl; // OK since size is the first parameter
SubList<label>(myList, 0); // Unsafe
The SubList usage is unsafe since it passes in pointer and size into
the underlying UList. However, the pointer from the labelList::null()
will be whatever happens to be around in memory immediately after the
NullObject singleton. This is mostly not a problem if the List size
is always checked, but does mean that the data pointer is rather
dubious.
- Increase the size of the nullObject singleton to 32 bytes of zeros
to ensure that most reinterpret casting will not result in objects
that reference arbitrary memory.
The 32-byte data size is rather arbitrary, but covers most basic
containers.
- The findObject() methods are template-typed and used to locate a
particular Type/name combination.
Eg,
volScalarField* ptr = obr.findObject<volScalarField>("xyz");
- The findIOobject() methods are un-typed and use the name only.
Eg,
regIOobject* ptr = obr.findIOobject("xyz");
The typed versions will be most commonly used, but the un-typed lookup
can be useful in a templating.
- Simplified findObject* methods to use findIOobject* as the backend.
- similar to what erase() does, but as a mutable operation (#1180)
- replace basicThermo lookupAndCheckout (commit 880c98757d) with
the new objectRegistry::checkOut() method.
- implemented as lazy evaluation with an additional update() method.
This avoids unnecessary changes until the values are actually
required.
- apply mesh motion changes for momentum, volFieldValue,
specieReactionRates function objects
- changed ensightOutput from a class solely comprising static methods to
a namespace and added in sub-namespaces Detail and Serial.
This makes it easier to "mix-in" functions at different levels.
Refactored and combined some serial/parallel code where possible.
The general ensightOutput namespace has now shifted to be in the
fileFormats lib, while leaving volField outputs in the conversion lib
and cloud outputs in the lagrangian-intermediate lib.
The ensightCloud namespace is now simply folded into the new
ensightOutput namespace.
These changes clean up some code, reduce fragmentation and
duplication and removes the previous libconversion dependency for
sampling.
- use int for ensight nTypes constexpr
Note: issue #1176 is unaffected except for the change in file name:
ensightOutputTemplates.C -> ensightOutputVolFieldTemplates.C
- improved the selection mechanism to include using a bitSet
cell selection (more efficient and convenient).
Use templated implementation internally to remove the previous
reliance on a NullObject.
Eg,
#define FOAM_CONFIGURED_PROJECT_ETC "/usr/share/openfoam/etc"
This provides some easy to file patching locations, but is not yet
integrated in the build system at all.
- in some circumstances we need to pass a bool value upwards to the
caller and know if the true/false value was set based on real input
or is a default value.
Eg, in the object::read() we might normally have
enabled_(dict.readIfPresent(key, true));
but would lose information about why the value is true/false.
We can change that by using
enabled_(dict.readIfPresent<Switch>(key, Switch::DEFAULT_ON));
After which we can use this information is testing.
if
(
child.enabled().nonDefault()
? child.enabled()
: parent.enabled()
)
{ ... }
And thus enable output if the parent requested it explicitly or by
default and it has not been explicitly disabled in the child.
No difference when testing as a bool and the text representation
of DEFAULT_ON / DEFAULT_OFF will simply be "true" / "false".
ENH: add construction of Switch from dictionary (similar to Enum)
Previously silently accepted '-o' as being equivalent to '-output',
but the former could be misinterpreted meaning an output file (which
it is not) instead of an output directory.
- instead of
WM_COMPILER=GccKNL WM_COMPILE_OPTION=Opt
-> linux64GccKNLDPInt32Opt
now specify
WM_COMPILER=Gcc WM_COMPILE_OPTION=OptKNL
-> linux64GccDPInt32OptKNL
This makes it easier (and more obvious) for adding different tweaks
without needing to generate too many files.
Eg,
cd wmake/rules/linux64Gcc
cp cOpt cOptBdw
cp c++Opt c++OptBdw
edit these two files and then use WM_COMPILE_OPTION=OptBdw
CONFIG: provide some default c/c++ flags in General compiler rules
- can make is easier when deriving new compile options, and ensures
that '-02' is enabled as an initial default.
- finds the correct root directory location before creating
the lnInclude directory
Eg,
from within something like src/finiteVolume/fields/fvPatchFields/..
wmakeLnInclude -update -root
it backtracks to find the top-level directory with Make/
and makes the lnInclude directory there:
Using /home/mark/openfoam/OpenFOAM-plus/src/finiteVolume
ln: /home/mark/openfoam/OpenFOAM-plus/src/finiteVolume/lnInclude
- Can result in inadvertent conversions where the user should really
know or check if the pointer is valid prior to using.
- Still have several places to fix that are using the deprecated copy
construct and copy assignment
- changed the sectorCoeffs keyword to 'point' from 'axisPt'
for more similarity with other dictionaries.
Continue to accept 'axisPt' for compatibility.
- now free anything owned by the registry when doing a clear.
- the myriad of other ways to remove items (and potentially leaking)
have not yet been addressed:
* set, erase, retain, filterKeys, filterValues, filterEntries
- Uses the user-specified value for the HTC calculation
{
type externalCoupledTemperature;
outputTemperture fluid; // or wall;
htcRefTemperature user; // or cell (default)
Tref 293.15;
}
- was for parallel compilation across multiple hosts, but less useful
with modern CPUs with higher number of cores and/or hyperthreading.
Fragile use and dependent on a 'lockfile' utility that is not often
installed.
- previously stated that the patch level would be 0, but this would
necessitate many revert commits after merging in the master branch.
It is better to leave the meaning open.
- support for optional 'enabled' keyword to selectively disable a
single sampled surface.
ENH: add sampledSurface::withSurfaceFields() method
- can be used to distinguish which samplers support surface fields.
Currently this is only sampledPatch
- remove unused and deprecated emptyList() casting function.
This function is disllowed by many modern compilers and is no longer
used within OpenFOAM - was deprecated 2018-07.
- this protected method was previously used directly for the list
output and had the check for 2 or more elements in it. Now simply
test the List content and handle the output preference separately.
- introduced a ListPolicy details to make the transition between
a short list (space separated) and a long list (newline separated)
more configurable.
We suppress line breaks for commonly used types that often have
short content: (word, wordRes, keyType).
- was WM_PROJECT_API in the environment and FOAM_API in dictionaries.
Make these both consistently FOAM_API.
This is a non-breaking change, since the value of WM_PROJECT_API
(added in 1812) and/or FOAM_API is purely informative.
For the current correct values, always use
* foamEtcFile -show-api
* wmakeBuildInfo -show-api
- If using a non-clang compiler suite (gcc, intel, etc) the additional
lbraries required for mesa with llvm pipelines may not be found.
Provide a mesa_llvm configuration with in the 'vtk' config file.
Can use the usual types of settings
* mesa_llvm=llvm-4.0.1
* mesa_llvm=none
* mesa_llvm=system
- accidentally introduced by 27c62303ad
STYLE: trial use of brace-initialized dimensionSet
- instead of writing
dimensionedScalar(dimensionSet(1, -2, -2, 0, 0, 0), Zero);
we can use C++11 brace-initialization to bundle the parameters
for the dimensionSet construction and simply write
dimensionedScalar({1, -2, -2, 0, 0, 0}, Zero);
Note the following is incorrect syntax (extra brackets):
dimensionedScalar(({1, -2, -2, 0, 0, 0}), Zero);
- Global functions are unary or combining binary functions, which are
defined in MinMax.H (MinMaxOps.H).
There are also global reduction functions (gMinMax, gMinMaxMag)
as well as supporting 'Op' classes:
- minMaxOp, minMaxEqOp, minMaxMagOp, minMaxMagEqOp
Since the result of the functions represents a content reduction
into a single MinMax<T> value (a min/max pair), field operations
returning a field simply do not make sense.
- Implemented for lists, fields, field-fields, DimensionedField,
GeometricField (parallel reducing, with boundaries).
- Since the minMax evaluates during its operation, this makes it more
efficient for cases where both min/max values are required since it
avoids looping twice through the data.
* Changed GeometricField writeMinMax accordingly.
ENH: clip as field function
- clipping provides a more efficient, single-pass operation to apply
lower/upper limits on single or multiple values.
Examples,
scalarMinMax limiter(0, 1);
limiter.clip(value)
-> returns a const-ref to the value if within the range, or else
returns the appropriate lower/upper limit
limiter.inplaceClip(value)
-> Modifies the value if necessary to be within lower/upper limit
Function calls
clip(value, limiter)
-> returns a copy after applying lower/upper limit
clip(values, limiter)
-> returns a tmp<Field> of clipped values
- in 1812 propagated through the distinction between areaNormal and
unitNormal (issue #885).
In older versions, the normal() always meant the area-normal for
certain of these primitive.
However, the .org version changed this to now return the unit-normal
instead, but with the same method name. Thus add the deprecated
message to avoid future inadvertent uses of normal() without being
certain which one is being meant.
- a valid() method (same as !empty() call) for consistency with other
containers and data types
- a centre() method (same as midpoint() method) for consistency with
other OpenFOAM geometric entities
Had this:
Tuple2() {}
Instead of:
Tuple2() : f_(), s_() {}
which is the same as
Tuple2() = default;
This meant that Tuple2<scalar, scalar>() was not being zero-initialized
- a FixedList is generally small so there is little advantage
in a compact output form for uniform content. Eg, "2{-1}"
By avoiding this compact form we obtain output that is also
consistent with Tuple2, for example.
- make FixedList construct from Istream explicit
- relocate the pair_entry (HashTable) and unary_entry (HashSet) into
the Detail namespace and add output handling.
The output handling at this level removes the reliance on zero::null
output (HashSet) and allows direct support of pointers.
This means that the following now works
HashTable<T*> tbl;
os << tbl;
It also means that we don't need to overload operator<< for
HashPtrTable anymore.
- avoid delete/new when calling HashSet::set(). If the entry already
exists there is no reason to remove it and add another one with the
same content.
STYLE: HashTable iterators now have a val() method
- identical to the object() iterator method, but shorter to type.
- fixed some more places with an explicit AUTO_WRITE.
BUG: revert handling of the readOption. It should not be NO_READ.
In cases where the user a IOobject without specifying read/write, it
defaults to NO_READ anyhow. However, the move constructor can also
be called with empty lists and a read option. This has the same
signature, but obviously will not work with NO_READ.
- identical to found(), which should be used for more consistency.
The contains() is a remnant from when hashedWordList was generalized
from a speciesTable (OCT 2010)
- looks slightly messier without associative arrays, but improves
portability. Should now also work with dash.
STYLE: support wmakeBuildInfo -cmp and -check options as equivalent
- number of particles per parcel info to kinematic cloud
- added turbulent dispersion to basicHeterogeneousReactingParcel
- corrected dhsTrans in MUCSheterogeneousRate::calculate
- added cloud macro system to reactingParcelFoam and fixed calculation
of average particles per parcel
- added progress variable dimension to reacting model (nF)
- added ReactingHeterogeneous tutorial
- provide a lookupOrDefault constructor form, since this is a fairly
commonly used requirement and simplifies the calling sequence.
Before
dimensionedScalar rhoMax
(
dimensionedScalar::lookupOrDefault
(
"rhoMax",
pimple.dict(),
dimDensity,
GREAT
)
);
After
dimensionedScalar rhoMax("rhoMax", dimDensity, GREAT, pimple.dict());
- read, readIfPresent methods with alternative lookup names.
- Mark the Istream related constructors with compile-time deprecated
warnings.
BUG: read, readIfPresent methods not handling optional dimensions (#1148)
- this scripts are largely pre-git era and not used much anymore.
Relocate to a legacy/ sub-directory while we see if there are
actually any still being used.
- the utility had automatic triangulation removed some time ago, but
never changed its name.
- catch old uses with a surfaceMeshTriangulate deprecated script
- can be used as a more natural test on the iterator.
For example, with
HashTable<..> table;
auto iter = table.find(...);
Following are now all equivalent:
1. if (iter != table.end()) ...
2. if (iter.found()) ...
3. if (iter) ...
- similar to autoPtr and unique_ptr. Returns the pointer value without
any checks. This provides a simple way for use to use either
an autoPtr or a tmp for local memory management without accidentally
stealing the pointer.
Eg,
volVectorField* ptr;
tmp<volVectorField> tempField;
if (someField.valid())
{
ptr = someField.get();
}
else
{
tempField.reset(new volVectorField(....));
ptr = tmpField.get();
}
const volVectorField& withField = *ptr;
STYLE: make more tmp methods noexcept
Averages columns of cells for layered meshes.
For each patch face, calculates the average value of all cells attached in
the patch face normal direction, and then pushes the average value back
to all cells in the column.
Useful for channel-like cases where we want to average fields in the
spanwise direction.
Example of function object specification:
columnAverage1
{
type columnAverage;
libs ("libfieldFunctionObjects.so");
...
patches (front side);
fields (U p);
}
Where the entries comprise:
\table
Property | Description | Required | Default value
type | type name: fieldMinMax | yes |
patches | list of patches to collapse onto | yes |
fields | list of fields to process | yes |
\endtable
- this corresponds to 'never match', which may be useful in combination
with -constant selection.
Eg,
surfaceMeshTriangulate -constant -time none
selects only the constant entry and suppresses any automatic time loop
STYLE: adjust help for the standard -times option
- indicate that times can be comma or space separated, since this is
otherwise not apparent. Don't mention semicolon separators in the help
since that just adds even more clutter.
- support .vtp format for geometry, surface, line, cloud.
- use native reader for handling vtk, vtp, obj, stl surface files.
For other formats, use the MeshedSurface (the surfMesh lib) to
handle reading and Foam::vtk::Tools::Patch to handle the
conversion to vtkPolyData. This combination is more memory efficient.
- update tutorial case to include vtp surface geometry
- note that it does not actually triangulate unless necessary, should
probably receive a new name.
- use newer constructs for handling processor/non-processor patch
selection etc.
- for quantities such as face area/normals etc, it can be useful to
calculate directly and avoid the overhead of caching all the values.
STYLE: comments, use HashTable lookup() method in whichPoint()
- this allows more use of the runTimePostProcessing functionObject
that will fail more gracefully if the proper version could not be
built.
The dummy functionObject simply emits a message that it is not available.
- this is identical to either of these solutions:
* getEnv("FOAM_CASE")
* stringOps::expand("<case>")
but with a closer resemblance to argList or Time globalPath(),
which makes the intent clearer.
Avoids using raw strings in the caller, which improves compile-time checks.
Used in situations where a class has no derivation path or other
access to a time registry or command args.
- provide relativePath() for argList and for Time.
These are relative to the case globalPath().
Eg,
Info<< "output: " << runTime.relativePath(outputFile) << nl;
- partial solution for issue #1091
This generates file properties that are case-relative,
Eg,
plane0
{
p
{
file "<case>/postProcessing/plane0/1/p_plane0.vtk";
}
U
{
file "<case>/postProcessing/plane0/1/U_plane0.vtk";
}
}
This allows the case to be moved elsewhere and still find its files.
This functionality was previously added for vtkCloud, but now also
applies to streamLine, sampledSets and sampledSurfaces
- it is sufficient to provide the total number of times that findBinary()
failed instead of flooding the screen with messages
Full verbose warnings still emitted when debugging is on.
- makes the intent clearer and avoids the need for additional
constructor casting. Eg,
labelList(10, Zero) vs. labelList(10, 0)
scalarField(10, Zero) vs. scalarField(10, scalar(0))
vectorField(10, Zero) vs. vectorField(10, vector::zero)
- now use findEtcEntry() instead to handle file or directory.
Added findEtcEntries(), which provides provides a common code basis
for findEtcDirs(), findEtcFiles() ...
- this simplifies use of a unified test for directory or file.
fileName::Type what = myfile.type(true, true);
if (what == FILE) ...
if (what == DIRECTORY) ...
- Use distinct bit values for fileName::Type, for possible use in
the future.
- related to issue #1121, since we need a more flexible way of
expanding file or directory.
An alternative would be to add checkGzip to Foam::exists() and
Foam::type() functions, but that would make the code there more
confusing and in the fileHandler classes.
- for some special cases we wish to mark command-line arguments as
being optional, in order to do our own treatment. For example,
when an arbitrary number of arguments should be allowed.
Now tag this situation with argList::noMandatoryArgs().
The argList::argsMandatory() query can then be used in any further
logic, including the standard default argument checking.
- with the new default check, can consolidate the special-purpose
"setRootCaseNonMandatoryArgs.H"
into the regular
"setRootCase.H"
- revert to a simple "setRootCase.H" and move all the listing related
bits to a "setRootCaseLists.H" file. This leaves the information
available for solvers, or whoever else wishes, without being
introduced everywhere.
- add include guards and scoping to the listing files and rename to
something less generic.
listOptions.H -> setRootCaseListOptions.H
listOutput.H -> setRootCaseListOutput.H
- Now also responds to the contents of the trigger file,
processing action= contents similar to used with external coupling.
Previously it only handled an action that was defined in the
dictionary. With this update, the user can chose a diferent action
simply by echoing the appropriate action string into the trigger
file.
- similar to the foamEtcFile script -mode=... option, the specific
search location (user/group/other) can now also specified for
string expansions and as a numerical value for etcFile()
For example, if searching for group or other (project) controlDict,
but not wishing to see the user controlDict:
1. foamEtcFile -mode=go controlDict
2. fileName dictFile("<etc:go>/controlDict");
dictFile.expand();
3. etcFile(controlDict, false, 0077);
The default behaviour for searching all contexts is unchanged.
1. foamEtcFile controlDict
2. fileName dictFile("<etc>/controlDict");
dictFile.expand();
3. etcFile(controlDict);
- the local third-party headers are to be searched before any MPI
include directories. This stops the situation where an mpi-specific
version of ptscotch.h is installed into the MPI directories.
This "system" version may well have a different SCOTCH_Num size
(32 bit vs 64 bit) from the third-party library etc.
- change previous default (convert all faceZones unless -noFaceZones
specified) with the default behaviour to only convert face zones on
request.
- uses the '-faceZones' option as per foamToEnsight
- the result of lsof, which is used in the etc/cshrc to locate the
installation, may contain trailing information about host and mount
point.
There is also a moderate concern with people sourcing the
file indirectly with their own version in the same directory.
For example, a 'etc/cshrc-site' that actually sources 'etc/cshrc'.
This leads to multiple matches in the lsof output, so we only take
the first one, stop there and hope they didn't do something even
trickier.
- the counterpart to floatVector, doubleTensor, which can be useful
for connecting to programs that always expect double precision for
the arguments, when using single-precision for OpenFOAM itself.
Eg,
doubleVector pos = ...;
vtkcamera->SetPosition(pos.v_);
- prefer this to using the OPENFOAM define since this improves the
internal consistency with the build information.
The API information could change between builds without the
etcFiles.C being recompiled whereas the value of
Foam::foamVersion::api is force updated during the build (triggers
recompilation of globals.Cver)
Reports the min|max|average AMI weights to text file and optionally
writes VTK surfaces of the sum of the weights, and mask field for
ACMI patches.
Example usage:
AMIWeights
{
type AMIWeights;
libs ("libfieldFunctionObjects.so");
writeControl writeTime;
writeFields yes;
}
Reference:
Comte-Bellot, G., and Corrsin, S., "Simple Eulerian Time Correlation of
Full- and Narrow-Band Velocity Signals in Grid-Generated, 'Isotropic'
Turbulence," Journal of Fluid Mechanics, Vol. 48, No. 2, 1971,
pp. 273–337.
- now placed under postProcessing/checkMesh and postProcessing/checkAMI,
respectively.
Output files are now also tagged with the id of the patch, in case
there are multiple AMI patches in use.
- the problem occurred when running the writers in a parallel solver
or utility but requesting output on the master only.
Adjusted the logic to avoid globalIndex for these cases.
Previously the if (parallel_) checks were happening later, after the
globalIndex had already been created.
- use cellCentres() instead of volField equivalent for vtk conversion
- make looping variables more consistent
- centralize the transcription of OpenFOAM -> vtk tuples
Adding reflecting fluxes to Solar load radiation model.
Adding functionality to the boundary radiation models and new
place holder for basic wall types such as transparent, opaqueDiffusive,
opaqueReflective,etc.
Changing radiation wall models to run time selectable.
Adding multi-band capabilities to VF model and improving the set up
for using solar loads in VF and fvDOM radiation models.
The freestreamFvPatchField previously employed a fixed value when supplying
the inlet values. This commit extends the BC so that users can use another
patch to supply the values via the new freestreamBC entry, e.g. to set the
velocity to an atmospheric boundary layer profile:
inlet
{
type freestream;
freestreamBC
{
type atmBoundaryLayerInletVelocity;
flowDir (1 0 0);
zDir (0 0 1);
Uref 20;
Zref 20;
z0 uniform 0.1;
zGround uniform 935;
}
}
The earlier specification is also maintained for backwards compatibility, e.g.
inlet
{
type freestream;
freestreamValue uniform (300 0 0);
}
- provide default WM_DIR if not already set, to improve robustness if a
reduced environment is used
- add etc/ to WM_PROJECT_SITE search. This makes the site directory
structure consistent with the OpenFOAM structure.
Eg,
WM_PROJECT_SITE/etc/..
WM_PROJECT_SITE/bin/..
WM_PROJECT_SITE/platforms/..
- Don't set/export WM_OSTYPE. The default is POSIX and is properly
defaulted throughout, including in CMakeLists-OpenFOAM.txt (also for
Catalyst)
- Use the OPENFOAM define (eg, 1806, 1812), which normally corresponds
to a major release, to define an API level. This remains consistent
within a release cycle and means that it is possible to manage
several sub-versions and continue to have a consistent lookup.
The current API value is updated automatically during the build
and cached as meta data for later use, even when the wmake/ directory
is missing or OpenFOAM has not yet be initialized.
The version information reported on program start or with -help
usage adjusted to reflect this. The build tag from git now also
carries the date as being more meaningful to trace than a hash
value.
- Update etc/bashrc and etc/cshrc to obtain the project directory
directly instead of via its prefix directory. The value obtained
corresponds to an absolute path, from which the prefix directory
can be obtained.
The combination of these changes removes the reliance on any
particular directory naming convention.
For example,
With an 1812 version (API level):
WM_PROJECT_VERSION=myVersion
installed as /some/path/somewhere/openfoam-mySandbox
This makes the -prefix, -foamInstall, -projectVersion, -version
values of foamEtcFiles, and similar entries for foamConfigurePaths
superfluous.
WM_PROJECT_INST_DIR is no longer required or used
ENH: improve handling and discovery of ThirdParty
- improve the flexibility and reusability of ThirdParty packs to cover
various standard use cases:
1. Unpacking initial release tar files with two parallel directories
- OpenFOAM-v1812/
- ThirdParty-v1812/
2. With an adjusted OpenFOAM directory name, for whatever reason
- OpenFOAM-v1812-myCustom/
- openfoam-1812-other-info/
3. Operating with/without ThirdParty directory
To handle these use cases, the following discovery is used.
Note PROJECT = the OpenFOAM directory `$WM_PROJECT_DIR`
PREFIX = the parent directory
VERSION = `$WM_PROJECT_VERSION`
API = `$WM_PROJECT_API`, as per `foamEtcFiles -show-api`
0. PROJECT/ThirdParty
- for single-directory installations
1. PREFIX/ThirdParty-VERSION
- this corresponds to the traditional approach
2. PREFIX/ThirdParty-vAPI
- allows for an updated value of VERSION (eg, v1812-myCustom)
without requiring a renamed ThirdParty. The API value
would still be '1812' and the original ThirdParty-v1812/
would be found.
3. PREFIX/ThirdParty-API
- this is the same as the previous example, but using an unadorned
API value. This also makes sense if the chosen version name also
uses the unadorned API value in its naming
(eg, 1812-patch190131, 1812.19W03)
4. PREFIX/ThirdParty-common
- permits maximum reuse for various versions, but only for
experienced user who are aware of potential version
incompatibilities
Directory existence is checked as is the presence of an Allwmake file
or a platforms/ directory. This reduces the potential of false positive
matches and limits the selection to directories that are either
with sources (has the Allwmake file), or pre-compiled binaries (has
the platforms/ directory).
If none of the explored directories are found to be suitable,
it reverts to using a PROJECT/ThirdParty dummy location since
this is within the project source tree and can be trusted to
have no negative side-effects.
ENH: add csh support to foamConfigurePaths
- this removes the previously experienced inconsistence in config file
contents.
REMOVED: foamExec
- was previously used when switching versions and before the
bashrc/cshrc discovery logic was added. It is now obsolete.
- Uses the user-specified value for outputTemperature:
{
type externalCoupledTemperature;
outputTemperture fluid; // or wall;
}
Otherwises uses 'wall' as a default (for compatibility) and emits a
warning.
The T.out header now reflects the type of output. Eg,
# Values: area Tfluid qDot htc
- tutorials based on squareBend used Default_Boundary_Region explicitly
defined since they predated the defaultPatch renaming (2008).
The name 'Default_Boundary_Region' was for convenience as the default
name when converting to PROSTAR or CCM formation, but can now be
changed to something more generic.
- define wall boundary conditions for squareBend using a general regex
to allow future splitting of wall types by name.
- check if the first argument corresponds to an OpenFOAM value for
'true' (as per Switch).
True == 't', 'y', 'true', 'yes', 'on'. Everything else is not true.
- when the first argument is '-dict', it initializes the value
with a query via foamDictionary.
Eg,
isTrue -dict mydict -entry parallel
==> value=$(foamDictionary mydict -entry parallel -value)
isTrue $value
a missing entry is silently treated as false.
ENH: add getNumberOfPatchFaces function in RunFunctions
- simple extraction of nFaces from boundary file for given patch/region
- append the commit hash value with the commit date when creating
the build string information and drop the version prefix.
This provides an immediate overview of when the code was last
changed. The prefixed version information can be dropped from
the build string, since it is readily available in other forms.
- was PREFIX/site, now PROJECT/site
This avoids several issues when installing OpenFOAM in clusters
without an intermediate OpenFOAM-specific installation prefix.
The 'site' directory may have a reserved meaning in these situations
and it is undesirable to 'leak' upwards into the parent directory to
look for configuration files.
Placing the default within the project directory avoids this.
Alternative locations can be given via the WM_PROJECT_SITE variable.
- removed reliance on ParaView_INCLUDE_DIR variable for conveying the
major.minor version information when compiling. This can be somewhat
fragile and also adds variable that is an unnecessary when running
(only used when compiling).
Instead use `have_pvplugin_support` function in paraviewFunctions
wmake script to determine the maj.min from the PV_PLUGIN_PATH
since we have already defined the output path there with paraview
maj.min numbering.
Can now build with paraview from the operating system,
provided that it has develop headers available.
ParaView_VERSION=system
In the etc/config.sh/paraview setup, the maj.min is taken from
the corresponding `paraview --version` output and used when
defining the PV_PLUGIN_PATH.
During the build, the include path taken from `paraview-config`
for a system installation, from the guess installation root
of the paraview binary, or ParaView_DIR otherwise.
NB: using a system ParaView for building runTimePostProcessing is unsupported.
- these types of builds appear to have various library resolution issues
(eg, libexpat not being loaded). Additionally, the build logic does
not yet cover this type of use case.
- cfindObject() for const pointer access.
- getObject() for mutable non-const pointer access, similar to the
objectRegistry::getObjectPtr()
- cfindObject(), findObject(), getObject() with template type access
to also check the headerClassName.
For example,
cfindObject("U") -> good
cfindObject<volVectorField>("U") -> good
cfindObject<volScalarField>("U") -> nullptr
This allows inversion of looping logic.
1) Obtain the names for a particular Type
for (const word& objName : objs.sortedNames<Type>())
{
const IOobject* io = objs[objName];
...
}
2) Use previously obtained names and apply to a particular Type
for (const word& objName : someListOfNames)
{
const IOobject* io = objs.cfindObject<Type>(objName);
if (io)
{
...
}
}
- if FOAM_EXT_LIBBIN is unset and some scripts set this to /usr/lib*
as a fallback (eg, to avoid an undefined value) this will cause a
system library to be found before appropriate *_ARCH_PATH entry.
This was noticed during a scotch compilation without third-party:
resulting in the system library (/usr/lib64/libscotch.so) to be found
instead of the SCOTCH_ARCH_PATH location
(/usr/lib64/mpi/gcc/openmpi/lib64/).
Simply changing the search order doesn't work for use, since we wish
to retain a preference for any dynamic libraries discovered in a
real FOAM_EXT_LIBBIN.
Circumvent these issues by only taking libraries from
FOAM_EXT_LIBBIN if it also points to a location within ThirdParty.
- can now things like ref(), boundaryFieldRef(), primitiveFieldRef()
with an optional argument that avoids triggering any update events
Instead of
Field<Type>& iF = const_cast<Field<Type>&>(fld.primitiveField());
can now write
Field<Type>& iF = fld.primitiveFieldRef(false);
or simply
auto& iF = fld.primitiveFieldRef(false);
- can be used, for example, to visualize all wall cells - for quality
or other purposes - without requiring an intermediate faceSet for
the selection. Request arising from pending merge !213.
- now supports a parcel selection mechanism like vtkCloud,
giving the ability to select a subset of parcels.
For example, a given stride, or removal of parcels with a small
diameter.
Eg,
dataCloud output Time: 3.2
Applying parcel filtering to 994 parcels
- add stride 4
- subtract field U : (less 0.2)
After filtering using 214/994 parcels
- add output precision control for dataCloud
- vtkWrite with moving mesh was not updated the subsets properly,
which caused it to crash.
- foamToVTK -overwrite ignored for single region cases,
was working for multi-region cases
- minor documentation changes
Description
Calculates the energy spectrum for a structured IJK mesh
Usage
Example of function object specification:
energySpectrum1
{
type energySpectrum;
libs ("libfieldFunctionObjects.so");
}
Where the entries comprise:
\table
Property | Description | Required | Default value
type | type name: energySpectrum | yes |
log | write info to standard output | no | yes
\endtable
Output data is written to the file \<timeDir\>/energySpectrum.dat
- Added quoting to handle spaces in environment values in commit 50852b33
(#1007, #1008). However, quoting is only needed for eval mode.
In regular mode, quoting should not be part of the output, instead it
should be done on the caller side.
- provide edit for adjusting the ThirdParty and fallback site variables.
This is useful when packaging into a single directory, and possibly
without any ThirdParty dependencies.
- support '-prefix' (similar to auotconfig) as an alternative to
'-foamInstall'. Use this prefix to set the prefix directly.
Bypasses and disables the bash sourcing magic.
- Within strings it is preferable to use the "<etc>" instead.
Most use cases for the old "~OpenFOAM" expansion have been obsoleted
by the #includeEtc directive.
- use std::string instead of c-string for the string constants
- centralize some definitions of resources into foamVersion.H
Now expose some of the hard-coded values used in foamEtcFiles()
so that they can be known or even overridden as required.
Relocate to src/OpenFOAM/include as a constant location.
- uses wmake, without OpenFOAM libraries.
The application and libray serve as a minimal test case for wmake,
but can also be used to generate a minimal library/executable pair
target for testing of packaging etc.
- For compatibility, access to the old global names is provided via
macros
#define FOAMversion foamVersion::version
#define FOAMbuild foamVersion::build
#define FOAMbuildArch foamVersion::buildArch
- this isolation makes it easier to provide additional scoped methods
for dealing with version related information. Eg, printBuildInfo()
- foamVersion.H now includes stdFoam.H for consistent use
of compatibility compiler defines.
- move forward declaration of Detail, Module namespaces to stdFoam.H
- doxygen documentation of Foam namespace in stdFoam.H
- generalize output text wrapping, use for usage notes
- add -help-man option for generating manpage content for any OpenFOAM
application or solver.
bin/tools/foamCreateManpage as helper
- The changes in foamCleanPath introduced for issues (#1007, #1008)
include quoted output of the cleaned environment variable.
When used in foamCreateModuleInclude, the quotes make their way
into the final environment. Avoid this by using the -sh-env
eval format instead.
- add environment extraction of MANPATH changes
- 'unfriend' operators on dimensionSet, since they operate without
requiring access to non-public members.
- add missing invTransform() function for dimensionSet.
- make inv(const dimensionSet&) available as
operator~(const dimensionSet&), which can be used instead
of (dimless/ds).
- writing of dictionary entry with the name of the dimensionedType
suppressed if it is identical to the keyword.
This corresponds to the input requirements.
- deprecate dimensionedType constructors using an Istream in favour of
versions accepting a keyword and a dictionary.
Dictionary entries are almost the exclusive means of read
constructing a dimensionedType. By construct from the dictionary
entry instead of doing a lookup() first, we can detect possible
input errors such as too many tokens as a result of a input syntax
error.
Constructing a dimensionedType from a dictionary entry now has
two forms.
1. dimensionedType(key, dims, dict);
This is the constructor that will normally be used.
It accepts entries with optional leading names and/or
dimensions. If the entry contains dimensions, they are
verified against the expected dimensions and an IOError is
raised if they do not correspond. On conclusion, checks the
token stream for any trailing rubbish.
2. dimensionedType(key, dict);
This constructor is used less frequently.
Similar to the previous description, except that it is initially
dimensionless. If entry contains dimensions, they are used
without further verification. The constructor also includes a
token stream check.
This constructor is useful when the dimensions are entirely
defined from the dictionary input, but also when handling
transition code where the input dimensions are not obvious from
the source.
This constructor can also be handy when obtaining values from
a dictionary without needing to worry about the input dimensions.
For example,
Info<< "rho: " << dimensionedScalar("rho", dict).value() << nl;
This will accept a large range of inputs without hassle.
ENH: consistent handling of dimensionedType for inputs (#1083)
BUG: incorrect Omega dimensions (fixes#2084)
- use forwarding templates for the factory method
- avoid double use of dynamic_cast.
Don't need implicit use in isA<>, can use result directly
STYLE: updated iteration over HashTable of mesh objects
- was using coordinate-system and transform() which is the
local-to-global mapping, whereas it should be invTransform() which
is the global-to-local mapping
- this seems to be the only reliable means of obtaining the values.
Using typeName_() yields the wrong value.
Using the typeName causes initialization issues
(segfault when executing on some systems).
- support name filtering by class based on <Type> or predicates.
Eg,
objects.sortedNames<volScalarField>(namePattern);
vs objects.sortedNames(volScalarField::typeName, namePattern);
These can also be used directly for untyped name matching.
Eg,
objects.sortedNames<void>(namePattern);
Can also use a predicate:
objects.sortedNames(wordRe("vol.*Field"), namePattern);
objects.sortedNames
(
[](const word& clsName){ return clsName.startsWith("vol"); },
namePattern
);
- add IOobjectList::count() methods
- lookupClass<Type>() to use types instead of class variables.
- additional helpers for parallel: allNames(), checkNames()
- provide filterClasses() and filterObjects(), prune_0() method
forwarding to HashTable methods for easier access.
- in parameter form, check if it headerClassName() corresponds to the
specified class name
- in templated form, check if headerClassName() corresponds to the
Type:typeName value.
Specialization for <void> always returns true (ie, no checks)
- replace explicit use of word, wordRe, wordRes, wordHashSet as filters
with a MatchPredicate, since they all satisfy the requirements for
use a predicate. This change reduces code duplication, allows other
matcher types (eg, keyType) as well as lambda functions.
- add special treatment for a 'const char*' parameter
for lookupClass() and the now-deprecated single item lookup() method
to promote these parameters to 'word'.
- naming similar to objectRegistry, with unambiguous resolution.
The lookup() methods have different return types depending on the
calling parameter.
STYLE: use IOobjectListTemplates.C for implementations
- previously included as local definition within IOobjectList.C,
but will be adding more templated methods soon.
- adjust parameters (eg, matchName instead of matcher) to show their
function
ENH: handle objectRegistry::names<void>(...)
- this is equivalent to no Type restriction, and can be used when
filtering names. Eg,
obr.names<void>(wordRe..);
- Start brief descriptions with 'Deprecated(YYYY-MM)' so that it is
readily visible in the short method description. Consistent date
format (YYYY-MM), placed immediately after the \deprecated tag.
commit 3f9c7bf411
commit 3cf177e759
====
ENH: add geometric decomposition constraint (issue #921)
- geometric decomposition constraints may be used to prevent the
decomposition of regions of the mesh.
The geometric constraint is applied according to the face centres,
which define the connectivity between cells.
Specified in decomposeParDict
constraints
{
geometric
{
type geometric;
geometry
{
box1
{
type box;
min (-10 -10 -10);
max (1 1 1);
}
ball1
{
type sphere;
origin (-2 -2 1);
radius 1;
}
}
}
}
ENH: add 'grow' option for geometric decomposition constraint (issue #921)
- the 'grow' option includes an additional check to include cell faces
for any cell that already has two or more of its faces "unblocked".
This could indicate a connection over a corner, but does not distinguish
between connectivity introduced by the constraint and the connectivity
defined by other constraints.
ENH: geometric decomposition constraint using topoSetFaceSource (issue #921)
- replaced use of searchableSurface with a more general and
more efficient topoSetFaceSource instead.
Since searchableSurface is also available as a topoSetFaceSource,
there is no loss in functionality, but using topoSetFaceSource allow
directly looping over the faces without creating of an additional
List of volumeTypes.
This fixes the static-initialisation order problem - fieldTypes.C
referes to labelIOField etc. which are after it in Make/files and
hence the link order.
- now takes a const UList<T> as input and returns a List<T>
instead of trying to use the same ListType for both.
This avoids previously encountered issues when a UList was passed in.
- add specialized bitSet handling within subset(), where we can benefit
from faster traversal of sparse selections and have a better estimate
of the final output size.
- local token shifting was missing when getting the next file chunk
(while in the middle of parsing that text).
As well as adding the correct shifting, also tag the local buffer
with nullptr when it is done. Be extra paranoid and check the
raw buffer range before passing off to std::string.
- Default format is now XML binary (base64) instead of legacy format.
The old -xml option is redundant and ignored.
The new -legacy option can be used to force legacy output instead.
- Polyhedral decomposition is now off by default (old -poly is ignored).
The option -poly-decomp forces decomposition of polyhedrals into
primitive shapes.
- reduced memory footprint by reading and converting fields
successively.
- Creation of symlinks to processor files is no longer required or
desired. The old -noLinks option is ignored.
- Ignore -useTimeName option. Always number according to timeIndex.
- align input parameters and some of the behaviour with vtkWrite
The output is now postProcessing/<name> for similar reasoning as
mentioned in #866 - better alignment with other function objects, no
data collision with foamToEnsight output.
- separate controls for internal and boundary meshes
- can restrict conversion based on zone names, enclosing volumes,
bounding box.
- parallel output.
The output is now postProcessing/<name> for similar reasoning as
mentioned in #866 - better alignment with other function objects, no
collision with foamToVTK output.
- align the input parameters with those of vtkCloud so that we can
specify the ASCII precision and the padding width for the output
file names as well.
- emit TimeValue field, support file series generation
- support internal or boundary meshes, combining the result into a vtm
file.
- can restrict conversion based on zone names, enclosing volumes,
bounding box
- handle tmp fields in interpolate methods
- special method interpolateInternal() for creating a volume field
with zero-gradient treatment for patches from an internal field.
This method was previously also called interpolate(), but that
masked the ability to subset the internal field only.
Ensight output needs the volume field:
uses interpolateInternal().
VTK output has separate handling of internal and patch fields:
uses interpolate().
ENH: added fvMeshSubset mesh() method for baseMesh or subMesh.
- simplies coding when the fvMeshSubset may or may not be in active use.
ENH: update foamToEnsight to use newer methods in wrapped form
- static interpolate functions with renaming for manual use with
fvMeshSubset (when fvMeshSubsetProxy may be too limiting in
functionality)
- helps reduce clutter in the topoSetDict files.
Caveats when using this.
The older specification styles using "name" will conflict with the
set name. Eg,
{
name f0
type faceSet;
action add;
source patchToFace;
sourceInfo
{
name inlet;
}
}
would flattened to the following
{
name f0
type faceSet;
action add;
source patchToFace;
name inlet;
}
which overwrites the "name" used for the faceSet.
The solution is to use the updated syntax:
{
name f0
type faceSet;
action add;
source patchToFace;
patch inlet;
}
- faceBitSet, pointBitSet and faceBoolSet (similar to cellBitSet)
* allows topo sources in a wider variety of places.
* With copy or move constructors.
- cylinderToPoint, searchableSurfaceToFace, searchableSurfaceToPoint,
sphereToFace, sphereToPoint sources
- optional innerRadius for sphere and cylinder sources to treat as hollow.
- support "sets" as well as "set" for cellToCell, faceToFace... sources.
* convenience and avoids writing the set during processing.
- now applicable to labelLists.
Note:
in some situations it will be more efficient to use
Foam::identity() directly. Eg,
globalIndex globalCells(mesh.nCells());
...
labelList cellIds
(
identity(globalCells.localSize(), globalCells.localStart())
);
- previously simply read files until the input stream went bad and no
more lines could be read. With the more stringent checking of
values read (commit 0ce7e364a4) this approach causes problems.
Use the underlying tokenizer instead to decide about termination.
- for space-savings the VTK fields are normally written as 'float'
rather than double. When a double field contains very large values,
these can result in a overflow when converted to float.
Now trap these with the appropriate numeric limits.
No warning when these values are clipped: it should be readily
apparent from the output.
ENH: handle symmTensor component swapping directly on VTK output.
- use VTK output routines in vtkSurfaceWriter to benefit from the
above changes
- a failed attempt to read a value (eg, word, label, scalar) from a
stream now always provokes a FatalIOError.
This helps avoid some difficult to trace input errors.
- old 'DELETE' enum was easily confused with 'REMOVE', which removes
the set, not the elements from the set.
- provide corresponding subtractSet() method
STYLE: HashSet set/unset instead of insert/erase methods in topoSetSource
- simplifies switching to/from bitSet storage
- make hasFaceId a top-level virtual method and remove keepIds
equivalent from sampledTriSurfaceMesh. This makes the property
available without casting.
- New sampling type 'none'.
Can be used to temporarily disable a sampling surface definition,
or to provide boilerplate for overwriting later.
- as part of the cleanup of dictionary access methods (c6520033c9)
made the dictionary class single inheritance from IDLList<entry>.
This eliminates any ambiguities for iterators and allows
for simple use of range-for looping.
Eg,
for (const entry& e : topDict))
{
Info<< "entry:" << e.keyword() << " is dict:" << e.isDict() << nl;
}
vs
forAllConstIter(dictionary, topDict, iter))
{
Info<< "entry:" << iter().keyword()
<< " is dict:" << iter().isDict() << nl;
}
- more dictionary-like methods, enforce keyType::LITERAL for all
lookups to avoid any spurious keyword matching.
- new readEntry, readIfPresent methods
- The get() method replaces the now deprecate lookup() method.
- Deprecate lookupOrFailsafe()
Failsafe behaviour is now an optional parameter for lookupOrDefault,
which makes it easier to tailor behaviour at runtime.
- output of the names is now always flatted without line-breaks.
Thus,
os << flatOutput(someEnumNames.names()) << nl;
os << someEnumNames << nl;
both generate the same output.
- Constructor now uses C-string (const char*) directly instead of
Foam::word in its initializer_list.
- Remove special enum + initializer_list constructor form since
it can create unbounded lookup indices.
- Removd old hasEnum, hasName forms that were provided during initial
transition from NamedEnum.
- Added static_assert on Enum contents to restrict to enum or
integral values. Should not likely be using this class to enumerate
other things since it internally uses an 'int' for its values.
Changed volumeType accordingly to enumerate on its type (enum),
not the class itself.
- this helps for many cases outlined in issue #1007, but can also be
useful when simply using symlinks for shorter or reorganized
directory structures.
Update of overRhoPimpleDyMFoam and overInterDyMFoam solvers.
Adding corresponding tutorials with best possible settings
The main effort was put on reducing pressure spikes as the
stencil change with hole cells on the background mesh.
- writes positions and a single field (eg, diameter) in plain ASCII files,
suitable for importing in a spreadsheet or manipulation with
scripting tools.
- code integrated from
https://develop.openfoam.com/Community/OpenFOAM-addOns
New name: findObject(), cfindObject()
Old name: lookupObjectPtr()
Return a const pointer or nullptr on failure.
New name: findObject()
Old name: --
Return a non-const pointer or nullptr on failure.
New name: getObjectPtr()
Old name: lookupObjectRefPtr()
Return a non-const pointer or nullptr on failure.
Can be called on a const object and it will perform a
const_cast.
- use these updated names and functionality in more places
NB: The older methods names are deprecated, but continue to be defined.
- these currently only with bool parameters, but the return value should
nonetheless always be a bool value:
andOp(), orOp(), lessOp(), lessEqOp(), greaterOp(), greaterEqOp()
- renamed the unused eqEqOp() to equalOp() for naming consistency with
the equal() global function.
ENH: equalOp() specialization for scalars
- function object version of the equal() function.
The default constructor uses the same tolerance (VSMALL),
but can also supply an alternative tolerance on construction.
Description
Calculates the spatial minimum and maximum extents of a field
The extents are derived from the bound box limits after identifying
the locations where field values exceed the user-supplied threshold
value.
Usage
Example of function object specification:
fieldExtents1
{
type fieldExtents;
libs ("libfieldFunctionObjects.so");
...
writeToFile yes;
log yes;
fields (alpha);
threshold 0.5;
patches ();
}
Where the entries comprise:
Property | Description | Required | Default
type | type name: fieldExtents | yes |
writeToFile | write extents data to file | no | yes
log | write extents data to standard output | no | yes
internalField | Process the internal field | no | yes
threshold | Field value to identify extents boundary | yes |
referencePosition | Reference position | no | (0 0 0)
fields | list of fields to process | yes |
patches | list of patches to process | no | <all>
Output data is written to the file \<timeDir\>/fieldExtents.dat
Note
For non-scalar fields, the magnitude of the field is employed and
compared to the threshold value.
- with the 'cwd' optimization switch it is possible to select the
preferred behaviour for the cwd() function.
A value of 0 causes cwd() to return the physical directory,
which is what getcwd() and `pwd -P` return.
Until now, this was always the standard behaviour.
With a value of 1, cwd() instead returns the logical directory,
which what $PWD contains and `pwd -L` returns.
If any of the sanity checks fail (eg, PWD points to something other
than ".", etc), a warning is emitted and the physical cwd() is
returned instead.
Apart from the optical difference in the output, this additional
control helps workaround file systems with whitespace or other
characters in the directory that normally cause OpenFOAM to balk.
Using a cleaner symlink elsewhere should skirt this issue.
Eg,
cd $HOME
ln -s "/mounted volume/user/workdir" workdir
cd workdir
# start working with OpenFOAM
- foamCleanPath now only splits the environment variable on ':', which
allows other directories with spaces or '(..)' etc to pass through
without major issue.
- The filter arguments are split on whitespace, colons or semi-colons.
- use keyType::option enum to consolidate searching options.
These enumeration names should be more intuitive to use
and improve code readability.
Eg, lookupEntry(key, keyType::REGEX);
vs lookupEntry(key, false, true);
or
Eg, lookupEntry(key, keyType::LITERAL_RECURSIVE);
vs lookupEntry(key, true, false);
- new findEntry(), findDict(), findScoped() methods with consolidated
search options for shorter naming and access names more closely
aligned with other components. Behave simliarly to the
methods lookupEntryPtr(), subDictPtr(), lookupScopedEntryPtr(),
respectively. Default search parameters consistent with lookupEntry().
Eg, const entry* e = dict.findEntry(key);
vs const entry* e = dict.lookupEntryPtr(key, false, true);
- added '*' and '->' dereference operators to dictionary searchers.
- use the dictionary 'get' methods instead of readScalar for
additional checking
Unchecked: readScalar(dict.lookup("key"));
Checked: dict.get<scalar>("key");
- In templated classes that also inherit from a dictionary, an additional
'template' keyword will be required. Eg,
this->coeffsDict().template get<scalar>("key");
For this common use case, the predefined getXXX shortcuts may be
useful. Eg,
this->coeffsDict().getScalar("key");
- not used by the ISstream parser, but suitable for other parsing
methods where true/false concept should be distinguishable from
integer values.
Only constructed via the token::boolean() static method, not
directly assignable.
This avoids any potential ambiguities with label.
- this also removes the '-newTimes' option cruft from appearing
everywhere. reconstructPar and redistributePar are unaffected by this
since they define their own -newTimes option independently.
- same as !isPattern(), but can be more readable.
- add wordRe enum state 'UNKNOWN', which has the identical value as
'DETECT' but used for a return value.
- makes an easier overview of the rotation matrix coefficients
(issue #863).
Provided as a distinct commit for easier examination of the lines changed.
Previously the coordinate system functionality was split between
coordinateSystem and coordinateRotation. The coordinateRotation stored
the rotation tensor and handled all tensor transformations.
The functionality has now been revised and consolidated into the
coordinateSystem classes. The sole purpose of coordinateRotation
is now just to provide a selectable mechanism of how to define the
rotation tensor (eg, axis-angle, euler angles, local axes) for user
input, but after providing the appropriate rotation tensor it has
no further influence on the transformations.
--
The coordinateSystem class now contains an origin and a base rotation
tensor directly and various transformation methods.
- The origin represents the "shift" for a local coordinate system.
- The base rotation tensor represents the "tilt" or orientation
of the local coordinate system in general (eg, for mapping
positions), but may require position-dependent tensors when
transforming vectors and tensors.
For some coordinate systems (currently the cylindrical coordinate system),
the rotation tensor required for rotating a vector or tensor is
position-dependent.
The new coordinateSystem and its derivates (cartesian, cylindrical,
indirect) now provide a uniform() method to define if the rotation
tensor is position dependent/independent.
The coordinateSystem transform and invTransform methods are now
available in two-parameter forms for obtaining position-dependent
rotation tensors. Eg,
... = cs.transform(globalPt, someVector);
In some cases it can be useful to use query uniform() to avoid
storage of redundant values.
if (cs.uniform())
{
vector xx = cs.transform(someVector);
}
else
{
List<vector> xx = cs.transform(manyPoints, someVector);
}
Support transform/invTransform for common data types:
(scalar, vector, sphericalTensor, symmTensor, tensor).
====================
Breaking Changes
====================
- These changes to coordinate systems and rotations may represent
a breaking change for existing user coding.
- Relocating the rotation tensor into coordinateSystem itself means
that the coordinate system 'R()' method now returns the rotation
directly instead of the coordinateRotation. The method name 'R()'
was chosen for consistency with other low-level entities (eg,
quaternion).
The following changes will be needed in coding:
Old: tensor rot = cs.R().R();
New: tensor rot = cs.R();
Old: cs.R().transform(...);
New: cs.transform(...);
Accessing the runTime selectable coordinateRotation
has moved to the rotation() method:
Old: Info<< "Rotation input: " << cs.R() << nl;
New: Info<< "Rotation input: " << cs.rotation() << nl;
- Naming consistency changes may also cause code to break.
Old: transformVector()
New: transformPrincipal()
The old method name transformTensor() now simply becomes transform().
====================
New methods
====================
For operations requiring caching of the coordinate rotations, the
'R()' method can be used with multiple input points:
tensorField rots(cs.R(somePoints));
and later
Foam::transformList(rots, someVectors);
The rotation() method can also be used to change the rotation tensor
via a new coordinateRotation definition (issue #879).
The new methods transformPoint/invTransformPoint provide
transformations with an origin offset using Cartesian for both local
and global points. These can be used to determine the local position
based on the origin/rotation without interpreting it as a r-theta-z
value, for example.
================
Input format
================
- Streamline dictionary input requirements
* The default type is cartesian.
* The default rotation type is the commonly used axes rotation
specification (with e1/e2/3), which is assumed if the 'rotation'
sub-dictionary does not exist.
Example,
Compact specification:
coordinateSystem
{
origin (0 0 0);
e2 (0 1 0);
e3 (0.5 0 0.866025);
}
Full specification (also accepts the longer 'coordinateRotation'
sub-dictionary name):
coordinateSystem
{
type cartesian;
origin (0 0 0);
rotation
{
type axes;
e2 (0 1 0);
e3 (0.5 0 0.866025);
}
}
This simplifies the input for many cases.
- Additional rotation specification 'none' (an identity rotation):
coordinateSystem
{
origin (0 0 0);
rotation { type none; }
}
- Additional rotation specification 'axisAngle', which is similar
to the -rotate-angle option for transforming points (issue #660).
For some cases this can be more intuitive.
For example,
rotation
{
type axisAngle;
axis (0 1 0);
angle 30;
}
vs.
rotation
{
type axes;
e2 (0 1 0);
e3 (0.5 0 0.866025);
}
- shorter names (or older longer names) for the coordinate rotation
specification.
euler EulerRotation
starcd STARCDRotation
axes axesRotation
================
Coding Style
================
- use Foam::coordSystem namespace for categories of coordinate systems
(cartesian, cylindrical, indirect). This reduces potential name
clashes and makes a clearer declaration. Eg,
coordSystem::cartesian csys_;
The older names (eg, cartesianCS, etc) remain available via typedefs.
- added coordinateRotations namespace for better organization and
reduce potential name clashes.
This fix changes how the intersections loop ignores previously
intersected faces. It now marks them by their index so that subsequent
iterations ignore them.
Before this change, after an intersection was found the start point was
advanced by a small amount to move the past the intersection. The
problem with this was if multiple boundary faces or the end point were
in close proximity to the intersection then the move forward might span
them. This could lead to intersections being missed or counted multiple
times, in some cases indefinitely.
Based on a patch contributed by Mattijs Janssens
Resolves bug report https://bugs.openfoam.org/view.php?id=1147
- Can now retrieve or set a column/row of a tensor.
Either compile-time or run-time checks.
Get
t.col<1>(); t.col(1);
t.row<1>(); t.row(1);
Set
t.col<1>(vec); t.col(1,vec);
t.row<1>(vec); t.row(1,vec);
The templated versions are compile-time checked
t.col<3>();
t.col<3>(vec);
The parameter versions are run-time checked
t.col(3);
t.col(3,vec);
ENH: provide named access to tensor/tensor inner product as inner()
Helper function to calculate the current face area vs the area returned
from the current point locations. Useful for ACMI-type baffles where we
scale the face areas without moving points.
- nBoundaryFaces() is often used and is identical to
(nFaces() - nInternalFaces()).
- forward the mesh nInternalFaces() and nBoundaryFaces() to
polyBoundaryMesh as nFaces() and start() respectively,
for use when operating on a polyBoundaryMesh.
STYLE:
- use identity() function with starting offset when creating boundary maps.
labelList map
(
identity(mesh.nBoundaryFaces(), mesh.nInternalFaces())
);
vs.
labelList map(mesh.nBoundaryFaces());
forAll(map, i)
{
map[i] = mesh.nInternalFaces() + i;
}
- this provides internal consistency and allows direct use of the
coordinate angle with sin(), cos() functions.
It eliminates potential issues that could otherwise arise from
alternative user input.
Eg, in mixerFvMesh it would have previously been possible to specify
the coordinate system to use degrees or radians, but these units were
not checked when determining the tangential sweep positions.
NOTE: this may represent a breaking change if user coding has been
relying on cylindrical coordinate system in degrees.
Previously had 3 possibilities for handling exposed internal faces
1. use default "oldInternalFaces"
2. specify -patch, to use the specified (existing) patch
3. specify -patches, to use the geometrically closest patches
Now relaxed the restriction on -patch to allow specification of a new
(not yet existing) patch name. This improves flexibility, but won't
catch typing mistakes.
Harmonize behaviour of -patches and -patch. When -patches is used to
specify a single, non-regex patch name, it now behaves identically to
-patch. Since the getList handling for options already allows special
treatment for single parameter lists, the following will work
identically:
subsetMesh -patch patch0
subsetMesh -patches patch0
subsetMesh -patches '( patch0 )'
In the future it might be reasonable to fully combine the behaviour of
'-patch' and '-patches' and treat them as aliases for each other.
ENH: support subsetMesh on a cellZone.
- when the '-zone' option is specified, the command argument is treated
as the name (or names) of cellZones to be selected instead of as the
name of the cellSet.
The command argument can be a single word, regex, or list of
word/regex.
Eg,
subsetMesh -zone -patch mypatch mixer
subsetMesh -zone -patch mypatch '(mixer "moving.*" )'
STYLE: simplify set handling and other code cleanup in subsetMesh
Using: OpenFOAM-plus (see www.OpenFOAM.com)
Build: plus-7ab57cc5d014 (OPENFOAM=1807)
Arch: LSB;label=32;scalar=64
- This can be useful for development versions, or when the version
at build time uses some other naming scheme (#1010)
- 'signed' input parameter only mandatory for distance > 0.
A distance <= 0 is always signed and the input parameter is ignored.
- Use normal distance when distance == 0. This has no effect when
the surface has no open edges, but improves on rounding issues
around the zero crossing when the surface has open edges.
This may still need future revisiting.
- use parallel list writing, beginDataArray methods.
- use static_assert to restrict conversion of non-label integral types
- cache .vtp.series information by fileName instead of by cloud name.
This issues if the output directory changes, and simplifies code.
ENH: emit TimeValue in files generated by vtkCloud
- additional information for passing to ParaView
ENH: vtkCloud output to postProcessing/ (issue #866)
- better alignment with other function objects, no collision with
foamToVTK output.
- avoid duplicate code by relocating cellZone selection and bounding box
sub-selection into cuttingPlane and cuttingSurfaceBaseSelection.
Allows reuse by inherited classes (sampledPlane, surfMeshSamplePlane).
- takes two general actions:
1. orient edge in canonical direction (positive gradient) and detect
any edge intersection.
2. edge intersection alpha (0-1)
- refactor into a cuttingSurfaceBase intermediate class with the
actions as templated parameters rather than function pointers. This
allows the use of lambda functions with captures from the caller.
- The test condition
[ -n "$cur" -a ... ]
fails if $cur starts with '-le', which bash interprets as a further
test op. Splitting the test condition solves the problem:
[ -n "$cur" ] && [ ... ]
- Since the local edges are oriented according to the gradient,
they can also be used to determine the correct face orientation.
This generalizes the algorithm for future reuse.
- Provides a means of accumulating file entries for generating vtm
by accumulate blocks, datasets and writing them later.
Only a single block depth is currently supported and the methods
are kept fairly simple.
- Output formats such as vtp, vtu follow a particular internal data
structure (HEAD, FIELD_DATA, PIECE, CELL_DATA/POINT_DATA) and other
output conventions. This writer base tracks these expected output
states internally to help avoid logic errors in the callers.
- parallel list output for foamVtkOutput
- simplified '.series' file output
- beginDataArray() method instead of openDataArray() + closeTag()
since this seems to be the most common use anyhow.
With an optional argument for leaving the tag open, this works the
same as openDataArray() which may be deprecated in the future.
- begin/end methods for CellData, PointData, FieldData (commonly used)
- templating parameters for file headers, content version,
legacy fields. This improves coding robustness and convenience of use.
- use formatter and higher-level methods for legacy output
- attribute quoting character now part of the formatter itself
instead of as an argument for xmlAttr().
Toggle with quoting() method.
- pair-wise processing of xml attributes, which also allows them to be
passed as optional entries when creating an xml tag.
- xmlComment with multiple arguments
- allows cell point labels will use global numbering, but only for
unmerged points. We'd ideally like to avoid point merging per se,
and instead use VTK point blanking instead (as required).
This approach allows parallel collation of the output into a single
piece directly.
- there were previously no hashing mechanisms for lists so they
would fall back to the definition for primitives and hash the
memory location of the allocated List object.
- provide a UList::Hash<> sub-class for inheritance, and also a global
specialization for UList<T>, List<T> such that the hash value for
List<List<T>> cascades properly.
- provide similar function in triFace to ensure that it remains
similar in behaviour to face.
- added SymmHash to Pair, for use when order is unimportant.
STYLE: use string::hash() more consistently
- no particular reason to use Hash<word>() which forwards to
string::hash() anyhow
- With argList::noFunctionObjects() we use the logic added in
4b93333292 (issue #352)
By removing the '-noFunctionObjects' option, we automatically
suppress the creation of function-objects via Time (with argList
as a parameter).
There is generally no need in these cases for an additional
runTime.functionObjects().off() statement
Use the argList::noFunctionObjects() for more direct configuration
and reduce unnecessary clutter in the -help information.
In previous versions, the -noFunctionObjects would have been redundant
anyhow, so we can also just ignore it now instead.
- allows use with any container with begin(), end() and where the
"*iterator" dereference returns a label, which is used for indexing
into the list of points.
This container could be labelUList, bitSet, labelHashSet, etc
- takes a direct approach of determining which cells are cut and walks
the cell faces directly to build the resulting surface.
- better handling of corner cases.
* Avoids redundant points when the cut passes exactly through a
mesh point.
* Supresses generation of duplicates faces when the plane cut
coincides exactly with a mesh face.
- for severely concave cells where the plane cuts a face multiple times
there is currently no remedial action taken, except to note the
failure and unwind the insertion of the corresponding points and
faces.
- signedDistance() method is like distance() but retains
the positive/negative sign for the side of the plane.
- the sign() method returns the sign as -1,0,+1 integer for
classification purposes where it is important to distinguish between
a zero value and a positive value (eg, for cutting). Optional
tolerance can be supplied to round for zero.
- refactor and inlined simple and frequently used methods.
- add boundBox faceCentre() method, which can be useful for creating
clipping planes from a bounding box.
Relocated treeBoundBox faceNormals to boundBox since they apply
equally there - the meaning of the faces (x-min, x-max, etc)
is the same, even if the point addressing for the faces differs.
- rationalized code dealing with extraction of name or indices from
coordinateSystems, polyBoundaryMesh, faBoundaryMesh, fvBoundaryMesh,
ZoneMesh to use internal implementations that allow direct
searching/matching without building an intermediate list of names.
- simpler and more efficient handling of patch group matching.
- centralizes IOobject handling and treatment of alternative locations.
If an alternative file location is specified, it will be used instead.
- provide decompositionMethod::canonicalName instead of using
"decomposeParDict" in various places.
- treat as a List constant without requiring inclusion of ListOps.H
- replace use of emptyList<label>() with emptyLabelList directly.
The emptyList<T>() casting is disallowed with many modern compilers
and now marked as deprecated (expect early removal).
- relocate labelList typedef to List.H for more general access.
Similar reasoning to having labelUList defined in UList.H
- makes for easier extraction of boundary values since it encapsulates
start/size directly.
Eg,
SubList<T>(allValues, patches.range());
or
bitSet(blocked, patches.range(patchi));
- allows for simpler unpacking of a full list, or list range into any
sufficiently large integral type.
For example,
processorPolyPatch pp = ...;
UOPstream toNbr(pp.neighbProcNo(), pBufs);
toNbr << faceValues.unpack<char>(pp.range());
General:
* -roots, -hostRoots, -fileHandler
Specific:
* -to <coordinateSystem> -from <coordinateSystem>
- Display -help-compat when compatibility or ignored options are available
STYLE: capitalization of options text
- avoids compiler ambiguity when virtual methods such as
IOdictionary::read() exist.
- the method was introduced in 1806, and was thus not yet widely used
- behaves the same as the valid() method, but can be queried directly
like a normal raw pointer and as per std::unique_ptr.
Eg,
autoPtr<T> ptr = ...
if (ptr) ...
- advanced options are not displayed with -help, but only with
-help-full, which helps retain a better overview of the standard
options. Replaces previous ad hoc suppression of -listSwitches,
-listRegisteredSwitches etc.
- simplifies usage.
Support syncPar check on names() to detect inconsistencies.
- simplify readFields, ReadFields and other routines by using these
new methods.
- what was previously termed 'setLargeCellSubset()' is now simply
'setCellSubset()' and supports memory efficient interfaces.
The new parameter ordering avoids ambiguities caused by default
parameters.
Old parameter order:
setLargeCellSubset
(
const labelList& region,
const label currentRegion,
const label patchID = -1,
const bool syncCouples = true
);
New parameter order:
setCellSubset
(
const label regioni,
const labelUList& regions,
const label patchID = -1,
const bool syncCouples = true
);
And without ambiguity:
setCellSubset
(
const labelUList& selectedCells,
const label patchID = -1,
const bool syncCouples = true
);
- support bitSet directly for specifying the selectedCells for
memory efficiency and ease of use.
- Additional constructors to perform setCellSubset() immediately,
which simplifies coding.
For example,
meshParts.set
(
zonei,
new fvMeshSubset(mesh, selectedCells)
);
Or even
return autoPtr<fvMeshSubset>::New(mesh, selectedCells);
- enclosed with a #ifdef Foam_argList_1712 .. #endif pair
(defined by default).
In a later release, this can be disabled by default.
ENH: add input length check for -hostRoots option
Also extended the cubic equation test routine and modified the error
methods so that they more accurately generate the round of error of
evaluation.
This resolves bug report https://bugs.openfoam.org/view.php?id=3015
- instead of dict.lookup(name) >> val;
can use dict.readEntry(name, val);
for checking of input token sizes.
This helps catch certain types of input errors:
{
key1 ; // <- Missing value
key2 1234 // <- Missing ';' terminator
key3 val;
}
STYLE: readIfPresent() instead of 'if found ...' in a few more places.
- the opposite problem from issue #762. Now we also test if the input
token stream had any tokens at all.
- called by the dictionary get<> and readEntry() methods.
- ignore implicit-fallthrough for ragel generated code.
- add -Wno-deprecated-declarations for c++LESSWARN.
These principally associated with older CGAL versions and their use
of particular mpfr routines.
Some special adjustments are undertaken for distance = 0.
- With the isoSurfaceCell algorithm is used, additional checks for open
surfaces edges are used to limit the extend of resulting distance
surface. The resulting surface elements will not, however, contain
partial cell coverage.
- Always treated as signed (ignoring the input value), since it is
nearly impossible to generate any surface otherwise.
- the original intention was to avoid vtp output when the clouds are
empty anyhow. However, it is useful for post-processing to have
clouds with zero parcels (eg, before the start of injection).
Pruning of empty clouds is now an option in the vtkCloud dictionary
controls, with the default being false (no pruning). This represents
a non-breaking change in behaviour since it generates more output
than previously.
Example,
{
type vtkCloud;
//- Suppress writing of empty clouds (default: false)
prune true;
}
This method waits until all the threads have completed IO operations and
then clears any cached information about the files on disk. This
replaces the deactivation of threading by means of zeroing the buffer
size when writing and reading of a file happen in sequence. It also
allows paraFoam to update the list of available times.
Patch contributed by Mattijs Janssens
Resolves bug report https://bugs.openfoam.org/view.php?id=2962
- functionObjectLibs -> libs
- redirectType -> name
- change deprecated writeCompression flags types to Switch.
- cleanup some trailing ';;' from some dictionaries
- The problem is not 100% reproducible, but be somewhat conservative
and now only close(stdin) for pure background (daemon-like) use of
Foam::system(), where it can be useful.
Using Foam::system() for launching background processes is currently
only used for the doc browser.
- since 1612, FOAM_INST_DIR and foamInstDir longer have any
special meanings when sourcing the bashrc or cshrc files.
Thus no need for special treatment in any of the dispatch wrappers.
Retained FOAM_INST_DIR as (unexported) variable in etc/bashrc,
just in case people are using patched versions of etc/bashrc
as part of their installation.
ENH: relax prefix restrictions on foamCreateVideo (issue #904)
- shift the implicit '.' to be part of the default prefix. This allows
things like "-image myimages_00" to work as might be expected.
- respect trailing '-', '.', '_' for the image prefix name.
For example,
-image press_ to accept press_*.png
- additional -mask width option (for avconv)
- The additional output generated by #calc directives in the
controlDict or decomposeParDict causes issues for the RunFunctions
extraction of 'application' and 'numberOfSubdomains'.
Avoid by using -disableFunctionEntries, which also has the side-effect
of disabling '#include'.
- major() and minor() are GNU macros in sys/sysmacros.h
and generates warning on some systems (eg, Ubuntu 18.04)
use getMajor() and getMinor() as method names instead.
- corrected the mass based correction and updated the misleading function
arguments
- moved the option to the optimisation switches, e.g.:
OptimisationSwitches
{
experimentalDdtCorr 1;
}
- default remains off/no (0)
twoPhaseMixtureThermo writes the temperatures during construction only
for them to be read again immediately after by construction of the
individual phases' thermo models. When running with collated file
handling this behaviour is not thread safe. This change deactivates
threading for the duration of this behaviour.
Patch contributed by Mattijs Janssens
- for larger problems with a smaller region of interest, can apply a
bounding to limit the size of the ensight geometry and fields created.
Since the implementation uses a fvMeshSubset, there is an additional
per-process memory overhead.
A high output frequency should be avoided with moving meshes, since
this indirectly forces a frequent update of the submesh.
- const version of offsets().
- empty() method to test for empty offsets, or zero overall size
- reset() methods for reseting the sizes. For example, when the context
has shifted slightly.
- localStart() methods, similar to localSize() methods
STYLE: make globalIndex single parameter constructors explicit
- added line::last() for consistency with edge::last()
- adjusted unitVec() to return Zero for small vectors.
Consistent with VectorSpace normalised() and vector::normalise()
- Don't remove the constant/polyMesh directory if it contains a
blockMeshDict or blockMeshDict.m4 file. Offer a reminder that
system/ is the normal place for it.
- add additional control via a Foam::infoDetailLevel flag, which is
supported by a 'DetailLevel' macro. Eg,
DetailLevel << "some information" << nl
- When infoDetailLevel is zero, the stdout for all Foam::system() calls
are also redirected to stderr to prevent child output from
appearing on the parent.
- close stdin before exec in system call.
- convenient way to temporarily suspend the SIGFPE handler.
Eg,
// Normal code with SIGFPE enabled ...
sigFpe::set();
{
// Ignore SIGFPE in this scope ...
sigFpe::ignore noFpeHandling;
...
}
- use Enum instead of NamedEnum
- shorter form for dimensionedScalar
- reduce verbosity about missed seeding for DTRM cloud.
Re-enable old warnings in debug mode.
- some paraview versions (eg, on windows) don't support float, only double.
This mostly affected the vtkSurfaceWriter.
The foamToVTK is also affected, but since it also supports the XML
output formats (vtp, vtu) these can be used instead.
- affected manually generated legacy output (vtkSetWriter, vtkSurfaceWriter)
- the order emitted by vtkSetWriter remains, but needs to revisited again.
- this provides easily sortable names.
The time information is available via the corresponding .series
file, which can also be loaded directly with ParaView 5.5 or later.
For further redundancy, time information is saved in the first XML
comment inside of the .vtp files. For example,
<!-- cloud=limestoneCloud1 time=0.005 index=200 -->
- now report as "min = XX max = YY average = ZZ"
instead of as "min/max/average = XX, YY, ZZ"
this makes it easier to parse any particular value
(eg, with foamLog)
- should use bitSet::set() and not bitSet::operator[] to auto-vivify
out-of-range entries
- use bitSet::test() instead of bitSet::operator[] when testing
non-const variables - circumvents any potential out-of-range issues.
- Since 'bool' and 'Switch' use the _identical_ input mechanism
(ie, both accept true/false, on/off, yes/no, none, 1/0), the main
reason to prefer one or the other is the output.
The output for Switch is as text (eg, "true"), whereas for bool
it is label (0 or 1). If the output is required for a dictionary,
Switch may be appropriate. If the output is not required, or is only
used for Pstream exchange, bool can be more appropriate.
- Always used for optional dictionary entries, since these are individual
values, and not meant to be embedded in a larger stream of tokens.
Methods:
- lookupOrDefault, lookupOrAddDefault, lookupOrDefaultCompat
- readIfPresent, readIfPresentCompat
- Handling mandatory dictionary entries is slightly more complex,
since these may be part of larger stream of tokens, and are often
used in a constructor context. For example,
word modelType(dict.lookup("type"));
Or they are used without a definite context. For example,
dict.lookup("format") >> outputFormat;
Newly introduced methods for mandatory dictionary entries:
- get, getCompat
- read, readCompat
In a constructor or assignment context:
word modelType(dict.get<word>("type"));
outputFormat = dict.lookup("format");
without copy/move (similar to readIfPresent):
dict.read("format", outputFormat);
- improves backward compatibility and more naming consistency.
Retain setMany(iter1, iter2) to avoid ambiguity with the
PackedList::set(index, value) method.
Basic directional refinement:
- only for coordinate aligned meshes
- only for refinementRegions
See the mesh/snappyHexMesh/aerofoilNACA0012_directionalRefinement
tutorial.
- the current working path with replacements for base-level
OpenFOAM env variables such as FOAM_RUN, WM_PROJECT_DIR,
WM_PROJECT_USER_DIR etc
Can be used directly from the command-line or embedded into a
command prompt. For example,
PS1='$(foamPwd)\n\u\$ '
- aliases for user solver/utilities located under "$WM_PROJECT_USER_DIR":
(ufoam, uapp, usol, uutil)
- using const reference to temporary was failing. Remedy by using a
direct copy, which is a reasonable solution since surfZone content
is quite minimal.
- downgrades some diagnostics about nonconformant code from errors to
warnings. Oddly enough, the errors actually arise from STL library
elements shipped with gcc itself. Affects kahip compilation with
gcc-6, gcc-7
The minimum number of particles per parcel can now be set in the
injection model input, e.g.:
model1
{
type ...;
massTotal ...;
parcelBasisType ...;
minParticlesPerParcel 1; <-- new optional entry
SOI ...;
...
Uses a value of 1 by default if the entry is not present. The value of
1 is generally recommended and beneficial for coupled cases where small
time steps can lead to the injection of too many parcels and subsequently
greatly over-predict the particle source contributions (momentum, heat,
mass transfer etc)
- problems when the cloud was not available on all processors.
- NB: ensight measured data only allows a single cloud, but
foamToEnsight writes all clouds.
- these were previously taken from region-local directories
(eg, constant/region/triSurface), but this becomes difficult to
manage when there are many files and regions.
- The central InfoSwitch "writeLagrangianPositions" allows writing an
additional Lagrangian "positions" file, but these were not being
written by reconstructPar. These are now also written in reconstructPar
if the central writeLagrangianPositions InfoSwitch is enabled.
NOTES
- "positions" are reconstructed from the processors "coordinates" file
- decomposePar will not attempt to create or redistribute any
"positions" files
- disallow insert() of raw pointers, since a failed insertion
(ie, entry already existed) results in an unmanaged pointer.
Either insert using an autoPtr, or set() with raw pointers or autoPtr.
- IOobjectList::add() now takes an autoPtr instead of an object reference
- IOobjectList::remove() now returns an autoPtr instead of a raw pointer
- use normal instead of volumeType to decide on the sign.
This provides a continuous field and eliminates special handling of
GREAT in iso-surface routines.
- fix regression in isoSurfaceCell cutting that was introduced by the
previous adjustments for distanceSurface
- input or output scaling of values to manage dissimilar unit systems
in the structures model
- logging of communicated force, moments and updated positions.
This allows tracking of the information exchange throughout the
duration of the simulation and may assist in post-simulation diagnosis.
- default is now without polyhedral decomposition, since this produces
compacter files and VTK mananges this in most instances.
However, provide function object flag to reinstate the old behaviour.
Calculates and outputs a field whose values are offset to a reference
value obtained by sampling the field at a user-specified location.
The field values are calculated using:
\f[
f_c = s(f_{c,t} - f_p + f_{off})
\f]
where
\vartable
f_c | field values at cell
s | optional scale factor (default = 1)
f_{c,t} | current field values at cell at this time
f_p | field value at position
f_{off} | offset field value (default = 0)
\endvartable
Usage
Example of function object specification to calculate the reference
field:
\verbatim
pRef
{
type reference;
libs ("libfieldFunctionObjects.so");
...
field p;
result pRef;
position (0 0 0);
scale 1.2;
offset 100000;
}
\endverbatim
- the problem arises since the various surface writers are stateless.
The collated output format hacks around this limitation by adding in
its own fieldDict caching (to disk).
Now include an updateMesh() method to hook into geometry changes.
This is considered a stop-gap measure until the surface output
handling is improved.
- improvement documentation for surface sampling.
- can now specify alternative sampling scheme for obtaining the
face values instead of just using the "cell" value. For example,
sampleScheme cellPoint;
This can be useful for cases when the surface is close to a boundary
cell and there are large gradients in the sampled field.
- distanceSurface now handles non-closed surfaces more robustly.
Unknown regions (not inside or outside) are marked internally and
excluded from consideration. This allows use of 'signed' surfaces
where not previously possible.
- a -valgrind option for logging with valgrind
- determine number of processors from system/decomposeParDict
or -decomposeParDict if -np was not specified
- this should normally not be triggered, provided that setRefCell was
used. However, if getRefCellValue() was called without any previous
checking on refCelli, it is possible to provoke errors.
- The iterator for a HashSet dereferences directly to its key.
- Eg,
for (const label patchi : patchSet)
{
...
}
vs.
forAllConstIter(labelHashSet, patchSet, iter)
{
const label patchi = iter.key();
...
}
- the algorithm was last used in OpenFOAM-2.4, after which it was
replaced with a FaceCellWave version.
Whereas the original (2.4.x) version exhibited performance
degradation on very large meshes (with explicit constraints), the
FaceCellWave version exhibited performance issues with large numbers
of blocked faces.
With large numbers of blocked faces, the FaceCellWave regionSplit
could take between 10 to 100 times longer due to the slow
propagation speed through blocked faces.
The 2.4 regionSplit has been revamped to avoid local memory
allocations, which appears to have been the source of the original
performance issues on large meshes.
For additional performance, intermediate renumbering is also avoided
during the consolidation of regions over processor domains.
- controlled by the the 'printExecutionFormat' InfoSwitch in
etc/controlDict
// Style for "ExecutionTime = " output
// - 0 = seconds (with trailing 's')
// - 1 = day-hh:mm:ss
ExecutionTime = 112135.2 s ClockTime = 113017 s
ExecutionTime = 1-07:08:55.20 ClockTime = 1-07:23:37
- Callable via the new Time::printExecutionTime() method,
which also helps to reduce clutter in the applications.
Eg,
runTime.printExecutionTime(Info);
vs
Info<< "ExecutionTime = " << runTime.elapsedCpuTime() << " s"
<< " ClockTime = " << runTime.elapsedClockTime() << " s"
<< nl << endl;
--
ENH: return elapsedClockTime() and clockTimeIncrement as double
- previously returned as time_t, which is less portable.
For example, with some HashTable or Map container of models
{ model0 => 1, model1 => 4, model2 => 5, model3 => 12, model4 => 15, }
specify the remapping
Map<label> mapper({{1, 3}, {2, 6}, {3, 12}, {5, 8}});
inplaceMapValue(mapper, models) then yields
{ model0 => 3, model1 => 4, model2 => 8, model3 => 12, model4 => 15, }
--
ENH: extend bitSet::count() to optionally count unset bits instead.
--
ENH: BitOps compatibility methods for boolList.
- These ease coding that uses a boolList instead of bitSet and use
short-circuit logic when possible.
Eg, when 'bitset' and 'bools' contain the same information
bitset.count() <-> BitOps::count(bools)
bitset.all() <-> BitOps::all(bools)
bitset.any() <-> BitOps::any(bools)
bitset.none() <-> BitOps::none(bools)
These methods can then be used directly in parameters or in logic.
Eg,
returnReduce(bitset.any(), orOp<bool>());
returnReduce(BitOps::any(bools), orOp<bool>());
if (BitOps::any(bools)) ...
- since PackedBoolList is now a compatibility typedef for bitSet,
it is useful to have an additional means of distinction.
STYLE: simplify internal version tests and compiler defines.
- the API version is now conveyed via the OPENFOAM define directly.
The older OPENFOAM_PLUS define is provided for existing code.
- parsing error state only arises from a missing final newline
in the file (which the dnl macro does not capture).
Report with a warning instead of modifying the dnl macro since
we generally wish to know about this anyhow.
- add missing newline to YEqn.H file.
- flags the following type of problems:
* mismatches:
keyword mismatch ( set of { brackets ) in the } entry;
* underflow (too many closing brackets:
keyword too many ( set of ) brackets ) in ) entry;
- a missing semi-colon
dict
{
keyword entry with missing semi-colon
}
will be flagged as 'underflow', since it parses through the '}' but
did not open with it.
Max monitoring depth is 60 levels of nesting, to avoid incurring any
memory allocation.
- handling of dead links (find -L -delete unsupported)
- remove ignore case flag on 's/../../i' used in have_scotch script.
It is unneeded and not tolerated by Darwin's sed.
- avoid embedded comments in EXE_INC (Make/options files), which do
not work well with the OSX LLVM cpp.
It strips out the comments but also removes the continuation char.
STYLE: adjust notes about paraview library locations
- generalize some of the library extensions (.so vs .dylib).
Provide as wmake 'sysFunctions'
- added note about unsupported/incomplete system support
- centralize detection of ThirdParty packages into wmake/ subdirectory
by providing a series of scripts in the spirit of GNU autoconfig.
For example,
have_boost, have_readline, have_scotch, ...
Each of the `have_<package>` scripts will generally provide the
following type of functions:
have_<package> # detection
no_<package> # reset
echo_<package> # echoing
and the following type of variables:
HAVE_<package> # unset or 'true'
<package>_ARCH_PATH # root for <package>
<package>_INC_DIR # include directory for <package>
<package>_LIB_DIR # library directory for <package>
This simplifies the calling scripts:
if have_metis
then
wmake metisDecomp
fi
As well as reducing clutter in the corresponding Make/options:
EXE_INC = \
-I$(METIS_INC_DIR) \
-I../decompositionMethods/lnInclude
LIB_LIBS = \
-L$(METIS_LIB_DIR) -lmetis
Any additional modifications (platform-specific or for an external build
system) can now be made centrally.
- also simplify parsing by accepting any case on keywords.
This implies that something like "sOlId", "SoLiD" will also
be accepted. Although nobody should really count on this rather
generous behaviour, it does simplfy the state machine even further.
- in 2.4.x the general default for polyMesh::findCell was FACE_DIAG_TRIS,
but this was changed to CELL_TETS for better handling of concave
cells.
- in snappyHexMesh meshRefinement, findCell is used to define
locations in mesh and cells for closer refinement. Using CELL_TETS
causes an octree rebuild when the mesh has changed and this adds
considerable overhead. For this operation, the faster FACE_DIAG_TRIS
mode can be used instead.
- the previous grammar used
'/*' { fgoto comment; }
to start processing multi-line comments and
comment := any* :>> '*/' @{ fgoto main; };
as a finishing action to return to normal lexing, but seemed not to
have been triggered properly.
Now simply trap in a single rule:
'/*' any* :>> '*/'; # Multi-line comment
STYLE: use more compact dnl (delete to newline)
OLD: [^\n]* '\n'
NEW: (any* -- '\n') '\n'
eliminates the intermediate state
- the API-versioned calls (eg, tecini142, teczne142, tecpoly142, tecend142),
the limited availability of the SDK and lack of adequate testing make
proper maintenance very difficult.
- these errors are mostly rounding related (when a point is located on
the edge of a bounding box instead of being fully inside it).
For debug > 1, continue to treat as fatal.
- IOstreamOption class to encapsulate format, compression, version.
This is ordered to avoid internal padding in the structure, which
reduces several bytes of memory overhead for stream objects
and other things using this combination of data.
Byte-sizes:
old IOstream:48 PstreamBuffers:88 Time:928
new IOstream:24 PstreamBuffers:72 Time:904
====
STYLE: remove support for deprecated uncompressed/compressed selectors
In older versions, the system/controlDict used these types of
specifications:
writeCompression uncompressed;
writeCompression compressed;
As of DEC-2009, these were deprecated in favour of using normal switch
names:
writeCompression true;
writeCompression false;
writeCompression on;
writeCompression off;
Now removed these deprecated names and treat like any other unknown
input and issue a warning. Eg,
Unknown compression specifier 'compressed', assuming no compression
====
STYLE: provide Enum of stream format names (ascii, binary)
====
COMP: fixed incorrect IFstream construct in FIREMeshReader
- spurious bool argument (presumably meant as uncompressed) was being
implicitly converted to a versionNumber. Now caught by making
IOstreamOption::versionNumber constructor explicit.
- bad version specifier in changeDictionary
- In addition to the traditional Flex-based parser, added a Ragel-based
parser and a handwritten one.
Some representative timings for reading 5874387 points (1958129 tris):
Flex Ragel Manual
5.2s 4.8s 6.7s total reading time
3.8s 3.4s 5.3s without point merging
- However, the new ragel-based parser is much faster
than the others, and does not cause 'too many open files' error
that the flex-based parser does (issue #784).
The timings (using src/sampling as being somewhat representative)
$ wclean; wmakeLnInclude -u .; time wmake -s dep
3.4s wmkdepend (ragel) [now default]
5.7s wmkdep (flex)
6.1s cpp -M
- The makeDepend script is for testing purposes only, but could used as
a hook for other dependency generation systems (eg, ninja).
It simply wraps 'cpp -M' in a form that is calling compatible with
wmkdepend.
BUG: wmkdepend parser was missing optional leading space on #include match
STYLE: use -G2 (goto-based) option for wmkdepend state machine
- the machine is compact with few states and lends itself to this
- the expansions were previously required as slash to follow, but
now either are possible.
"<case>", "<case>/" both yield the same as "$FOAM_CASE" and
will not have a trailing slash in the result. The expansion of
"$FOAM_CASE/" will however have a trailing slash.
- adjust additional files using these expansions
- a partial selection from https://github.com/mrklein/openfoam-os-x
with adjustments. The primary purpose is to reduce header-level
incompatibilities and to provide a common set of make rules to allow
easier patching (or re-integration).
This is similar to efforts (Feb 2010) but using ragel
(https://en.wikipedia.org/wiki/Ragel) instead of the now defunct
coco/r. The modified commit message from 2010:
ENH: add C++-based wmkdepend parser (uses ragel grammar).
- This avoids dependency on lex/flex and provides better encapsulation
for buffer switching. As a result, the maximum number of open files
only corresponds to the include depth.
--
Note that the flex source and rules are still available, but are not
deactivate (see wmake/rules/General/transform)
Support the following expansions when they occur at the start of a
string:
Short-form Equivalent
========= ===========
<etc>/ ~OpenFOAM/ (as per foamEtcFile)
<case>/ $FOAM_CASE/
<constant>/ $FOAM_CASE/constant/
<system>/ $FOAM_CASE/system/
These can be used in fileName expansions to improve clarity and reduce
some typing
"<constant>/reactions" vs "$FOAM_CASE/constant/reactions"
ParaView 5.4 and older:
- requires lib/paraview-X.X only
ParaView 5.5:
- requires lib/
- does not appear to require lib/paraview-X.X, but retained for simplicity
- Change default version to paraview-5.5.0 for testing purposes
- this removes an OS-specific dependency (eg, drand48_r is not POSIX)
and allows easier use of other random number generators.
The Rand48 generator has identical behaviour and period as the
lrand48() library routine, but holds its own seed and state
(which makes it re-entrant) and can be combined with other
random distributions.
However, when using the modified form to obtain scalar values
they will not be identical to what drand48() yields.
This is because drand48() uses the raw 48-bit values to directly
set the mantissa of an IEEE double where as the newer distribution
normalizes based on the 32-bit value.
STYLE: simplify code in Random::shuffle and use Swap
keeping chocked conditions of Mach number.
This BC can work in two modes, chocked or non-chocked. In the
chocked mode the Ma is an input. In the non-chocked mode
the Ma is calculated from model inputs.
- in many cases can just use lookupOrDefault("key", bool) instead of
lookupOrDefault<bool> or lookupOrDefault<Switch> since reading a
bool from an Istream uses the Switch(Istream&) anyhow
STYLE: relocated Switch string names into file-local scope
- improve internal handling to permit deriving resizable containers
(eg, PtrDynList).
- include '->' iterator dereferencing
- Only append/set non-const autoPtr references. This doesn't break
existing code, but makes the intention more transparent.
- both autoPtr and tmp are defined with an implicit construct from
nullptr (but with explicit construct from a pointer to null).
Thus is it safe to use 'nullptr' when returning an empty autoPtr or tmp.
The set of injectionMethods has been extended to include a new option:
injectionMethod movingPoint;
The position is then read as a TimeFunction1 entry, e.g. for a 'table'
type:
position table
(
(0 (-0.009 0.0995 0))
(1e-3 (0.009 0.0995 0))
);
where the list corresponds to the tuples (time (position)), and the time
is relative to the start of injection (SOI)
- when constructing dimensioned fields that are to be zero-initialized,
it is preferrable to use a form such as
dimensionedScalar(dims, Zero)
dimensionedVector(dims, Zero)
rather than
dimensionedScalar("0", dims, 0)
dimensionedVector("zero", dims, vector::zero)
This reduces clutter and also avoids any suggestion that the name of
the dimensioned quantity has any influence on the field's name.
An even shorter version is possible. Eg,
dimensionedScalar(dims)
but reduces the clarity of meaning.
- NB: UniformDimensionedField is an exception to these style changes
since it does use the name of the dimensioned type (instead of the
regIOobject).
- also ensure fewer side-effects from inplaceReorder
- provide ListOps::reorder especially for PackedList and PackedBoolList
since they behave differently from regular lists.
- eliminate iterators from PackedList since they were unused, had
lower performance than direct access and added unneeded complexity.
- eliminate auto-vivify for the PackedList '[] operator.
The set() method provides any required auto-vivification and
removing this ability from the '[]' operator allows for a lower
when accessing the values. Replaced the previous cascade of iterators
with simpler reference class.
PackedBoolList:
- (temporarily) eliminate logic and addition operators since
these contained partially unclear semantics.
- the new test() method tests the value of a single bit position and
returns a bool without any ambiguity caused by the return type
(like the get() method), nor the const/non-const access (like
operator[] has). The name corresponds to what std::bitset uses.
- more consistent use of PackedBoolList test(), set(), unset() methods
for fewer operation and clearer code. Eg,
if (list.test(index)) ... | if (list[index]) ...
if (!list.test(index)) ... | if (list[index] == 0u) ...
list.set(index); | list[index] = 1u;
list.unset(index); | list[index] = 0u;
- deleted the operator=(const labelUList&) and replaced with a setMany()
method for more clarity about the intended operation and to avoid any
potential inadvertent behaviour.
- clockValue class for managing the clock values only, with a null
constructor that does not query the system clock (can defer to later).
Can also be used directly for +/- operations.
- refactor clockTime, cpuTime, clock to reduce storage.
- The bitSet class replaces the old PackedBoolList class.
The redesign provides better block-wise access and reduced method
calls. This helps both in cases where the bitSet may be relatively
sparse, and in cases where advantage of contiguous operations can be
made. This makes it easier to work with a bitSet as top-level object.
In addition to the previously available count() method to determine
if a bitSet is being used, now have simpler queries:
- all() - true if all bits in the addressable range are empty
- any() - true if any bits are set at all.
- none() - true if no bits are set.
These are faster than count() and allow early termination.
The new test() method tests the value of a single bit position and
returns a bool without any ambiguity caused by the return type
(like the get() method), nor the const/non-const access (like
operator[] has). The name corresponds to what std::bitset uses.
The new find_first(), find_last(), find_next() methods provide a faster
means of searching for bits that are set.
This can be especially useful when using a bitSet to control an
conditional:
OLD (with macro):
forAll(selected, celli)
{
if (selected[celli])
{
sumVol += mesh_.cellVolumes()[celli];
}
}
NEW (with const_iterator):
for (const label celli : selected)
{
sumVol += mesh_.cellVolumes()[celli];
}
or manually
for
(
label celli = selected.find_first();
celli != -1;
celli = selected.find_next()
)
{
sumVol += mesh_.cellVolumes()[celli];
}
- When marking up contiguous parts of a bitset, an interval can be
represented more efficiently as a labelRange of start/size.
For example,
OLD:
if (isA<processorPolyPatch>(pp))
{
forAll(pp, i)
{
ignoreFaces.set(i);
}
}
NEW:
if (isA<processorPolyPatch>(pp))
{
ignoreFaces.set(pp.range());
}
- primary points for an external user are the polyMesh constructor
- add config info for gcc-7.3.0
COMP: intel-2017. Ignore unknown pragmas. Disambiguate method resolution.
This class is largely a pre-C++11 holdover. It is now possible to
simply use move construct/assignment directly.
In a few rare cases (eg, polyMesh::resetPrimitives) it has been
replaced by an autoPtr.
- rvalue() is a (transitional) means of converting Xfer content to a
reference for move construct, move assign semantics.
- valid() method for consistency with autoPtr and tmp classes
Improve alignment of its behaviour with std::shared_ptr
- element_type typedef
- swap, reset methods
* additional reference access methods:
cref()
returns a const reference, synonymous with operator().
This provides a more verbose alternative to using the '()' operator
when that is desired.
Mnemonic: a const form of 'ref()'
constCast()
returns a non-const reference, regardless if the underlying object
itself is a managed pointer or a const object.
This is similar to ref(), but more permissive.
Mnemonic: const_cast<>
Using the constCast() method greatly reduces the amount of typing
and reading. And since the data type is already defined via the tmp
template parameter, the type deduction is automatically known.
Previously,
const tmp<volScalarField>& tfld;
const_cast<volScalarField&>(tfld()).rename("name");
volScalarField& fld = const_cast<volScalarField&>(tfld());
Now,
tfld.constCast().rename("name");
auto& fld = tfld.constCast();
--
BUG: attempts to move tmp value that may still be shared.
- old code simply checked isTmp() to decide if the contents could be
transfered. However, this means that the content of a shared tmp
would be removed, leaving other instances without content.
* movable() method checks that for a non-null temporary that is
unique (not shared).
Improve alignment of its behaviour with std::unique_ptr
- element_type typedef
- release() method - identical to ptr() method
- get() method to get the pointer without checking and without releasing it.
- operator*() for dereferencing
Method name changes
- renamed rawPtr() to get()
- renamed rawRef() to ref(), removed unused const version.
Removed methods/operators
- assignment from a raw pointer was deleted (was rarely used).
Can be convenient, but uncontrolled and potentially unsafe.
Do allow assignment from a literal nullptr though, since this
can never leak (and also corresponds to the unique_ptr API).
Additional methods
- clone() method: forwards to the clone() method of the underlying
data object with argument forwarding.
- reset(autoPtr&&) as an alternative to operator=(autoPtr&&)
STYLE: avoid implicit conversion from autoPtr to object type in many places
- existing implementation has the following:
operator const T&() const { return operator*(); }
which means that the following code works:
autoPtr<mapPolyMesh> map = ...;
updateMesh(*map); // OK: explicit dereferencing
updateMesh(map()); // OK: explicit dereferencing
updateMesh(map); // OK: implicit dereferencing
for clarity it may preferable to avoid the implicit dereferencing
- prefer operator* to operator() when deferenced a return value
so it is clearer that a pointer is involve and not a function call
etc Eg, return *meshPtr_; vs. return meshPtr_();
- constexpr, noexcept.
Added an 'at()' method for returning an iterator within the range
and changed operator()(label) to have behaviour as per found().
This makes the labelRange usable as a unary predicate.
- added templated conversion class 'toLabelRange'
- add range() method to polyPatch and surfZone classes, and corresponding
templated conversion functors.
For example,
auto patchDims = ListOps::create<labelRange>
(
mesh.boundaryMesh(),
toLabelRange<polyPatch>()
);
to create a List<labelRange> representing the patch extents.
- relocated HashSetPlusEqOp and HashTablePlusEqOp to
HashSetOps::plusEqOp and HashTableOps::plusEqOp, respectively
- additional functions for converting between a labelHashSet
and a PackedBoolList or List<bool>:
From lists selections to labelHashSet indices:
HashSetOps::used(const PackedBoolList&);
HashSetOps::used(const UList<bool>&);
From labelHashSet to list forms:
PackedBoolList bitset(const labelHashSet&);
List<bool> bools(const labelHashSet&);
- relocated ListAppendEqOp and ListUniqueEqOp to ListOps::appendEqOp
and ListOps::UniqueEqOp, respectively for better code isolation and
documentation of purpose.
- relocated setValues to ListOps::setValue() with many more
alternative selectors possible
- relocated createWithValues to ListOps::createWithValue
for better code isolation. The default initialization value is itself
now a default parameter, which allow for less typing.
Negative indices in the locations to set are now silently ignored,
which makes it possible to use an oldToNew mapping that includes
negative indices.
- additional ListOps::createWithValue taking a single position to set,
available both in copy assign and move assign versions.
Since a negative index is ignored, it is possible to combine with
the output of List::find() etc.
STYLE: changes for PackedList
- code simplication in the PackedList iterators, including dropping
the unused operator() on iterators, which is not available in plain
list versions either.
- improved sizing for PackedBoolList creation from a labelUList.
ENH: additional List constructors, for handling single element list.
- can assist in reducing constructor ambiguity, but can also helps
memory optimization when creating a single element list.
For example,
labelListList labels(one(), identity(mesh.nFaces()));
- constexpr, noexcept on various bits
- addition of a 'one::minus' class that returns '-1' instead of '1'.
There are no additional operations defined for this class,
but it can be used in various places to signal alternative behaviour
such as "initialize to a negative or other invalid value"
- This class is largely a pre-C++11 holdover, prior to having movable
references.
- align internals with autoPtr instead of always unconditionally
allocating memory. The valid() method can be used to check for a null
pointer.
- Consolidate into a single file, in anticipation of future removal.
- deprecated MAR-2017
subset(const UList<T>& select, const T& value, const ListType&);
inplaceSubset(const UList<T>& select, const T& value, ListType&);
The subsetList/inplaceSubsetList variants with a unary predicate
provide more flexible and robuster solutions.
- deprecated MAR-2017
initList(const T[mRows]);
initListList(const T[mRows][nColumns]);
Required prior to the addition of constructors with
std::initializer_list
* For most cases, this conversion would be largely unintentional
and also less efficient. If the regex is desirable, the caller
should invoke it explicitly.
For example,
findStrings(regExp(str), listOfStrings);
Or use one of the keyType, wordRe, wordRes variants instead.
If string is to be used as a plain (non-regex) matcher,
this can be directly invoked
findMatchingStrings(str, listOfStrings);
or using the ListOps instead:
findIndices(listOfStrings, str);
* provide function interfaces for keyType.
- subsetList, inplaceSubsetList with optional inverted logic.
- use moveable elements where possible.
- allow optional starting offset for the identity global function.
Eg, 'identity(10, start)' vs 'identity(10) + start'
- more consistent with STL practices for function classes.
- string::hash function class now operates on std::string rather
than Foam::string since we have now avoided inadvertent use of
string conversion from int in more places.
- Eg instead of using labelHashSet, used HashSet<label> which uses
the string::hash for hashing. Other places inadvertently using the
string::hash instead of Hash<label> for hashing.
STYLE: use Map<..> instead of HashTable<.., label, Hash<label>>
- reduces clutter
- add copy construct from UList
- remove copy construct from dissimilar types.
This templated constructor was too generous in what it accepted.
For the special cases where a copy constructor is required with
a change in the data type, now use the createList factory method,
which accepts a unary operator. Eg,
auto scalars = scalarList::createList
(
labels,
[](const label& val){ return 1.5*val; }
);
- now warn about the following:
* the bounding box does not overlap wih the global mesh
* plane does not intersect the (valid) bounding box
* plane does not intersect the global mesh
- add bounding to the "plane" variant of a sampled plane.
- simplify structure, removed unused constuctors.
- transfer from base objects via '=' assignment removed as being too
non-transparent
- add New factory method with perfect forwarding.
- use std::reverse_iterator adaptors, avoid the array-bounds warning
- use pointer arithmetic instead of dereferencing the internal array
- adjust logic to use 'operator<' instead of 'operator>' in sorting.
This creates less work when making other classes sortable.
- the transfer method was previously a copy
- use std::reverse_iterator adaptors in FixedList
This greatly reduces the amount of code and now avoids the array-bounds
warning for FixedList::rend()
- use pointer arithmetic instead of dereferencing the internal array
- without these will use the normal move construct + move assign.
This is similarly efficient, but avoids the inadvertently having the
incorrect Swap being used for derived classes.
STYLE: remove unused xfer methods for HashTable, HashSet
- unneeded since move construct and move assignment are possible
- can stop producing content when the target number of entries has
been reached.
- change return type to labelList instead an Xfer container.
This allows return-value-optimization and avoids a surrounding
allocation. This potentially breaks existing code.
- make PackedList and PackedBoolList moveable. Drop xfer wrappers.
- forward command-line arguments for paraview, where they may also be
evaluated (cshrc, POSIX shell)
Eg,
. etc/bashrc ParaView_VERSION=5.4.1-mpipy
source etc/cshrc ParaView_VERSION=5.4.1-mpipy
- this currently just strips off the leading parent directory name
"/this/path/and/subdirs/name"
relative("/this/path") -> "and/subdirs/name"
relative("/this") -> "path/and/subdirs/name"
'delta'
The scheme should now be specified using, e.g.
div(phi,U) Gauss DEShybrid
linear // scheme 1
linearUpwind grad(U) // scheme 2
hmax // LES delta name, e.g. 'delta', 'hmax'
0.65 // DES coefficient, typically = 0.65
30 // Reference velocity scale
2 // Reference length scale
0 // Minimum sigma limit (0-1)
1 // Maximum sigma limit (0-1)
1.0e-03; // Limiter of B function, typically 1e-03
- simplify structure.
- protect against nullptr when resetting memory streams
- make UIListStream swappable
- add uiliststream as an example of using a plain std::istream
- define regExp::results_type using SubStrings container for handling
groups. This makes a later shift to std::smatch easier, but changes
the regExp API for matching with groups. Previously had list element
0 for regex group 1, now list element 0 is the entire match and list
element 1 is regex group 1.
Old:
List<std::string> mat;
if (re.match(text, mat)) Info<< "group 1: " << mat[0] << nl;
New:
regExp::results_type mat;
if (re.match(text, mat)) Info<< "group 1: " << mat.str(1) << nl;
- problems were introduced by the change ee252307d3 (issue #686).
Affected reading of OBJ files.
The fallback zone (used to catch unnamed groups/zones), which was
previously filtered away when not needed. Now handle more explicitly.
ENH: use stringOps::split and low-level read{Label,Scalar} for parsing OBJ file
- export library path for gmp/mpfr from CGAL config files.
This is required when non-system gmp/mpfr libraries are being
used, but not using a ThirdParty compiler installation.
- automatically handle lib/ vs lib64/ (eg, for central installations)
for packages such as boost, CGAL, etc. While the ThirdParty
compilation of these will normally land in lib64/, this may not be
the case when they are supplied by another means.
- reworked the handling of foamEtcFile and foamCleanPath for less
clutter in the configuration files.
Added the bin/tools/lib-dir script to handle logic that is
too complex to easily manage in csh.
The total number of escaped|stick particles in patches can now be sorted by the injectorID from
which the particle originated. It uses outputByInjectorId keyword in the localInteractionCoeffs
dictionary
- for tutorials that are known to run poorly, can provide a
placeholder Allrun-optional instead of the usual Allrun script.
If this is detected, the case will be skipped.
- can be used to handle when options become redundant, but it is
undesirable to treat its presence as an error. Can now tag it as
being ignored.
argList::ignoreOptionCompat({"oldOption", 1706}, true);
argList::ignoreOptionCompat({"oldBoolOpttion", 1706}, false);
command -oldOption xyz -oldBoolOpttion
- use succincter method names that more closely resemble dictionary
and HashTable method names. This improves method name consistency
between classes and also requires less typing effort:
args.found(optName) vs. args.optionFound(optName)
args.readIfPresent(..) vs. args.optionReadIfPresent(..)
...
args.opt<scalar>(optName) vs. args.optionRead<scalar>(optName)
args.read<scalar>(index) vs. args.argRead<scalar>(index)
- the older method names forms have been retained for code compatibility,
but are now deprecated
- now avoid Istream and token mechanism in favour of a simpler string
parser. This makes the code clearer, smaller, robuster.
- provide convenience ge/gt/le/lt static constructors for scalarRange
for using bounds directly with specifying via a string parameter.
- scalarRange, scalarRanges now follow the unary predicate pattern
(using an operator() for testing). This allows their reuse in
other contexts. Eg, for filtering operations:
myHash.filterValues(scalarRange::ge(100));
- remove unused scalarRanges methods that were specific to handling
lists of time values. These were superseded by timeSelector methods
several versions ago.
- support move construct/assignment for linked-lists themselves
and when moving into a 'normal' list
- better consistency with begin/end signatures and the various
iterators.
- for indirect linked-lists, provide iterator access to the underlying
data element address: iter.get() vs &(iter())
- add standard '->' indirection for iterators (as per normal STL
definitions)
- comments
- avoid egrep for getting processor count.
- wcleanBuild, wcleanPlatform with shorter form '-curr' instead of '-c'
to avoid any potential user confusion with '-comp'
- this avoids a situation when an aborted sourcing of the etc/bashrc
file can leave WM_SHELL_FUNCTIONS defined, which causes all
subsequent sourcing to fail.
- can be used to test the behaviour of the decomposion and its
characteristics without writing any decomposition to disk.
Combine with -cellDist to visualize the expected decomposition
result.
- aids with detection of excess tokens (issue #762)
- deprecated dictionary::operator[] in favour of the lookup() method
which offers more flexibilty and clarity of purpose.
Additionally, the read<> and get<> forms should generally be used
instead anyhow.
- FOAM_CONFIG_NOUSER
Suppress use of user/group configuration files.
This is useful when packaging for a central installation.
- allow additional user tuning of compiler settings.
Per-compiler overrides in "compiler-$WM_COMPILER" files
- the vector normalise() method modifies the object inplace,
the normalised function returns a copy.
vector vec1(1,2,3);
vec1.normalise();
vs
vector vec1(1,2,3);
vec1 /= mag(vec1) + VSMALL;
For const usage, can use either of these
const vector vec2a(normalised(vector(1,2,3)));
const vector vec2b(vector(1,2,3).normalise());
DOC: document topo sources inputs in doxygen format
ENH: check for excess tokens in dictionary input (issue #762)
- various bits of code cleanup (modernization) in meshTool/sets.
- improve doxygen entries for searchable surfaces.
- support selection of searchable surfaces with shorter names.
Eg,
type box | cylinder | ...;
vs type searchableBox | searchableCylinder | ...;
- relocate some standard functionality to TimePaths to allow a lighter
means of managing time directories without using the entire Time
mechanism.
- optional enableLibs for Time construction (default is on)
and a corresponding argList::noLibs() and "-no-libs" option
STYLE:
- mark Time::outputTime() as deprecated MAY-2016
- use pre-increment for runTime, although there is no difference in
behaviour or performance.
- support VTP input in functionObjectCloud scene element
- additional fallback lookup of cloud information from state properties
instead of cloud OutputProperties
version on a switch. See #867
By default the code will use the same form as previous versions
To use the experimental version integrated from openfoam.org commit
da787200 set the info switch in the controlDict:
InfoSwitches
{
experimentalDdtCorr 1;
}
- when the iso-surface (eg, a cut plane, or distanceSurface) passes
exactly through the cell centre, zero-sized triangles can occur.
These should be merged away.
- link CGAL (clang version) without reference to mpfr,gmp libraries
- use offset address in printStack for Darwin as well
- alternative handling of feexcept on Darwin
- Reimplemented treatment of alpha1, phi and U in case of
nOuterCorrectors > 1 based on storePrevIter() to avoid cluttering the
solver with unnecessary fields in case of nOuterCorrectors = 1.
- Updated tutorial headers
- Added copyright note to isoAdvector src
- Removed outcommented code lines in interIsoFoam solver
- Removed all LTS from interIsoFoam since this is not currently supported
- Confirmed that discInConstantFlow gives identical results with N subCylces and time step N*dt
- Confirmed that this also holds when nOuterCorrectors > 1.
- start/end values were underrepresented due to rounding.
Now extend the range to include -0.5 and +0.5 beyond the usual
range to ensure the same number density.
Residual fields can be written using the new 'writeFields' entry, e.g.
functions
{
residual
{
type residuals;
libs ("libutilityFunctionObjects.so");
fields (".*");
writeControl writeTime;
writeFields true;
}
}
Fields currently correspond to the initial residual for the last solver
iteration.
-dry-run : perform check only and no writing
-dry-run-write: perform check and write to the next time step. This
also triggers function objects that fire on the call to write()
Improvements to existing functionality
--------------------------------------
- MPI is initialised without thread support if it is not needed e.g. uncollated
- Use native c++11 threading; avoids problem with static destruction order.
- etc/cellModels now only read if needed.
- etc/controlDict can now be read from the environment variable FOAM_CONTROLDICT
- Uniform files (e.g. '0/uniform/time') are now read only once on the master only
(with the masterUncollated or collated file handlers)
- collated format writes to 'processorsNNN' instead of 'processors'. The file
format is unchanged.
- Thread buffer and file buffer size are no longer limited to 2Gb.
The global controlDict file contains parameters for file handling. Under some
circumstances, e.g. running in parallel on a system without NFS, the user may
need to set some parameters, e.g. fileHandler, before the global controlDict
file is read from file. To support this, OpenFOAM now allows the global
controlDict to be read as a string set to the FOAM_CONTROLDICT environment
variable.
The FOAM_CONTROLDICT environment variable can be set to the content the global
controlDict file, e.g. from a sh/bash shell:
export FOAM_CONTROLDICT=$(foamDictionary $FOAM_ETC/controlDict)
FOAM_CONTROLDICT can then be passed to mpirun using the -x option, e.g.:
mpirun -np 2 -x FOAM_CONTROLDICT simpleFoam -parallel
Note that while this avoids the need for NFS to read the OpenFOAM configuration
the executable still needs to load shared libraries which must either be copied
locally or available via NFS or equivalent.
New: Multiple IO ranks
----------------------
The masterUncollated and collated fileHandlers can now use multiple ranks for
writing e.g.:
mpirun -np 6 simpleFoam -parallel -ioRanks '(0 3)'
In this example ranks 0 ('processor0') and 3 ('processor3') now handle all the
I/O. Rank 0 handles 0,1,2 and rank 3 handles 3,4,5. The set of IO ranks should always
include 0 as first element and be sorted in increasing order.
The collated fileHandler uses the directory naming processorsNNN_XXX-YYY where
NNN is the total number of processors and XXX and YYY are first and last
processor in the rank, e.g. in above example the directories would be
processors6_0-2
processors6_3-5
and each of the collated files in these contains data of the local ranks
only. The same naming also applies when e.g. running decomposePar:
decomposePar -fileHandler collated -ioRanks '(0 3)'
New: Distributed data
---------------------
The individual root directories can be placed on different hosts with different
paths if necessary. In the current framework it is necessary to specify the
root per slave process but this has been simplified with the option of specifying
the root per host with the -hostRoots command line option:
mpirun -np 6 simpleFoam -parallel -ioRanks '(0 3)' \
-hostRoots '("machineA" "/tmp/" "machineB" "/tmp")'
The hostRoots option is followed by a list of machine name + root directory, the
machine name can contain regular expressions.
New: hostCollated
-----------------
The new hostCollated fileHandler automatically sets the 'ioRanks' according to
the host name with the lowest rank e.g. to run simpleFoam on 6 processors with
ranks 0-2 on machineA and ranks 3-5 on machineB with the machines specified in
the hostfile:
mpirun -np 6 --hostfile hostfile simpleFoam -parallel -fileHandler hostCollated
This is equivalent to
mpirun -np 6 --hostfile hostfile simpleFoam -parallel -fileHandler collated -ioRanks '(0 3)'
This example will write directories:
processors6_0-2/
processors6_3-5/
A typical example would use distributed data e.g. no two nodes, machineA and
machineB, each with three processes:
decomposePar -fileHandler collated -case cavity
# Copy case (constant/*, system/*, processors6/) to master:
rsync -a cavity machineA:/tmp/
# Create root on slave:
ssh machineB mkdir -p /tmp/cavity
# Run
mpirun --hostfile hostfile icoFoam \
-case /tmp/cavity -parallel -fileHandler hostCollated \
-hostRoots '("machineA" "/tmp" "machineB" "/tmp")'
Contributed by Mattijs Janssens
Specialized variants of the power law porosity and k epsilon turbulence models
developed to simulate atmospheric flow over forested and non-forested complex
terrain.
Class
Foam::powerLawLopesdaCosta
Description
Variant of the power law porosity model with spatially varying
drag coefficient
given by:
\f[
S = -\rho C_d \Sigma |U|^{(C_1 - 1)} U
\f]
where
\vartable
\Sigma | Porosity surface area per unit volume
C_d | Model linear coefficient
C_1 | Model exponent coefficient
\endvartable
Reference:
\verbatim
Costa, J. C. P. L. D. (2007).
Atmospheric flow over forested and non-forested complex terrain.
\endverbatim
Class
Foam::RASModels::kEpsilonLopesdaCosta
Description
Variant of the standard k-epsilon turbulence model with additional source
terms to handle the changes in turbulence in porous regions represented by
the powerLawLopesdaCosta porosity model.
Reference:
\verbatim
Costa, J. C. P. L. D. (2007).
Atmospheric flow over forested and non-forested complex terrain.
\endverbatim
The default model coefficients are
\verbatim
kEpsilonLopesdaCostaCoeffs
{
Cmu 0.09;
C1 1.44;
C2 1.92;
sigmak 1.0;
sigmaEps 1.3;
}
\endverbatim
Tutorial case to follow.
Minmod is the default limiter function and specified with an explicit name e.g.:
gradSchemes
{
default Gauss linear;
limited cellLimited Gauss linear 1;
}
Venkatakrishnan and cubic limiter functions are also provided and may be
specified explicitly e.g.:
gradSchemes
{
default Gauss linear;
limited cellLimited<Venkatakrishnan> Gauss linear 1;
}
or
gradSchemes
{
default Gauss linear;
limited cellLimited<cubic> 1.5 Gauss linear 1;
}
The standard minmod function is recommended for most applications but if
convergence or stability problems arise it may be beneficial to use one of the
alternatives which smooth the gradient limiting. The Venkatakrishnan is not
well formulated and allows the limiter to exceed 1 whereas the cubic limiter is
designed to obey all the value and gradient constraints on the limiter function,
see
Michalak, K., & Ollivier-Gooch, C. (2008).
Limiters for unstructured higher-order accurate solutions
of the Euler equations.
In 46th AIAA Aerospace Sciences Meeting and Exhibit (p. 776).
The cubic limiter function requires the transition point at which the limiter
function reaches 1 is an input parameter which should be set to a value between
1 and 2 although values larger than 2 are physical but likely to significantly
reduce the accuracy of the scheme.
VenkatakrishnanGradientLimiter: Updated documentation
cubicGradientLimiter: Documented private data
The tutorial demonstrates generation of a C-grid mesh using blockMesh
The geometry is provided by a surface mesh (OBJ file) of the NACA0012 aerofoil
The case is setup with a freestream flow speed of Ma=0.72
Thanks to Kai Bastos at Duke University for the geometry and helpful input.
Description
This boundary condition extrapolates field to the patch using the near-cell
values and adjusts the distribution to match the specified, optionally
time-varying, mean value. This extrapolated field is applied as a
fixedValue for outflow faces but zeroGradient is applied to inflow faces.
This boundary condition can be applied to pressure when inletOutlet is
applied to the velocity so that a zeroGradient condition is applied to the
pressure at inflow faces where the velocity is specified to avoid an
unphysical over-specification of the set of boundary conditions.
Usage
\table
Property | Description | Required | Default value
meanValue | mean value Function1 | yes |
phi | Flux field name | no | phi
\endtable
Example of the boundary condition specification:
\verbatim
<patchName>
{
type fixedMeanOutletInlet;
meanValue 1.0;
}
\endverbatim
See also
Foam::fixedMeanFvPatchField
Foam::outletInletFvPatchField
Foam::Function1Types
These BCs blend between typical inflow and outflow conditions based on the
velocity orientation.
airFoil2D tutorial updated to demonstrate these new BCs.
In constant/chemistryProperties in addition to the specification of the initial
ODE integration time-step used at the start of the run:
initialChemicalTimeStep 1e-12;
this time step may now also be specified for every chemistry integration by
setting the optional entry maxChemicalTimeStep, e.g.
maxChemicalTimeStep 1e-12;
The number of characters needed to print a double in scientific format
is 8 plus the number of decimal places; e.g., -6.453452e-231 (6 decimal
places, 14 characters). This has been set in writeFile.C, replacing a
value of 7. Presumably, the case of three digits in the exponent was not
considered when this was first implemented. This change ensures at least
one character of whitespace between tabulated numbers.
This resolves bug report https://bugs.openfoam.org/view.php?id=2801
chtMultiRegionFoam now supports reaction/combustion modelling in fluid
regions in the same way as reactingFoam.
TUT: chtMultiRegionFoam: Added reverseBurner tutorial
This tutorial demonstrates chtMultiRegionFoam's combustion capability
Thermo and reaction thermo macros have been renamed and refactored. If
the name is plural (make???Thermos) then it adds the model to all
selection tables. If not (make???Thermo) then it only adds to the
requested psi or rho table.
This mixture allows a reacting solver to be used with a single component
fluid without the additional case files usually required for reacting
thermodynamics.
reactionThermo: Instantiated more single component mixtures
ENH: reactionThermo: Select singleComponentMixture as pureMixture
A pureMixture can now be specified in a reacting solver. This further
enhances compatibility between non-reacting and reacting solvers.
To achieve this, mixtures now have a typeName function of the same form
as the lower thermodyanmic models. In addition, to avoid name clashes,
the reacting thermo make macros have been split into those that create
entries on multiple selection tables, and those that just add to the
reaction thermo table.
This function object will write a paraview-viewable field showing the
area-density of parcel collisions on every patch face. It also outputs
the rate of collisions hitting each patch face, calculated over an
interval equal to the time elapsed since the last output. It has an
optional entry to specify a minimum incident speed below which a
collision is not counted.
It can be enabled in the cloud properties file as follows:
cloudFunctions
{
patchCollisionDensity1
{
type patchCollisionDensity;
minSpeed 1e-3; // (optional)
}
}
This work was supported by Anton Kidess, at Hilti
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.
and replaced multiphaseInterDyMFoam with a script which reports this change.
The multiphaseInterDyMFoam tutorials have been moved into the multiphaseInterFoam directory.
This change is one of a set of developments to merge dynamic mesh functionality
into the standard solvers to improve consistency, usability, flexibility and
maintainability of these solvers.
Henry G. Weller
CFD Direct Ltd.
and replaced interDyMFoam with a script which reports this change.
The interDyMFoam tutorials have been moved into the interFoam directory.
This change is one of a set of developments to merge dynamic mesh functionality
into the standard solvers to improve consistency, usability, flexibility and
maintainability of these solvers.
Henry G. Weller
CFD Direct Ltd.
interMixingFoam, multiphaseInterFoam: Updated for changes to interFoam
and replaced rhoPimpleDyMFoam with a script which reports this change.
The rhoPimpleDyMFoam tutorials have been moved into the rhoPimpleFoam directory.
This change is the first of a set of developments to merge dynamic mesh
functionality into the standard solvers to improve consistency, usability,
flexibility and maintainability of these solvers.
Henry G. Weller
CFD Direct Ltd.
rhoReactingFoam: Updated for changes to rhoPimpleFoam files
Now pimpleDyMFoam is exactly equivalent to pimpleFoam when running on a
staticFvMesh. Also when the constant/dynamicMeshDict is not present a
staticFvMesh is automatically constructed so that the pimpleDyMFoam solver can
run any pimpleFoam case without change.
pimpleDyMFoam: Store Uf as an autoPtr for better error handling
pimpleFoam: Set initial deltaT from the Courant number
for improved stability on start-up and compatibility with pimpleDyMFoam
ENH: pimpleFoam: Merged dynamic mesh functionality of pimpleDyMFoam into pimpleFoam
and replaced pimpleDyMFoam with a script which reports this change.
The pimpleDyMFoam tutorials have been moved into the pimpleFoam directory.
This change is the first of a set of developments to merge dynamic mesh
functionality into the standard solvers to improve consistency, usability,
flexibility and maintainability of these solvers.
Henry G. Weller
CFD Direct Ltd.
tutorials/incompressible/pimpleFoam: Updated pimpleDyMFoam tutorials to run pimpleFoam
Renamed tutorials/incompressible/pimpleFoam/RAS/wingMotion/wingMotion2D_pimpleDyMFoam
-> tutorials/incompressible/pimpleFoam/RAS/wingMotion/wingMotion2D_pimpleFoam
XiEngineFoam is a premixed/partially-premixed combustion engine solver which
exclusively uses the Xi flamelet combustion model.
engineFoam is a general engine solver for inhomogeneous combustion with or
without spray supporting run-time selection of the chemistry-based combustion
model.
Standard crank-connecting rod and the new free-piston kinematics motion options
are provides, others can easily be added.
Contributed by Francesco Contino and Nicolas Bourgeois, BURN Research Group.
The patch magSf calculation has been changed so that it uses the same
triangulation as the overlap algorithm. This improves consistency and
means that for exactly conforming patches (typically before any mesh
motion) the weights do not require normalisation.
Resolves bug-report https://bugs.openfoam.org/view.php?id=2785
ENH: compressibleInterFoam family: merged two-phase momentum stress modelling from compressibleInterPhaseTransportFoam
The new momentum stress model selector class
compressibleInterPhaseTransportModel is now used to select between the options:
Description
Transport model selection class for the compressibleInterFoam family of
solvers.
By default the standard mixture transport modelling approach is used in
which a single momentum stress model (laminar, non-Newtonian, LES or RAS) is
constructed for the mixture. However if the \c simulationType in
constant/turbulenceProperties is set to \c twoPhaseTransport the alternative
Euler-Euler two-phase transport modelling approach is used in which separate
stress models (laminar, non-Newtonian, LES or RAS) are instantiated for each
of the two phases allowing for different modeling for the phases.
Mixture and two-phase momentum stress modelling is now supported in
compressibleInterFoam, compressibleInterDyMFoam and compressibleInterFilmFoam.
The prototype compressibleInterPhaseTransportFoam solver is no longer needed and
has been removed.
Another exception has been added to globalIndexAndTransform to prevent
transformations being generated from coupled patch pairs marked with
coincident-full-match transformations. Foamy generates such patches, and
the faces on them at intermediate stages of meshing can be degenerate,
making the calculation of transformations unreliable. This change
enforces the definition that coincident-full-match patch pairs are not
transformed.
To unsure fvOptions are instantiated for post-processing createFvOptions.H must
be included in createFields.H rather than in the solver directly.
Resolves bug-report https://bugs.openfoam.org/view.php?id=2733
BUG: porousSimpleFoam: moved createFvOptions.H into createFields.H for -postProcess option
Resolves bug-report https://bugs.openfoam.org/view.php?id=2733
BUG: solvers: Moved fvOption construction into createFields.H for post-processing
This ensures that the fvOptions are constructed for the -postProcessing option
so that functionObjects which process fvOption data operate correctly in this
mode.
The absolute value of the the time has been added to the rigid body
model state. This value is not directly necessary for calculating the
evolution of the rigid body system, it just facilitates the
implementation of sub-models which are in some way time-dependent.
Mixture molecular weight is now evaluated in heThermo like everything
else, relying on the low level specie mixing rules. Units have also been
corrected.
SpecieMixture: Pure virtual definition for W to prevent Clang warning
to support the evaporation of the solvent from the wax film and the changes in
viscosity caused by the reduction in solvent content.
BUG: filmViscosityModel::thixotropicViscosity: Corrected sign of impingement rate
to compensate for rhoSp having the wrong sign
BUG: surfaceFilmModels::waxSolventEvaporation: Corrected handling of impingement
ENH: surfaceFilmModels::waxSolventViscosity: Changed mixing to mole-fraction based
ENH: surfaceFilmModels::thermoSingleLayer: Added call to solveContinuity before updateSubmodels
to allow sub-models to solve transport equations for conserved properties
In the event that matching centroids across a coupled patch pair fails,
we fall back to matching the face point average. The latter can be
obtained more reliably on degenerate faces as the calculation does not
involve division by the face area.
This fallback was already implemented as part of processorPolyPatch.
This change also applies it to the faceCoupleInfo class used by
reconstructParMesh.
In this version of compressibleInterFoam separate stress models (laminar,
non-Newtonian, LES or RAS) are instantiated for each of the two phases allowing
for completely different modeling for the phases.
e.g. in the climbingRod tutorial case provided a Newtonian laminar model is
instantiated for the air and a Maxwell non-Newtonian model is instantiated for
the viscoelastic liquid. To stabilize the Maxwell model in regions where the
liquid phase-fraction is 0 the new symmTensorPhaseLimitStabilization fvOption is
applied.
Other phase stress modeling combinations are also possible, e.g. the air may be
turbulent but the liquid laminar and an RAS or LES model applied to the air
only. However, to stabilize this combination a suitable fvOption would need to
be applied to the turbulence properties where the air phase-fraction is 0.
Henry G. Weller, Chris Greenshields
CFD Direct Ltd.
The restraints generate either joint-local (tau) or global (fx) forces.
At the moment they all generate the latter. This change corrects three
of the four restraints so that the forces are in the gobal coordinate
system and not the local coordinate system of the body.
The problem with this is that the forward dynamics code then transforms
most of the forces back to the body local coordinate system. A better
solution would be to associate restraints which are more sensibly
defined in a local frame with the joints instead of the bodies, and
return the forces as part of the tau variable.
Two boundary conditions for the modelling of semi-permeable baffles have
been added. These baffles are permeable to a number of species within
the flow, and are impermeable to others. The flux of a given species is
calculated as a constant multipled by the drop in mass fraction across
the baffle.
The species mass-fraction condition requires the transfer constant and
the name of the patch on the other side of the baffle:
boundaryField
{
// ...
membraneA
{
type semiPermeableBaffleMassFraction;
samplePatch membranePipe;
c 0.1;
value uniform 0;
}
membraneB
{
type semiPermeableBaffleMassFraction;
samplePatch membraneSleeve;
c 0.1;
value uniform 1;
}
}
If the value of c is omitted, or set to zero, then the patch is
considered impermeable to the species in question. The samplePatch entry
can also be omitted in this case.
The velocity condition does not require any special input:
boundaryField
{
// ...
membraneA
{
type semiPermeableBaffleVelocity;
value uniform (0 0 0);
}
membraneB
{
type semiPermeableBaffleVelocity;
value uniform (0 0 0);
}
}
These two boundary conditions must be used in conjunction, and the
mass-fraction condition must be applied to all species in the
simulation. The calculation will fail with an error message if either is
used in isolation.
A tutorial, combustion/reactingFoam/RAS/membrane, has been added which
demonstrates this transfer process.
This work was done with support from Stefan Lipp, at BASF.
To disable face correspondence checking set
checkFaceCorrespondence off;
in blockMeshDict. This is necessary in the rare cases where adjacent block
faces do not need to correspond because they are geometrically collapsed,
e.g. to form a pole/axis.
Resolves bug-report https://bugs.openfoam.org/view.php?id=2711
ENH: foamyHexMesh: Made default region volume type that of it's parent
Foamy surface conformation entries have a "meshableSide" entry which
controls which side of the surface is to be meshed. Typically this is
set "inside" for boundaries and "both" for baffles. A sub-region's
default entry is now taken from it's parent, rather than a specific
value (it was "inside"). This is consistent with how other entries are
handled.
surfaceConformation
{
locationInMesh (0 0 0);
geometryToConformTo
{
baffle
{
featureMethod extractFeatures;
includedAngle 120;
meshableSide both; // <-- per-surface setting
regions
{
disk
{
meshableSide both; // <-- per-region setting*
// *in this example, this entry is not needed, as it
// is taken from the per-surface setting above
}
}
}
// ...
}
}
ENH: foamyHexMesh: Added (reinstated) baffle patches
A patch can now be assigned to a baffle surface. This assignment will
take precedence over any face-zones.
surfaceConformation
{
locationInMesh (0 0 0);
geometryToConformTo
{
disk
{
featureMethod extractFeatures;
includedAngle 120;
meshableSide both; // <-- baffle
patchInfo
{
type wall;
inGroups (walls);
}
}
// ...
}
}
STYLE: foamyHexMesh: Switched off output of all the secondary meshes
The integration of force and heat transfer onto the particle is
facilitated by a run-time-selectable integration scheme. These schemes
were written to generate the value at the end of an intregration step
and also an average value over the step from which the total transfer
was computed.
The average value in the Euler scheme was implemented incorrectly, which
resulted in the momentum and heat transfer processes being
non-conservative. Implementing the average correctly, however, would
have inteoduced a number of trancendental functions which would have
negated the purpose of the Euler scheme as the cheap and stable option.
The schemes have been rewritten to generate changes over the step,
rather than the final value. This change is then used to calculate the
transfers. Regardless of the scheme, this formulation is guaranteed to
be conservative, and the Euler scheme remains computationally
inexpensive.
This change was made with help from Timo Niemi, VTT
This resolves bug report https://bugs.openfoam.org/view.php?id=2666
ENH: integrationSchemes: Further simplification and optimisation
Removed templating from integration schemes, improved the name
convention, and optimised the utilisation so that the virtual call is
only made once per integration in the KinematicParcel and the
ThermoParcel.
BUG: integrationSchemes: Corrections to coupled/non-coupled force splitting
The integration splitting implemented in commit a5806207 has been shown
to be incorrect in some cases. A new procedure has been implemented
which can correctly split the implicit-explicit integral into a number
of pieces, in order to calculate the contribution of each. This is
intended for integrating coupled and non-coupled particle momentum and
heat transfers.
However, currently there is only ever one implicit coefficient used in
these transfers (there is no implicit non-coupled contribution). The
evaluation has therefore been short-cutted to only do the integration
with respect to the coupled contributions. The splitting functionality
has been retained in case additional separate implicit coefficients are
required in the future.
This change was made with help from Timo Niemi, VTT
This resolves bug report https://bugs.openfoam.org/view.php?id=2666
XiEngineFoam is a premixed/partially-premixed combustion engine solver which
exclusively uses the Xi flamelet combustion model.
engineFoam is a general engine solver for inhomogeneous combustion with or
without spray supporting run-time selection of the chemistry-based combustion
model.
Standard crank-connecting rod and the new free-piston kinematics motion options
are provides, others can easily be added.
Contributed by Francesco Contino and Nicolas Bourgeois, BURN Research Group.
OpenFOAM is a free, open source CFD software [released and developed primarily by OpenCFD Ltd](http://www.openfoam.com) since 2004. It has a large user base across most areas of engineering and science, from both commercial and academic organisations. OpenFOAM has an extensive range of features to solve anything from complex fluid flows involving chemical reactions, turbulence and heat transfer, to acoustics, solid mechanics and electromagnetics. [More...](http://www.openfoam.com/documentation)
OpenFOAM is a free, open source CFD software [released and developed by OpenCFD Ltd since 2004](http://www.openfoam.com/history/).
It has a large user base across most areas of engineering and science, from both commercial and academic organisations.
OpenFOAM has an extensive range of features to solve anything from complex fluid flows involving chemical reactions, turbulence and heat transfer, to acoustics, solid mechanics and electromagnetics.
OpenFOAM is professionally released every six months to include customer sponsored developments and contributions from the community - individual and group contributors, fork re-integrations including from FOAM-extend and OpenFOAM Foundation Ltd - in this Official Release sanctioned by the OpenFOAM Worldwide Trademark Owner aiming towards one OpenFOAM.
OpenFOAM is professionally released every six months to include
customer sponsored developments and contributions from the community -
individual and group contributors, integrations
(eg, from FOAM-extend and OpenFOAM Foundation Ltd) as well as
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. See the file COPYING in this directory or [http://www.gnu.org/licenses/](http://www.gnu.org/licenses), for a description of the GNU General Public License terms under which you can copy the files.
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. See the file COPYING in this directory or
[http://www.gnu.org/licenses/](http://www.gnu.org/licenses), for a
description of the GNU General Public License terms under which you
may redistribute files.
# OpenFOAM Trademark
OpenCFD Ltd grants use of its OpenFOAM trademark by Third Parties on a licence basis. ESI Group and OpenFOAM Foundation Ltd are currently permitted to use the Name and agreed Domain Name. For information on trademark use, please refer to the [trademark policy guidelines](http://www.openfoam.com/legal/trademark-policy.php).
Please [contact OpenCFD](http://www.openfoam.com/contact) if you have any questions on the use of the OpenFOAM trademark.
OpenCFD Ltd grants use of its OpenFOAM trademark by Third Parties on a
licence basis. ESI Group and OpenFOAM Foundation Ltd are currently
permitted to use the Name and agreed Domain Name. For information on
trademark use, please refer to the [trademark policy guidelines](http://www.openfoam.com/legal/trademark-policy.php).
Violations of the Trademark are continuously monitored, and will be duly prosecuted.
Please [contact OpenCFD](http://www.openfoam.com/contact) if you have
any questions on the use of the OpenFOAM trademark.
Violations of the Trademark are monitored, and will be duly prosecuted.
# Using OpenFOAM
If OpenFOAM has already been compiled on your system, simply source
the appropriate `etc/bashrc` or `etc/cshrc` file and get started.
Some files were not shown because too many files have changed in this diff
Show More
Reference in New Issue
Block a user
Blocking a user prevents them from interacting with repositories, such as opening or commenting on pull requests or issues. Learn more about blocking a user.
