- with the xml append format it is possible to write raw binary
(instead of base64), but the writer becomes more complicated.
Either needs two passes to create, or need to allocate a block
of space for the header information (like VTK itself does) and
write later.
* internalWriter
* patchWriter
* surfaceMeshWriter
* lagrangianWriter
Also these special purpose ones:
* foamVtkWriteSurfFields
- this shifts responsibility away from caller to the individual writers
for knowing which file formats are supported and which file ending is
appropriate. When the writer receives the output format request,
it can elect to downgrade or otherwise adjust it to what it can
actually manage (eg, legacy vs xml vs xml-append).
But currently still just with legacy format backends.
- The reader module allows two levels of caching.
The OpenFOAM fvMesh can be cached in memory, for faster loading of
fields. Additionally, the translated VTK geometries are held in a
local cache. The cached VTK geometries should incur no additional
overhead since they use the VTK reference counting for their storage
management.
- this allows filling in the VTK structures without intermediate data
and without sequencial insertion. Should be faster and smaller
than the previous cell-wise insertion methods.
Most importantly, it improves code reuse.
- has the selected values directly and use these lookup names to store
directly into a hash. This replaces several parallel lists of
decomp information etc and makes it easier.
Adds overset discretisation to selected physics:
- diffusion : overLaplacianDyMFoam
- incompressible steady : overSimpleFoam
- incompressible transient : overPimpleDyMFoam
- compressible transient: overRhoPimpleDyMFoam
- two-phase VOF: overInterDyMFoam
The overset method chosen is a parallel, fully implicit implementation
whereby the interpolation (from donor to acceptor) is inserted as an
adapted discretisation on the donor cells, such that the resulting matrix
can be solved using the standard linear solvers.
Above solvers come with a set of tutorials, showing how to create and set-up
simple simulations from scratch.
- Use on/off vs longer compressed/uncompressed.
For consistency, replaced yes/no with on/off.
- Avoid the combination of binary/compressed,
which is disallowed and provokes a warning anyhow
- ensure that the string-related classes have consistently similar
matching methods. Use operator()(const std::string) as an entry
point for the match() method, which makes it easier to use for
filters and predicates. In some cases this will also permit using
a HashSet as a match predicate.
regExp
====
- the set method now returns a bool to signal that the requested
pattern was compiled.
wordRe
====
- have separate constructors with the compilation option (was previously
a default parameter). This leaves the single parameter constructor
explicit, but the two parameter version is now non-explicit, which
makes it easier to use when building lists.
- renamed compile-option from REGEX (to REGEXP) for consistency with
with the <regex.h>, <regex> header names etc.
wordRes
====
- renamed from wordReListMatcher -> wordRes. For reduced typing and
since it behaves as an entity only slightly related to its underlying
list nature.
- Provide old name as typedef and include for code transition.
- pass through some list methods into wordRes
hashedWordList
====
- hashedWordList[const word& name] now returns a -1 if the name is is
not found in the list of indices. That has been a pending change
ever since hashedWordList was generalized out of speciesTable
(Oct-2010).
- add operator()(const word& name) for easy use as a predicate
STYLE: adjust parameter names in stringListOps
- reflect if the parameter is being used as a primary matcher, or the
matcher will be derived from the parameter.
For example,
(const char* re), which first creates a regExp
versus (const regExp& matcher) which is used directly.
- less clutter and typing to use the default template parameter when
the key is 'word' anyhow.
- use EdgeMap instead of the longhand HashTable version where
appropriate
- the heuristic for matching unresolved intersections is a relatively
simple matching scheme that seems to be more robust than attempting to walk
the geometry or the cuts.
- avoid false positives for self intersection
