- compiles
- deepClone (not needed at the moment)
- objectRegistry::subRegistry with fileName
- Time::null object so IOobject can be constructed
without objectRegistry
- added -dry-run, -write-vtk options.
Additional mesh information after creation.
- add parallel reductions and more information for checkFaMesh
ENH: minor cleanup of faPatch internals
- align pointLabels and pointEdges creation more closely with coding
patterns used in PrimitivePatch
- use fileHandler when loading "S0" field.
- previous handling did not correctly account for off-processor
connections (SEGFAULT).
- revised the point/area normal calculations to use the dual of the
faces. This simplifies the logic and reduces the depth of loops.
Point corrections from the neighbouring patches is handled
centrally by the new halo face information, which properly handles
on-processor or off-processor faces irrespective of any explicit
processor patches.
STYLE: local function and add comments for finiteArea area weighting
- following the original Tukovic code, the area-weighted normal
for a vector pair (defining a triangle) is weighted by
(1) area : larger weight for larger areas
(2) sin : lower weight for narrow angles (eg, shards)
(3) invDist squared : lower weights for distant points
Refactored to eliminate intermediate operations, some additional
divide-by-zero protection - similar to vector normalise()
- the finiteArea is typically restricteed to one or more patches on a
polyMesh but will have an external connectivity to other parts of
the polyMesh. For proper determination of the point normals (for
example), the neighbouring information is needed.
These outside 'halo' faces can be located on different processors,
but not correspond to an internal processor-processor interface.
Add a dedicated form of mapDistribute for swapping this type of
information. Since this is a collective operation, locate
corresponding methods directly on the faMesh level instead of
the faPatch level.
- the case of 'fan-like' processor was previously assumed to be
rare (see merge-request !490 and issue #2084).
However, Vaggelis Papoutsis noticed that even fairly normal geometries
can trigger problems.
- replaced the old patch/patch matching style with a more general
edge-based synchronisation and matching that appears to handle
the corner cases inherently. The internal communication overhead
is essentially unchanged, and the logic is simpler.
ENH: additional framework for managing patch connectivity
- the patch remapping in faFieldDecomposer calls weights
internalField() which can trigger parallel communication on the
complete mesh for some processors only (ie, blocks).
Force a priori creation of weights instead.
- ensure that the complete mesh (reconstruction helper)
is serial when adding patches.
- when creating a finite-area mesh in parallel, need to determine
the equivalent ProcAddressing for the faMesh.
In the faceProcAddressing the collected and sorted order was being
scattered directly back to the individual processors instead of only
the sections relevant to each particular processor.
This caused the observed jumbled order for reconstructed fields.
- this makes the lookup and use of tables slightly cleaner and
provides a hook for update (compat) messages
The singleton-style method returns the function pointer directly,
or nullptr on not-found.
NEW access method (mnemonic: 'ctor' prefix for constructors)
```
auto* ctorPtr = dictionaryConstructorTable(modelType);
if (!ctorPtr)
{
...
}
return autoPtr<myModel>(ctorPtr(dict, ...));
```
OLD method, which also still works, but without any compat handling:
```
auto ctorIter = dictionaryConstructorTablePtr_->cfind(modelType);
if (!ctorIter.found())
{
...
}
return autoPtr<myModel>(ctorIter()(dict, ...));
```
- a Pstream::master with a Pstream::parRun guard in case Pstream has
not yet been initialised, as will be the case for low-level messages
during startup.
- propagate relativeName handling into IOstreams
- better distinction between content and storage type
by appending 'Type' to the typedef.
old: 'Class::abcConstructorTable* tablePtr'
new: 'Class::abcConstructorTableType* tablePtr'
Was rarely used in any exposed code.
BREAKING: LESdelta::New with additional table
- parameter change to dictionaryConstructorTableType
(was dictionaryConstructorTable)
Example using mean turbulence fields (mean fields should be available e.g. from
a fieldAverage function object)
proudmanAcousticPower1
{
// Mandatory entries (unmodifiable)
type proudmanAcousticPower;
libs (fieldFunctionObjects);
...
// Turbulence field names (if not retrieved from the turb model)
k kMean;
epsilon epsilonMean;
omega none; // omegaMean
}
- was taking from the current head instead from specified commit-ish
ENH: add -debian=NUM convenience option to foamPackRelease
STYLE: relocate compile begin/end messages
COMP: suppress more clang warnings (needed for boost)
- provide a plain stream() method on messageStream to reduce reliance
on casting operators and slightly opaque operator()() calls etc
- support alternative stream for messageStream serial output.
This can be used to support local redirection of output.
For example,
refPtr<OFstream> logging; // or autoPtr, unique_ptr etc
// Later...
Info.stream(logging.get())
<< "Detailed output ..." << endl;
This will use the stdout semantics in the normal case, or allow
redirection to an output file if a target output stream is defined,
but still effectively use /dev/null on non-master processes.
This is mostly the same as this ternary
(logging ? *logging : Info())
except that the ternary could be incorrect on sub-processes,
requires more typing etc.
ENH: use case-relative names of dictionary, IOstream for FatalIOError
- normally yields more easily understandable information
- argList::envExecutable() static method.
This is identical to getEnv("FOAM_EXECUTABLE"), where the name of
the executable has typically been set from the argList construction.
Provides a singleton access to this value from locations that
do not have knowledge of the originating command args (argList).
This is a similar rationale as for the argList::envGlobalPath() static.
- additional argList::envRelativePath() static method.
- make -dry-run handling more central and easier to use by adding into
argList itself.
STYLE: drop handling of -srcDoc (v1706 option)
- replaced with -doc-source for 1712 and never used much anyhow
- for compilers such as gcc and clang, may have several different
variants installed on the computer. Use WM_COMPILER_CONTROL to
specify the preferred variant.
Eg,
WM_COMPILER=Gcc
WM_COMPILER_CONTROL="version=8"
will compile with "gcc-8" and "g++-8"
Good practice would be to tag output directory names with the
version too. Eg
WM_COMPILER=Clang110
WM_COMPILER_CONTROL="version=11.0"
STYLE: modify message for change of gcc -> clang (darwin)
- using the proximityRegions filter when there is no enclosing surface
to segregate domains causes a surface of zero-faces to be created.
In most cases, this means that a simpler proximityFaces filter would
have been more appropriate. To increase overall robustness, revert
to the simpler proximityFaces filter logic when the proximityRegions
would otherwise result in zero faces (globally seen).
- reuse single component buffer within an Ensight output method.
Use direct UPstream read/write to avoid Pstream char buffers
- replace blocking transfer with scheduled for Ensight cloud output
- UPstream::mpiGather (MPI_Gather) - used by Pstream::listGatherValues
- UPstream::mpiScatter (MPI_Scatter) - used by Pstream::listScatterValues
These are much simpler forms for gather/scatter of fixed-sized
contiguous types data types (eg, primitives, simple pairs etc).
In the gather form, creates a list of gathered values on the master
process. The subranks have a list size of zero.
Similarly, scatter will distribute a list of values to single values
on each process.
Instead of
labelList sendSizes(Pstream::nProcs());
sendSizes[Pstream::myProcNo()] = sendData.size();
Pstream::gatherList(sendSizes);
Can write
const labelList sendSizes
(
UPstream::listGatherValues<label>(sendData.size())
);
// Less code, lower overhead and list can be const.
For scattering an individual value only,
instead of
labelList someValues;
if (Pstream::master()) someValues = ...;
Pstream::gatherList(sendSizes);
const label localValue
(
someValues[Pstream::myProcNo()]
);
Can write
labelList someValues;
if (Pstream::master()) someValues = ...;
Pstream::gatherList(sendSizes);
const label localValue
(
UPstream::listScatterValues<label>(someValues)
);
Can of course also mix listGatherValues to assemble a list on master
and use Pstream::scatterList to distribute.
ENH: adjusted globalIndex gather methods
- added mpiGather() method [contiguous data only] using MPI_Gatherv
- respect localSize if gathering master data to ensure that a
request for 0 master elements is properly handled.
- Pstreams can be ascii/binary but are always currentVersion
- rename UIPstream externalBuf_ to 'recvBuf_' for similar naming as
PstreamBuffers and symmetry with UOPstream::sendBuf_
- specific enum size for commsType (for more compact structures in the
future). Default construct lists items.
BUG: possible incidental indexing in UIPstream::read(char*, std::streamsize)
- raw reading had been split into beginRawRead(), readRaw().
However, this could change the current input position (due to word
boundary alignment), even if the expected count is zero. Make a
no-op for count == 0. This mirrors UOPstream::write behaviour.
- construct or reset from a list of local sizes. It is generally
easier and safer to assemble sizes and let globalIndex determine the
corresponding offsets, when working with raw values.
- Can use reset() from sizes or fine-tune offsets with setLocalSize()
instead of using the potentially more fragile non-const access to
the offsets.
- add globalIndex const_iterator to iterate across the access ranges.
This is makes it simpler to use with the List slice() method to
access or operate on a sub-section of list.
For example,
scalarField allValues = ...;
globalIndex procAccess = ...;
for (const labelRange& range : procAccess)
{
someOutput(allValues.slice(range));
}
- the size of a List often requires adjustment prior to an operation,
but old values (if any) are not of interest and will be overwritten.
In these cases can use the _nocopy versions to avoid additional memory
overhead of the intermediate list and the copy/move overhead of
retaining the old values (that we will subsequently discard anyhow).
No equivalent for PtrList/UPtrList - this would be too fragile.
- add swap DynamicField with DynamicList
BUG: fixed Dynamic{Field,List} setCapacity corner case
- for the case when the newly requested capacity coincides with the
current addressable size, the resize of the underlying list would have
been bypassed - ie, the real capacity was not actually changed.
- remove (unused) PtrDynList setCapacity method as too fragile
- previously returned the range slice as a UList,
but this prevents convenient assignment.
Apply similar handling for Field/SubField
Allows the following
labelRange range(...);
fullList.slice(range) = identity(range.size());
and
fullList.slice(range) = UIndirectList<T>(other, addr);
ENH: create SubList from full FixedList (simplifies interface)
- allow default constructed SubList. Use shallowCopy to 'reset' later
- simply adds in the reinterpret_cast, which simplifies coding for
binary data movement.
Name complements the size_bytes() method for contiguous data
STYLE: container IO.C files into main headers for better visibility
STYLE: include CompactListList.H in polyTopoChange
- avoids future mismatches if the CompactListList template signature
changes
GIT: relocate CompactListList into CompactLists/ directory
- previously used an indirect patch to get the sampling locations,
but this doesn't take account of the face flips. Now use
the faceZone intrinsic for generating a properly flipped patch
and provide the sampling locations separately.
STYLE: adjust compatiblity header for surfaceMeshWriter
- it is now possible to include the selected mpi version in the
top-level bashrc or prefs.sh file. For example,
WM_MPLIB=OPENMPI-4.1.1 or WM_MPLIB=openmpi-4.1.1
after evaluation of the config.sh/mpi, this will define
WM_MPLIB=OPENMPI-4.1.1 and FOAM_MPI=openmpi-4.1.1
During the wmake, the mpi-rules will first load the MPI 'family'
rules (OPENMPI in this example) before trying to load
version-specific rules if they exist.
NOTE: the regular user-defined prefs system is unaffected by this
change. This means it is still possible to use a file such as
'prefs.openmpi' to define the preferred version instead or as well.
However, it does mean inconsistent naming can be specified.
For example, specify WM_MPLIB=OPENMPI-4.1.1 at the top-level but
actually have FOAM_MPI=openmpi-4.0.6 in the prefs.openmpi file.
This will make the value of WM_MPLIB misleading.
CONFIG: foamConfigurePaths support for sys-openmpi major version
CONFIG: cleanup any shadow env variables
- migrate to c++14 for most compilers *except* gcc.
There are still many systems in use with gcc-4.8.5, which does not
support c++14.
- initial rules for nvidia compilers (pgi is will soon be defunct).
Not fully tested...
CONFIG: provide fallback value for the user directory name
- in containers may have an unset USER env variable.
Default to 'user' to prevent ugly looking directory names.
- supports redistributePar -decompose -fileHandler collated
- supports redistributePar -reconstruct
- does not support redistributePar with collated in redistribution mode
- noticed by Robin Knowles with `decomposePar -fields -copyZero`
The internals for the Foam:cp method combine the behaviour of
a regular `cp` and `cp -R` combined.
When source and target are both directories, the old implementation
created a subdirectory for the contents.
This normally fine,
ok: cp "path1/0/" to "path2/1" -> "path2/1/2"
BUT: cp "path1/0/" to "path2/0" -> "path2/0/0" !!
Now add check for the basenames first.
If they are identical, we probably meant to copy directory contents
only, without the additional subdir layer.
BUG: decomposePar -fields -copyZero copies the wrong directory
- was using the current time name (usually latest) instead of copying
the 0 directory
ENH: accept 0.orig directories as a fallback to copy if the 0 directory
is missing
- use orte-info to determine prefix/libdir for openmpi.
This removes a run-time dependency on mpicc, which is actually
only needed for building with MPI (not running with MPI).
The corresponding openmpi devel package (deb/rpm) will not
necessarily be installed on a particular system.
- retain mpicc logic if the new logic using orte-info does not
deliver an answer. Final fallback to using 'orterun' to
infer prefix/libdir.
- Additional logic for intel and msmpi to make it easier to
locate these vendor packages within ThirdParty
(ie, under ThirdParty/opt/...)
CONFIG: improve robustness
- add check for absolute path when adding PATH/LD_LIBRARY_PATH etc.
- prefix more variables with '_foam*' to prevent accidental overwrite
of userspace shell variables when sourcing
- avoid deprecated autoPtr check
- bundle bool values in fvPatchField for compacter allocation
- change useImplicit to a set method taking an argument instead of
allowing direct access.
- top-level faceCells() on the boundary list simplifies the creation
of lduAddressing etc, can also be useful on its own
STYLE: replace isA/refCast combination with a single isA
- helps avoid the creation of small face cuts (near corners, edges)
that result in zero-size faces on output.
CONFIG: make default iso-surface topo regularisation less aggressive
- The full (diagcell) regularisation no longer includes cleaning of
non-manifold surfaces by removing open edges.
This can be selected by the 'clean' regularisation option instead.
ie, 'clean' = 'full' + erode open edges
ENH: additional debug modes for iso-surface topo
- with (debug & 8) dumps out a VTK file of the tets to be cut and the
calculated open edges.
- PstreamBuffers for parallel VTK output.
- avoids MPI overflows for larger meshes
- new vtk::lineWriter for writing edges
- vtk::fileWriter::writeUniform now also supports processor-specific
uniform values instead of assuming that they are identical everywhere.
- support simple mesh subsetting to vtu formats to enable debug output
for a subsection of an existing polyMesh
- rudimentary support for VTK from cellShapes is intended for handling
basic primitive cell shapes without a full blown polyMesh description.
For example,
// Create an empty polyMesh with points only
polyMesh debugMesh
(
io,
std::move(points),
faceList(), // faces
labelList(), // owner
labelList(), // neighbour
true // syncPar
);
// Establish the appropriate VTK sizing for the TET shapes
vtk::vtuCells vtuCells;
vtuCells.resetShapes(debugCutTets);
vtuCells.nPoints(debugMesh.nPoints());
NOTE
Since the vtk::internalMeshWriter only uses the polyMesh reference
for the points, it is also possible to create the vtuCells
description without a pointField (or from a different mesh
description) and write out the connectivity using the pointField
from a different mesh.
This intercepts all vector/tensor AMI interpolations and
does the interpolation in cylindrical coordinates.
Use (component) 'coupled' linear solver to enable this in
the linear solver sweeps.
- use dictionary methods directly in LduMatrix::solver::readControls.
Deprecate the redundant LduMatrix::solver::readControl helper-function
- define solver log-level outside of the loop,
narrow log flag to int.
- reinstate API-compatible parameters for SolverPerformance
- allows reuse of an int64_t scotch library with label-size 32
and/or label-size 64.
COMP: prefer scotch/metis/kahip libraries with label-size qualifiers
- as noted in #2200, mpirun may insert mpi libraries higher in the
library loader which can cause masking of our ThirdParty libraries
of the same name. With scotch (for example), the operating system
may have an int32 version installed but we have an int64 version
compiled under ThirdParty. Runing in serial is fine, but in parallel
we resolve to the (incorrect) system version due to the adjustments
in mpirun.
- adjust the ThirdParty make scripts to also create corresponding
links (eg, 'ln -s libscotch.so libscotch-int64.so') and prefer
linkage with these qualified libraries.
Eg, -L$(SCOTCH_LIB_DIR) -lscotch$(SCOTCH_LIBNAME_SUFFIX)
this prevent accidental runtime linkage with the system versions.
STYLE: simplify scotch interface code by using local functions
- allows reuse similar to refPtr for wrapping different content.
- additional control for when contents are copied back,
instead of waiting for the adaptor to go out of scope.
Eg,
if (adaptor.active())
{
adaptor.commit();
adaptor.clear();
}
- static ConstPrecisionAdaptor::get method renamed to 'select' as a
better description of its purpose and avoid confusion with
non-static 'get' method.
Was previously only used within GAMGPreconditioner, but even there
it is better just to use the ConstPrecisionAdaptor directly.
For cases where the number of injectors exceeded the number of parcels to
inject, processing the injectors sequentially led to not all injector locations
being active and yielding non-physical spatial distributions.
Previous naming conventions for input variables in the
normal, multiNormal, RosinRammler, and massRosinRammler
distributions were heuristic and did not reflect
the de facto conventions being used in statistics.
BUG: distributionModel: disallow any distribution
where input min is equal to input max
ENH: distributionModel: ensure execution of check() at ctor level
Previously, for basic incompressible and compressible simulations,
the "force" function object has not been using the user-specified "UName"
for the "devRhoReff" computation (affecting the tangential component),
but using the "U" of the latest available step. In contrast,
the user-specified "pName" has always been being used correctly.
This has been causing issues for users when they wish to use a specific
"UMean" field in various force and forceCoeff function object computations.
Introduces a new optional keyword of label type 'log'
to linear-solver dictionaries to enable variable-specific
debug statements. For example, in fvOptions file:
solvers
{
p
{
solver GAMG;
...
log 2;
}
U
{
...
log 0;
}
}
The meanings of values of 'log' are:
log 0; <!-- no output
log 1; <!-- standard output
log 2; <!-- debug output
// values higher than 2 are expected to have no effect
This keyword does not directly affect the operations of various
DebugSwitches and backward compatibility has been ensured in exchange
of code cleanness. The related DebugSwitches are:
DebugSwitches
{
SolverPerformance 0;
GAMG 0;
PCG 0;
PBiCG 0;
smoothSolver 0;
}
- previously reported the WM_PROJECT_VERSION in the top banner
but this makes it overly sensitive to arbitrary user naming.
Change to the current API in the comment banner, include the
WM_PROJECT_VERSION as part of the reported "Build: ..."
string instead.
- previously had a patch-size check, which caused a zero-sized patch
to be "sticky" as uniform Zero regardless of what the original input
stated (eg, "constant 0.5")
This was caused by short-circuiting logic that circumvented reading
on zero-size patches.
- support non-uniform scaling, prescaling and cartesian coordinate
transformations.
Eg, stretch in one direction and then rotate
```
prescale (1.5 1 1);
transform
{
origin (0 0 0);
rotation
{
type axisAngle;
axis (0 0 1);
angle 45;
}
}
```
- support "transformed" versions of blockMesh vertices, topology.
With the additional of transformations etc, a simplistic application
of a single scale parameter is no longer sufficient.
new: blMesh.vertices(true);
old: blMesh.vertices() * blMesh.scaleFactor();
new: blMesh.topology(true);
old: N/A
- add individual edge access for blockDescriptor.
Saves copying and duplicate calculations.
- handle '(block face)' specification for curved faces,
which is ok for external block faces, but likely somewhat
questionable if used for internal block faces.
- Can specify
```
transform
{
origin (1 2 3);
rotation none;
}
```
instead of the longer form
```
transform
{
origin (1 2 3);
e1 (1 0 0);
e3 (0 0 1);
}
```
COMPAT: remove old (pre-1812) Euler and STARCD keywords
- use "angles", remove old compat name "rotation"
as clutter and possible confusion with "coordinate rotation"
STYLE: remove coordinate rotation move constructors
- an unnecessary holdover from older code.
- for v2106 restricted the input conversion of string types to disallow
treating verbatim strings as possible word input.
However, it was too strict in just allowing quoted strings
and should have also permitted '$'-sigil variables as well.
- ensure that errors for bad string -> word input conversion
are raised from within the '>>' read operator. These were
previously triggered during the stripping process, which
made error tracing more difficult.
The original thermoSurfaceFilm sub-models were divided between kinematicSurfaceFilm and thermoSurfaceFilm in order to use the surfaceFilm model in a kinematicCloud.
The film interaction models are now in a kinematicSurface class which can be used in a kinematic cloud adding constant thermal properties (p and T) for some sub-models, e.g. drySplashInteraction/wetSplashInteraction.
pRef and Tref were added to the kinematicSurfaceFilm as entry to the regionFilm when used with a kinematic cloud.
In the finite area surface film model Tref, pRef are stored in filmSubModelBase.
TUT: kinematicParcelFoam: new tutorial pitzDailySprinkles
ENH: Several additions to thinFilm models
1) Changing the faSolution entry nonOrthoCorr to nFilmCorr entry.
This entry specify the number of iterations on the film thickness
Eq which does not correct for laplacian non-orthogonality.
2) Changing laminar turbulent model for the skin friction exerted by
the flow to the film.
3) Adding optional relaxation factors for source terms coming from
the added mass of the lagragian particles into the film such as
rhoSp, pnSp and Usp. Similarly the film pressure (pf) can be
relaxed in the inner loops.
4) Adding optional entries to curvatureSepration injection model.
minimum (fThreshold) force and minimum curvature (minInvR1) for
separation were added to have more control on determining the
points of film separation
ENH: ThermoSurfaceFilm in lagragian to search for finiteArea film models
- new model framework: liquidFilm
- new film turbulence models: filmTurbulenceModel with friction models
- new velocity boundary condition: velocityFilmShell to handle/evolve regionFa film
- new function object: setTimeStep to control the simulation time-step based on regionFa Courant number
- add support for the absorption of Lagrangian particles into films
Issue first shows up on gcc-11 with these types of library symbols:
U Foam::tableReader<double>::dictionaryConstructorTablePtr_[abi:cxx11]
xx B Foam::tableReader<double>::dictionaryConstructorTablePtr_
Use concrete hasher functor for runtime selection tables, which
avoids any additional template resolutions (introduced with
95cd8ee75c). The library symbols now resolve _without_ an
additional abi:cxx11 tag.
- need to change requireUpdate_ at the beginning of calculateCache
otherwise it is not updated for "ALL" selection (causing unnecessary
repeated calculations). For other modes, it would have tripped
an error in FULLDEBUG.
- all flags before loaders. Avoids "uninitialized when used here"
warning while preserving the field ownership logic.
- relocate override of updateT basicThermo into constructor body
for clearer logic and initialization
STYLE: plain bool instead of Switch for dpdt flag
1) Adding subMesh capabilities to momentumError and div FOs.
- A subMesh is created from cellZones.
- The operators (div, etc) are only calculated in the subMesh.
2) Optionally, halo cells can be added to the cellZones.
3) New helper class to handle the subMesh creation and field mapping.
- add setter/getter methods for number of grow/shrink steps,
which allows reuse of the same object.
- remove the lower input hard-limit of 1 step, to allow definition of
a no-op filter.
- drop early exit from grow/shrink cycle (potential parallel issues).
- previously a function (unlike the csh version) but since bashrc and
setup have been split -> replace with inline definition
STYLE: formatting/wording for openfoam starters
TUT: simplify controlDict modification, add default substitution
ENH: accept '/' for end-of-options terminator (etc/openfoam)
- makes the application or service more apparent.
* eg. /usr/bin/openfoam / blockMesh
* vs. /usr/bin/openfoam -- blockMesh
Accept lone '-' as the end-of-options terminator, as per bash
- Adjust handling of openfoam '-c' option to flag that a command-string
will appear, but continue with option parsing.
Consistent with bash definition.
- in the 'auto' mode (now the default), it will use cleanCase and also
remove the 0/ directory if a 0.orig/ directory also exists.
This corresponds to a frequent idiom and can be used quite safely
for most cases.
ENH: add -serial / -parallel preference for foamRunTutorials
- adjust commented-out evaluation to avoid warnings.
With code like this
```
#if 0
nxin #eval{ round($nxin / 5) };
#endif
```
The handling of the "#if 0 / #endif" clause uses the plain ISstream
parser to tokenize. This means that the "round(" is parsed as a word
with a mismatched closing ')', whereas the "#eval" parser will slurp
everything in until the closing brace and send it off as a string
to the expression parser.
- Added new faceAreaWeightAMI2D AMIMethod:
- performs intersection using a new 2D triangle class;
- candidate face matches set using an AABBTree method (vs advancing front for
faceAreaWeightAMI).
- Use by setting the AMIMethod entry when specifying the AMI in the
constant/polyMesh/boundary file, e.g.
AMI
{
type cyclicACMI;
AMIMethod faceAreaWeightAMI2D; // new method
Cbb 0.1; // optional coefficient
nFaces 1000;
startFace 100000;
matchTolerance 0.0001;
transform noOrdering;
neighbourPatch AMI1;
nonOverlapPatch AMI1_non_overlap;
}
- The optional Cbb coeffcient controls the size of the bounding box used when
looking for candidate pairs; the value of 0.1 is the default and worked well
for a large range of test cases. For badly matched AMI patches this may need
to be increased.
- Deprecated the partialFaceAreaWeightAMI class - primarily used by ACMI:
- functionality now offered by the AMI variants.
- prghPermeableAlphaTotalPressure for p_rgh
- pressurePermeableAlphaInletOutletVelocity for U
- new helper class for pressure-related BCs: updateableSnGrad
Wrapper that clones the supplied object for each region.
Simplifies the setup of identical post-processing requirements for
multi-region cases.
Applies the supplied function to all regions by default.
Example of function object specification:
multiRegion
{
type multiRegion;
libs (utilityFunctionObjects);
...
function
{
// Actual object specification
type fieldMinMax;
libs (fieldFunctionObjects);
fields (<field1> .. <fieldN>);
}
// Optional entries
regions (region1 region2);
}
Where the entries comprise:
Property | Description | Reqd | Default
type | Type name: multiRegion | yes |
function | Function object sub-dictionary | yes |
regions | List of region names | no | all
Computes a selected operation between multiple \c fieldValue function
objects.
The operation is applied to all results of each \c fieldValue object.
Note
Each object must generate the same number and type of results.
Usage
Minimal example by using \c system/controlDict.functions:
multiFieldValue1
{
// Mandatory entries (unmodifiable)
type multiFieldValue;
libs (fieldFunctionObjects);
// Mandatory entries (runtime modifiable)
operation subtract;
// List of fieldValue function objects as dictionaries
functions
{
region1
{
...
}
region2
{
...
}
...
regionN
{
...
}
}
// Optional (inherited) entries
...
}
where the entries mean:
Property | Description | Type | Req'd | Dflt
type | Type name: multiFieldValue | word | yes | -
libs | Library name: fieldFunctionObjects | word | yes | -
operation | Operation type to apply to values | word | yes | -
functions | List of fieldValue function objects | dict | yes | -
\endtable
Options for the \c operation entry:
add | add
subtract | subtract
min | minimum
max | maximum
average | average
Deprecated fieldValueDelta
- The fieldValueDelta function object was originally written to compute the
difference between two fieldValue-type function objects. The multiFieldValue
object name better describes its purpose whilst being able to operate on an
arbitrary number of fieldValue-type objects.
Currently only applied to the fanFvPatchField, e.g.
plane
{
type fan;
patchType cyclic;
jump uniform 0;
value uniform 0;
uniformJump false;
// Optional under-relaxation
relax 0.2;
...
}
- combines region-based and proximity-based filtering
proxityRegions (post-filter):
Checks the distance of the resulting faces against the original
search surface. Filters based on the area-weighted distance
of each topologically connected region.
If the area-weighted distance of a region is greater than
\c absProximity, the entire region is rejected.
STYLE: 'proxityFaces' as newer synonym for 'proximity' filter
- snGrad, internalField, neighbourField.
Functional use as per swak: "... + internalField(T) ..."
ENH: additional volume/patch expressions
- deltaT()
STYLE: rename exprDriverWriter -> fvExprDriverWriter
- the original class name was a misnomer since it holds a reference
to fvExprDriver
BUG: expression faceToPoint/pointToFace definitions were flipped
ENH: refactor expression hierarchy and code style
- handle TimeState reference at the top-level for simpler derivations
- unified internal search parameters (cruft)
- support wordRes for selecting patch names
- ownerPolyPatch specification is now optional, which simplifies input
and also supports a faMesh spanning different patches but with a
single boundary condition.
Alternatively, can specify more granularity if required.
```
polyMeshPatches ( "top.*" );
boundary
{
inlet1
{
type patch;
ownerPolyPatch top1; // <- specific to this portion
neighbourPolyPatch inlet;
}
inlet2
{
type patch;
ownerPolyPatch top2; // <- specific to this portion
neighbourPolyPatch inlet;
}
outlet
{
type patch;
neighbourPolyPatch outflow;
}
bound
{
type symmetry;
neighbourPolyPatch bound;
}
}
```
- additional -serial/-parallel option:
prefer Allrun-serial or Allrun-parallel if available
- optional -output=DIR to preserve output
ENH: report missing tutorials/ directory in RunFunctions
- add to wmakeFunctions to ensure it works even without 'make' being
installed. Exit immediately after -show-api for consistency with
-version.
foamEtcFile:
- drop warnings for some old (pre-v1812) defunct options
and simply flag as unknown options.
- handle -version, --version as equivalent to -show-api
Prior to the commit, initial residual fields were registered by
the `setResidualField()` function of a linear solver with a field name
prefixed by `residual:`. However, `solverInfo` FO could only access to
the initial residual fields prefixed by `initialResidual:`.
Due to this discrepancy, using `solverInfo` FO with `writeResidualFields=true`
option was resulting in empty residual fields to be output.
- ENH: turbulentDFSEMInlet: add normalisation factors for
input Reynolds stresses, mean velocity and integral-length
scales as entries `Uref` and `Lref`.
- ENH: turbulentDFSEMInlet: add scaling factor entries, `scale`
and `m`, to enable users to tune C1 normalisation coefficient,
if need be.
- BUG: turbulentDFSEM: (fixes#1004#1744#2089)
- see #2090 for theoretical issues related to the DFSEM method.
three macros:
- makeParcelCloudFunctionObjects for kinematic parcels
- makeThermoParcelCloudFunctionObjects for thermo parcels
- makeReactingParcelCloudFunctionObjects for reacting parcels
code style and quality improvements
renamed recon::centre to interfaceCentre.{groupName}
ranmed recon::normal to interfaceNormal.{groupName}
centre and normal field are not written by default
- makes it easier to use for local or alternative storage.
Eg,
```
tmp<volScalarField> tfld;
tfld.cref(obj.cfindObject<volScalarField>("name"));
if (!tfld)
{
tfld = volScalarField::New("name", ...);
}
```
- in some cases, additional dictionary inputs are useful for extending
the input parameters or functionality of dynamic coded conditions.
Typically this can be used to provide a simple set of dictionary
inputs that are used to drive specific code, but allows changing the
inputs without causing a recompilation.
Accessed with this type of code:
```
const dictionary& dict = this->codeContext();
```
boundary conditions and function objects:
* specify an additional codeContext dictionary entry:
```
codeContext
{
...
}
```
PatchFunction1:
* The code context dictionary is simply the dictionary used to specify
the PatchFunction1 coefficients.
To replicated persistant data, use local member static data.
Eg,
```
code
#{
// Persistent (Member) Data
static autoPtr<Function1<scalar>> baseVel;
static autoPtr<Function1<vector>> baseDir;
...
#}
```
fvOptions:
* currently not applicable
- meshTools include/library for many (most) coded items
- add PatchFunction1 include for coded BCs to provide ready access
to Function1 and PatchFunction1
- resizes to current fieldNames_ size and assigns everything to
false to avoid any "stickiness" if the field ordering changes
between reads.
ENH: additional debugging faOption/fvOption (#2110)
- aids tracing which sources are being used/ignored
- update code style
STYLE: rename CodedSource -> CodedFvSource
- avoid future name clashes with CodedFaSource
- with the changes in vtkCellArray, the legacy files now have
OFFSET, CONNECTIVITY information.
- support reading of both versions.
- continue to generate legacy format 2.0, since this is what
many programs still expect
- consider the neighbour polyPatch addressing on the connecting edge,
even when the neighbouring processor does not have a corresponding
section of the finiteArea mesh.
These "dangling" edges now propagate their real connectivity across.
- A bare-bones reconstructor for finiteArea meshes when processor
meshes are available (in parallel) but an equivalent serial faMesh
is needed for reconstruction or decomposition.
In these situations, a serial version of the faMesh is needed,
but preferably without reconstructing the entire volume mesh.
It uses the finiteVolume faceProcAddressing in addition to
the geometric information available from the underlying polyMesh.
The resulting equivalent faMesh can be used for basic operations,
but caution should be exercised before attempting large operations.
- adjust surfactantFoam/planeTransport tutorial to have partial
coverage of the plate by the finiteArea mesh.
Depending on the decomposition, the outflow boundary may coincide
with a processor patch (good for testing purposes).
- additional Allrun-parallel versions for targetted future behaviour
- improved separation of patch creation that is also parallel-aware,
which now allows creation in parallel
- memory-safe use of PtrList for adding patches, with a more generalized
faPatchData helper
- use uindirectPrimitivePatch instead of indirectPrimitivePatch
for internal patch handling.
- align boundary methods with polyMesh equivalents
- system/faMeshDefinition instead of constant/faMesh/faMeshDefinition
as per blockMesh convention. Easier to manage definitions, easier
for cleanup.
- drop inheritence from GeoMesh.
- depending on how the finiteArea is split up across processors,
it is possible that some processors have failed to register
fields in their object registry.
Now ensure that the field names are synchronized in parallel before
attempting a write. Replace locally missing fields with a dummy
zero-sized field.
- refine definition of patch boundary faces to distinguish between
boundaryFaces() and uniqBoundaryFaces().
* boundaryFaces() for edge to face lookup on boundary edges.
* uniqBoundaryFaces() for accessing quantities such as face areas
or eroding an outer layer
ENH: LabelledItem container, replaces unused 'Keyed' container
- method names in alignment with objectHit, pointIndexHit etc.
Top-level name aligns with labelledTri.
- provide '-clean' option for removing old files
- handle out of order '-decomposeParDict' as per RunFunctions
- implicit no-prompt '-yes' with the shortcuts (eg, -log, -xterm)
and set -local if not already defined
- accept <return> to select defaults
This is a partial fix for #2103. If there are no points
extruded for a stand-alone mesh (so not adding to mesh)
it should still include the original patch points. Not
doing so would generate illegal faces (also copiedPatchPoints
would not get set).
- can now drop older Test-decomposePar for exploration purposes
and simply use -dry-run with the -domains and -method options.
- write VTK file instead of volScalarField in combination
with -dry-run and -cellDist.
Avoids adding any OpenFOAM fields and is usually faster to load.
Also easier to rename than a volScalarField would be when exploring
multiple decompositions.
* removed internal upper limit on word/string length for parsed input.
- Although it has not caused many problems, no reason to retain
these limits.
- simplify some of the internal logic for reading string-like items.
- localize parsers for better separation from the header
- expose new function seekCommentEnd_Cstyle(), as useful
handler of C-style comments
* exclude imbalanced closing ')' from word/variable
- previously included this into the word/variable, but makes more
sense to leave on the parser for the following token.
Prevents content like 'vector (10 20 $zmax);' from being parsed
as '$zmax)' instead of as '$zmax' followed by a ')'.
No conceivable reason that the former would actually be desirable,
but can still be obtained with brace notation: Eg, '${zmax)}'
* consistent handling of ${{ ... }} expressions
- within a dictionary content, the following construct was
incorrectly processed:
value ${{2*sqrt(0.5)}};
Complains about no dictionary/env variable "{2*sqrt(0.5)}"
Now trap expressions directly and assign their own token type
while reading. Later expansion can then be properly passed to
the exprDriver (evalEntry) instead of incorrectly trying
variable expansion.
Does not alter the use of expressions embedded within other
expansions. Eg, "file${{10*2}}"
* improve #eval { ... } brace slurping
- the initial implementation of this was rudimentary and simply
grabbed everything until the next '}'. Now continue to grab
content until braces are properly balanced
Eg, the content: value #eval{${radius}*2};
would have previously terminated prematurely with "${radius" for
the expression!
NOTE:
both the ${{ expr }} parsed input and the #eval { ... } input
discard C/C++ comments during reading to reduce intermediate
overhead for content that will be discarded before evaluation
anyhow.
* tighten recognition of verbatim strings and expressions.
- parser was previously sloppy and would have accepted content such
as "# { ..." (for example) as an verbatim string introducer.
Now only accept parse if there are no intermediate characters
discarded.
- minor simplification of #if/#endif handling
ENH: improve input robustness with negative-prefixed expansions (#2095)
- especially in blockMeshDict it is useful to negate an value directly.
Eg,
```
xmax 100;
xmin -$xmax;
```
However, this fails since the dictionary expansion is a two-step
process of tokenization followed by expansion. After the expansion
the given input would now be the following:
```
xmax 100;
xmin - 100;
```
and retrieving a scalar value for 'xmin' fails.
Counteract this by being more generous on tokenized input when
attempting to retrieve a label or scalar value.
If a '-' is found where a number is expected, use it to negate the
subsequent value.
The previous solution was to invoke an 'eval':
```
xmax 100;
xmin #eval{-$xmax};
```
which adds additional clutter.
- intended for the following type of use:
auto oldHandler = fileHandler(fileOperation::NewUncollated());
... do something that only works with uncollated
// Restore previous (if any)
if (oldHandler)
{
fileHandler(std::move(oldHandler));
}
ENH: make fileOperation distributed(bool) mutable
- use is "static-like" and akin to Pstream::parRun(bool),
thus allow toggling of the switch without a const_cast
- return internalEdges() and boundaryEdges() sub lists directly
- calculate and return boundaryFaces() to identify faces attached to
boundary edges.
- minor code cleanup, and add PrimitivePatchBase class for
non-templated code.
STYLE: mark unused parameter in globalMeshData mergePoints
- this constructor was added for similarity with std::vector,
but continues to cause various annoyances.
The main problem is that the templated parameter tends to grab
anything that is not a perfect match for other constructors.
Typically seen with two integers (in 64-bit mode), but various other
cases as well.
If required, the ListOps::create() function provides a lengthier
alternative but one that can also incorporate transformations.
Eg,
pointField pts = ....;
List<scalar> mags
(
List<scalar>::create
(
pts.begin(),
pts.end(),
[](const vector& v){ return magSqr(v); }
);
- additional rcEdge(), rcEdges() methods for reverse order walk
- accept generic edge() method as alternative to faceEdge() for
single edge retrieval.
- edge() method with points -> returns the vector
- reduce the number of operations in edgeDirection methods
DEFEATURE: remove longestEdge global function
- deprecated and replaced by face::longestEdge() method (2017-04)
Historically the "geometry" for static meshes was placed under
directly in the EnSight case directory.
Eg,
ensight/ensight.case
ensight/geometry
ensight/data/000001
ensight/data/000002 ...
This generally works ok, but relocating it to a constant data directory
Eg
ensight/ensight.case
ensight/data/constant/geometry
ensight/data/000001
ensight/data/000002 ...
Improves handling and avoids potential collisions when adding in
additional mesh regions
- reduces code, simplifies creation of new, specialized polyData
writers.
- new templated vtk::GenericPatchWriter, which adds support for
writing both uindirectPrimitivePatch + indirectPrimitivePatch types.
- handle geometric fields separately from regular fields with
* vtk:GenericPatchGeoFieldsWriter
* vtk:indirectPatchGeoFieldsWriter
* vtk:uindirectPatchGeoFieldsWriter
- can be used for block-like meshes that are not aligned with the global
coordinate directions. Alternatively, for general testing purposes.
Example,
method simple;
coeffs
{
n ( 2 2 2 );
transform
{
origin (-0.15 0.15 0);
e1 (1 1 0);
e3 (0 0 1);
}
}
Step 1.
include "addAllRegionOptions.H"
Adds the -allRegions, -regions and -region options to argList.
Step 2.
include "getAllRegionOptions.H"
Processes the options with -allRegions selecting everything
from the regionProperties.
OR use -regions to specify multiple regions (from
regionProperties), and can also contain regular expressions
OR use the -region option
Specifying a single -regions NAME (not a regular expresssion)
is the same as -region NAME and doesn't use regionProperties
Creates a `wordList regionNames`
Step 3.
Do something with the region names.
Either directly, or quite commonly with the following
include "createNamedMeshes.H"
Creates a `PtrList<fvMesh> meshes`
STYLE: add description to some central include files
- make regionName an optional constructor parameter, which eliminates
a separate set of constructors and construction tables. Adjust
internals to treat a missing/empty regionName as a no-op.
- pass in fallback dictionary content via new IOdictionary constructor
with a pointer
ENH: further relax check for matching number of processor dirs
- if the "numberOfSubdomains" entry is missing (or even zero)
ignore checks of processor dirs as meaningless.
- additional debug information
- improve support for dictionary specification of constant, polynomial
and table entries. These previously only worked properly for
primitiveEntry, which causes confusion.
- extend table Function1 to include TableFile functionality.
Simplifies switching and modifying content.
- additional default construct
- add explicit zero-size constructor for ITstream.
For tagged dispatching, without ambiguity
- elminate mandatory name for parsing versions.
This makes it easier to use ITstream, IStringStream, UListStream
interchangeable.
- some code used copy construct from dictionary::null instead.
The result is the same but suggests that something else may be intended.
Only need dictionary::null for const-ref usage.
- allows use of surface names starting with a digit
(by quoting the name).
User is responsible for not generating bad names for output files.
Eg "bad.**.name", since these will be difficult to handle from the
shell
- largely as per patch from Jong-Gwan (Jason) Do
NB: the intel-one setup adds in paths for intelmpi.
Its mpicc version does not harmonize with the OpenFOAM
system openmpi setup (using mpicc --showme:link).
Needs adjustment, or use intelmpi instead.
- update name mappings for newer gcc, clang versions
Checking for the sum of species mass fraction in multiComponentMixture.
It can't be zero at the internal field or patches. A fatal error is thrown.
A warning was added if the mixture sum is different from one. In a
re-start the mass fraction can be slightly unbounded and new
normalization is required.
- The keyType is primarily used within dictionary reading, whereas
wordRe and wordRes are used for selectors in code.
Unifying on wordRe and wordRes reduces the number matching options.
- additional dummy template parameter to assist with supporting
derived classes. Currently just used for string types, but can be
extended.
- provide hash specialization for various integer types.
Removes the need for any forwarding.
- change default hasher for HashSet/HashTable from 'string::hash'
to `Hash<Key>`. This avoids questionable hashing calls and/or
avoids compiler resolution problems.
For example,
HashSet<label>::hasher and labelHashSet::hasher now both properly
map to Hash<label> whereas previously HashSet<label> would have
persistently mapped to string::hash, which was incorrect.
- standardize internal hashing functors.
Functor name is 'hasher', as per STL set/map and the OpenFOAM
HashSet/HashTable definitions.
Older code had a local templated name, which added unnecessary
clutter and the template parameter was always defaulted.
For example,
Old: `FixedList<label, 3>::Hash<>()`
New: `FixedList<label, 3>::hasher()`
Unchanged: `labelHashSet::hasher()`
Existing `Hash<>` functor namings are still supported,
but deprecated.
- define hasher and Hash specialization for bitSet and PackedList
- add symmetric hasher for 'face'.
Starts with lowest vertex value and walks in the direction
of the next lowest value. This ensures that the hash code is
independent of face orientation and face rotation.
NB:
- some of keys for multiphase handling (eg, phasePairKey)
still use yet another function naming: `hash` and `symmHash`.
This will be targeted for alignment in the future.
- wrap command-line retrieval of fileName with an implicit validate.
Instead of this:
fileName input(args[1]);
fileName other(args["someopt"]);
Now use this:
auto input = args.get<fileName>(1);
auto other = args.get<fileName>("someopt");
which adds a fileName::validate on the inputs
Because of how it is implemented, it will automatically also apply
to argList getOrDefault<fileName>, readIfPresent<fileName> etc.
- adjust fileName::validate and clean to handle backslash conversion.
This makes it easier to ensure that path names arising from MS-Windows
are consistently handled internally.
- dictionarySearch: now check for initial '/' directly instead of
relying on fileName isAbsolute(), which now does more things
BREAKING: remove fileName::clean() const method
- relying on const/non-const to control the behaviour (inplace change
or return a copy) is too fragile and the const version was
almost never used.
Replace:
fileName sanitized = constPath.clean();
With:
fileName sanitized(constPath);
sanitized.clean());
STYLE: test empty() instead of comparing with fileName::null
- simplify compile/uncompile, reading, assignment
- implicit construct wordRe from keyType (was explicit) to simplify
future API changes.
- make Foam::isspace consistent with std::isspace (C-locale)
by including vertical tab and form feed
ENH: improve #ifeq float/label comparisons
- originally had tests for regex meta characters strewn across
regExp classes as well as wordRe, keyType, string.
And had special-purpose quotemeta static function within string
that relied on special naming convention for testing the meta
characters.
The regex meta character testing/handling now relegated entirely
to the regExp class(es).
Relocate quotemeta to stringOps, with a predicate.
- avoid code duplication. Reuse some regExpCxx methods in regExpPosix
It was only looking for faces that were used in both
endpoints but not actually checking whether they were indeed
an edge (== consecutive vertex) in all faces. So if one
face had an additional crossing edge and another didn't it
would find more edgeFaces than the proper
'primitiveMesh::edgeFaces()' routine.
This occasionally happened inside snappyHexMesh
(e.g. motorBike tutorial)
When extruding an edge to a patch face make sure to extrude
all the patch faces connected to that edge and cell. This
will handle cyclicACMI (has duplicate patches - AMI and non-overlap)
fvMesh::readUpdate calls polyMesh::readUpdate which updates
the ACMI (including mesh areas etc). So we should not call
polyMesh::clearOut again inside fvMesh::readUpdate to avoid
having to re-do all the ACMI.
For example,
```
entry #eval 10 { vector(rand(), 0, 0) };
```
ENH: be more generous and ignore trailing ';' in expressions
STYLE: adjust parse token name for tensor::I
- previously had a very old (likely irrelevant) setting for solaris
systems only.
- support site-specific customization.
Eg, using etc/config.{csh,sh}/prefs.fjmpi
- remove erroneous shell redirects present in cshell files
- less important for VTK (may help in future though) but preserve
the face point 0 when flipping faces to ensure that the result
is the same as having called face::reverseFace()
- overCompressibleInterDyMFoam: Overset solver for two compressible,
non-isothermal, immiscible fluids using a VOF (i.e. volume of fluid)
phase-fraction based interface capturing approach.
- overInterPhaseChangeDyMFoam: Overset solver for two incompressible,
isothermal, immiscible fluids with phase-change (e.g. cavitation) using
VoF (i.e. volume of fluid) phase-fraction based interface capturing approach.
- adds new tutorials:
- multiphase/overCompressibleInterDyMFoam/compressibleTwoSimpleRotors
- multiphase/overInterPhaseChangeDyMFoam/twoSimpleRotors
Signed-off-by: Kutalmis Bercin <kutalmis.bercin@esi-group.com>
- useful when used in a batch process to trap the exit signal,
e.g. stop the run when the velocity magnitude exceeds a given
threshold:
runTimeControl
{
type runTimeControl;
libs ("libutilityFunctionObjects.so");
nWriteStep 1;
// Optional end 'action'
satisfiedAction abort; // end; // setTrigger
conditions
{
maxU
{
type minMax;
functionObject MinMax;
fields ("max(mag(U))");
value 1e6;
mode maximum;
}
}
}
- if the system/decomposeParDict is missing, skip check for matching
number of processor dirs. This can make job dispatch easier.
Does not apply if -decomposeParDict was explicitly specified.
STYLE: adjust naming of host/slaves in argList
- ensure that the processor directory cache is consistently available
by providing appropriate synthesized names. If the expected files
really do not exist, it will still fail at a later point (but not in
the caching).
This addresses cases that have been manually distributed
(different content on different nodes, but the same root path),
while still maintaining the readDir on master only for massively
parallel cases (#1946). It also addresses regular cases with
gaps in the processor directories.
- new '-ascii' option to write in ASCII format instead of the
controlDict setting. This can be useful when generating fields that
should be parsed with other tools, or for visual inspection.
- correct mismatch of option names and lookups
- can use either command-line option "-load-fields" or dictionary
entry "readFields" to specify field names to be preloaded.
Essentially the same functionality as with a readFields function
object but with a lot less typing.
- tutorial examples provided by Ryan Danks <ryan.danks@rwdi.com>
illustrate using setExpr* utilities to calculate a quantity
as a post-processing step.
- simplifies local toggling.
- centralize fileModification static variables into IOobject.
They were previously scattered between IOobject and regIOobject
to operate with overset
1) Adding zoneMotion to rigidBodyMotion
2) Introducing PID to prescribedRotation restraint
3) Making drivenLinearMotion read total displacement
4) When drivenLinearMotion is used sixDof and rigid-body solvers
write total displacement
- currently add to mesh zones to provide a table of contents
of the zone names that allows downstream consumers quick access to
the information without needing to parse the entire file.
- support selective enable/disable of the file banner.
ENH: improve code isolation for decomposedBlockData
- use readBlockEntry/writeBlockEntry to encapsulate the IO handling,
which ensures more consistency
- new decomposedBlockData::readHeader for chaining into the
block header information.
- remove unused constructors for decomposedBlockData
ENH: minor cleanup of collated fileOperations
- improves interface and data consistency.
Older signatures are still active (via the Foam_IOstream_extras
define).
- refine internals for IOstreamOption streamFormat, versionNumber
ENH: improve data alignment for IOstream and IOobject
- fit sizeof label/scalar into unsigned char
STYLE: remove dead code
- read/write lists of character data in binary only.
This is the only means of preserving data.
If character data are written as an ASCII list, there is no means of
determining if spaces or newlines are content or separators.
- handle binary/contiguous first as being the most obvious, followed
by increasing complexity of ascii.
Structure reading and writing routines similarly by introducing a
readList method to compliment the writeList method.
- override casename, procesorCase flags to guarantee reconstructed
case to be written to the undecomposed directory
- alternative is to construct a Zero mesh on the undecomposed
runTime and add all other bits to that but that has not been
pursued
- patch point ordering was affected by the EnSight face sorting
(tri, quad, nsided). This did not affect other point fields,
since they use the internal field values.
- for use when the is_contiguous check has already been done outside
the loop. Naming as per std::span.
STYLE: use data/cdata instead of begin
ENH: replace random_shuffle with shuffle, fix OSX int64 ambiguity
- direct check of punctuation.
For example,
while (!tok.isPunctuation(token::BEGIN_LIST)) ..
instead of
while (!(tok.isPunctuation() && tok.pToken() == token::BEGIN_LIST)) ..
Using direct comparison (tok != token::BEGIN_LIST) can be fragile
when comparing int values:
int c = readChar(is);
while (tok != c) .. // Danger, uses LABEL comparison!
- direct check of word.
For example,
if (tok.isWord("uniform")) ..
instead of
if (tok.isWord() && tok.wordToken() == "uniform") ..
- make token lineNumber() a setter method
ENH: adjust internal compound method empty() -> moved()
- support named compound tokens
STYLE: setter method for stream indentation
- pointPatches may or may not have a "value" type.
Use the patch value field where possible and the internal field
otherwise. Previously always used the internal field.
- the raw surface writer simply outputs x/y/z and field values.
This additional flag allows recovery of some geometric information.
- optional user-specified output precision
Example,
```
formatOptions
{
raw
{
normal yes;
precision 10;
}
}
```
- centralises existing functions (erfInv, incGamma*, invIncGamma*).
Provides a location for additional functions in the future.
- adjusted existing models to use these functions
(e.g. distributionModels::normal)
- eliminates a potentially invalid code branch.
Since it essentially had the same internals as std::swap anyhow,
make that more evident.
ENH: use std::swap for basic types
- makes it clearer that they do not rely on any special semantics
- since the wrapped cmake calls generally use the regular build
locations, add in MPI information to properly handle changes
in that as well. This makes it easier to build for multiple MPI
instances.
- ensure surface writing is time-step and nFields aware.
This avoids overwriting (ignoring) previous output fields.
- allow sampled surfaces to be used for weight fields as well.
Not sure why this restriction was still there.
- remove old compatibility reading of orientedFields.
Last used in v1612, now removed.
- only use face sampling. For surfaceFieldValue we can only do
something meaningful with face values.
ENH: modify interface methods for surfaceWriter
- replace direct modification of values with setter methods.
Eg,
old: writer.isPointData() = true;
new: writer.isPointData(true);
This makes it possible to add internal hooks to catch state changes.
ENH: allow post-construction change to sampledSurface interpolation
- rename interpolate() method to isPointData() for consistency with
other classes and to indicate that it is a query.
- additional isPointData(bool) setter method to change the expected
representation type after construction
- remove 'interpolate' restriction on isoSurfacePoint which was
previously flagged as an error but within sampledSurfaces can use
sampleScheme cellPoint and obtain representative samples.
Relax this restriction since this particular iso-surface algorithm
is slated for removal in the foreseeable future.
1) Small modification to the tracking logic for detA zero.
2) Adding small vector displacement to locate function to avoid error where
particle is inserted at the cell centre.
- get: uses access operation to get values for each list item
Example,
PtrListOps::get(mesh.boundaryMesh(), nameOp<polyPatch>());
- names: the name() of each list item filtered for matches
- firstMatching: index of first item with a matching name()
- findMatching: indices of items with a matching match name()
Example,
PtrListOps::findMatching(mesh.boundaryMesh(), wordRes( ... ));
STYLE: deprecate transitional getNameOp, getTypeOp
- use nameOp, typeOp (word.H) instead
If the 'writeFields' option is set in surfaceFieldValue, e.g.
surface1
{
type surfaceFieldValue;
libs (fieldFunctionObjects);
operation none;
fields (p);
regionType patch;
name walls;
// Create a surface in VTK format
writeFields yes;
surfaceFormat vtk;
}
... the surface can now be used in runTimePostProcessing, e.g.:
surfaces
{
surfaceFieldValueOutput
{
type functionObjectSurface;
representation surface;
liveObject no;
field p;
colourBy field;
range (0 120000);
functionObject surface1;
}
}
Note: setting 'liveObject' to 'no' to suppress warnings due to the surface
not being retrieved from the object registry (default = 'yes') - this surface
can [currently] only be read from disk.
- modification/continuation of 8d63073b08 and 5c1ec7ecb8 (#595).
Although this protected function is only used internally, the name
`size(label)` is too easily confused with `resize(label)` and
`setSize(label)`. The longer method name eliminates some ambiguity.
Name consistent with PtrListDetail.
- leave size(label) method (for possible compatibility),
but mark as deprecated
- improve sizing consistency for (Istream >> DynamicList)
STYLE: more consistent use of resize vs setSize in DynamicList
- more consistency between DynamicList and DynamicField.
There were some inconsistencies in how construct with a size was
interpreted.
STYLE: more consistent declaration/use of Swap
- this was previously suppressed for ASCII format as being 'clutter',
but without it there is no context for interpreting the type of data
contained in ASCII files: potentially leading to integer overflows
when reading in ParaView etc.
dynamicRefineFvMesh optionally can map fluxes derived from velocities
fields specified in dynamicMeshDict. The surface interpolation was
using old weights. This fix clear the old weights before mapping
the fluxes
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.
