- provides a simple means of defining/modifying fields. For example,
```
<name1>
{
type exprField;
libs (fieldFunctionObjects);
field pTotal;
expression "p + 0.5*(rho*magSqr(U))";
dimensions [ Pa ];
}
```
It is is also possible to modify an existing field.
For example, to modify the previous one.
```
<name2>
{
type exprField;
libs (fieldFunctionObjects);
field pTotal;
action modify;
// Static pressure only in these regions
fieldMask
#{
(mag(pos()) < 0.05) && (pos().y() > 0)
|| cellZone(inlet)
#};
expression "p";
}
```
To use as a simple post-process calculator, simply avoid storing the
result and only generate on write:
```
<name2>
{
store false;
executionControl none;
writeControl writeTime;
...
}
```
- literal lookups only for expression strings
- code reduction for setExprFields.
- changed keyword "condition" to "fieldMask" (option -field-mask).
This is a better description of its purpose and avoids possible
naming ambiguities with functionObject triggers (for example)
if we apply similar syntax elsewhere.
BUG: erroneous check in volumeExpr::parseDriver::isResultType()
- not triggered since this method is not used anywhere
(may remove in future version)
Based on:
Cao, L., Sun, F., Chen, T., Tang, Y., & Liao, D. (2018).
Quantitative prediction of oxide inclusion defects inside
the casting and on the walls during cast-filling processes.
International Journal of Heat and Mass Transfer, 119, 614-623.
DOI:10.1016/j.ijheatmasstransfer.2017.11.127
Co-authored-by: Kutalmis Bercin <kutalmis.bercin@esi-group.com>
- this refines commit c233961d45, which added prefix scoping.
Default is now off (v2106 behaviour).
The 'useNamePrefix' keyword can be specified on a per function basis
or at the top-level of "functions".
```
functions
{
errors warn;
useNamePrefix true;
func1
{
type ...;
useNamePrefix false;
}
func2
{
type ...;
// Uses current default for useNamePrefix
}
}
```
- at the moment there is no significant difference since FieldBase is
essentially just a refCount anyhow, but changing the inheritance
ensures that reinterpret casting from SubField -> Field will
continue to work if FieldBase is changed in the future.
A Helmholtz-like filter is applied to the original field of sensitivity
derivatives. The corresponding PDE is solved on the sensitivity patches,
using the finite area infrastructure. A smoothing radius is needed,
which is computed based on the average 'length' of the boundary faces,
if not provided by the user explicitly.
If an faMesh is provided, it will be used; otherwise it will be created
on the fly based on either an faMeshDefinition dictionary in system or
one constructed internally based on the sensitivity patches.
Surface gradient scheme with under-/over-relaxed
full or limited explicit non-orthogonal correction.
A minimal example by using system/fvSchemes:
snGradSchemes
{
snGrad(<term>) relaxed;
}
and by using system/fvSolution:
relaxationFactors
{
fields
{
snGrad(<term>) <relaxation factor>;
}
}
A second-order gradient scheme using face-interpolation,
Gauss' theorem and iterative skew correction.
Minimal example by using system/fvSchemes:
gradSchemes
{
grad(<term>) iterativeGauss <interpolation scheme> <number of iters>;
}
- fix overly aggressive match in the API value
- allow `INTELMPI*` generic value, this can be used to specify something
like INTELMPI_custom and populate the corresponding wmake rule
manually
STYLE: mention FOAM_BUILDROOT in wmake -help-full output
STYLE: adjust openfoam shell session welcome information
- adjust internal variable names to reduce collision potential
- improve handling of openfoam -etc=...
Description
Writes point data in glTF v2 format
Two files are generated:
- filename.bin : a binary file containing all scene entities
- filename.gltf : a JSON file that ties fields to the binary data
The output can contain both geometry and fields, with additional support
for colours using a user-supplied colour map, and animation of particle
tracks.
Controls are provided via the optional formatOptions dictionary.
For non-particle track data:
\verbatim
formatOptions
{
// Apply colours flag (yes | no ) [optional]
colours yes;
// List of options per field
fieldInfo
{
p
{
// Colour map [optional]
colourMap <colourMap>;
// Colour map minimum and maximum limits [optional]
// Uses field min and max if not specified
min 0;
max 1;
// Alpha channel [optional] (uniform | field)
alpha uniform;
alphaValue 0.5;
//alpha field;
//alphaField T;
//normalise yes;
}
}
}
\verbatim
For particle tracks:
\verbatim
formatOptions
{
// Apply colours flag (yes | no) [optional]
colours yes;
// Animate tracks (yes | no) [optional]
animate yes;
// Animation properties [optional]
animationInfo
{
// Colour map [optional]
colourMap <colourMap>;
// Colour [optional] (uniform | field)
colour uniform;
colourValue (1 0 0); // RGB in range [0-1]
//colour field;
//colourField d;
// Colour map minimum and maximum limits [optional]
// Note: for colour = field option
// Uses field min and max if not specified
min 0;
max 1;
// Alpha channel [optional] (uniform | field)
alpha uniform;
alphaValue 0.5;
//alpha field;
//alphaField T;
//normalise yes;
}
}
\endverbatim
Note
When writing particle animations, the particle field and colour properties
correspond to initial particle state (first data point) and cannot be
animated (limitation of the file format).
For more information on the specification see
https://www.khronos.org/registry/glTF/
The utility will now add field data to all tracks (previous version only
created the geometry)
The new 'fields' entry can be used to output specific fields.
Example
cloud reactingCloud1;
sampleFrequency 1;
maxPositions 1000000;
fields (d U); // includes wildcard support
STYLE: minor typo fix
- specify any of these
./Allwmake -build-root=...
wmake -build-root=...
FOAM_BUILDROOT=... wmake
these specify an alternative root where build artifacts are to land.
Currently only used as an alternative for the 'build/' hierarchy
since the 'platforms/' target normally includes inputs as well.
Possible use:
```
(
export WM_MPLIB="%{foam_mplib}"
export FOAM_MPI="%{foam_mpi}"
export MPI_ARCH_PATH="%{mpi_prefix}"
export FOAM_BUILDROOT=/tmp/mpibuild
export FOAM_MPI_LIBBIN="$FOAM_BUILDROOT/platforms/$WM_OPTIONS/lib/$FOAM_MPI"
src/Pstream/Allwmake-mpi
)
```
- exposed by the new embedded function handling.
Requires local copies of dictionary content instead
(similar to coded BCs handling)
BUG: incorrect formatting for expression function output
ENH: simpler copyDict version taking wordList instead of wordRes
- corresponds to the most common use case at the moment
ENH: expression string writeEntry method
- write as verbatim for better readability
- this revises the changes made in 95cd8ee75c to replace the
SFINAE-type of handling of string hashes with direct definitions.
This places a bit more burden on the developer if creating hashable
classes derived from std::string or variants of Foam::string, but
improves reliability when linking.
STYLE: drop template key defaulting from HashSet
- this was never used and `HashSet<>` is much less transparent
than writing `HashSet<word>` or `wordHashSet`
- Generic thermophysical properties class for a liquid in which the
functions and coefficients for each property are run-time selected.
Code adapted from openfoam.org
- had lookups into the merge-point map instead of
determining/remapping the duplicate points directly.
The result was a jumble of face/point addressing.
STYLE: additional debug/verbosity comment for mergePoints
- marks if the value is considered to be independent of 'x'.
Propagate into PatchFunction1 instead ad hoc checks there.
- adjust method name in PatchFunction1 to 'whichDb()' to reflect
final changes in Function1 method names.
ENH: add a Function1 'none' placeholder function
- This is principally useful for interfaces that expect a Function1
but where it is not necessarily used by a particular submodel.
TUT: update Function1 creation to use objectRegistry
- allows an additional HashTable of pointers to reference external
content which not otherwise directly available via an
objectRegistry.
This could typically be used to provide a function-local "rho"
to the expression evaluation.
- for cell quantities, these evaluate on the faceCells associated with
that patch to produce a field of true/false values
- for face quantities, these simply correspond to the mesh faces
associated with that patch to produce a field of true/false values
- similar idea to swak timelines/lookuptables but combined together
and based on Function1 for more flexibility.
Specified as 'functions<scalar>' or 'functions<vector>'.
For example,
functions<scalar>
{
intakeType table ((0 0) (10 1.2));
p_inlet
{
type sine;
frequency 3000;
scale 50;
level 101325;
}
}
These can be referenced in the expressions as a nullary function or a
unary function.
Within the parser, the names are prefixed with "fn:" (function).
It is thus possible to define "fn:sin()" that is different than
the builtin "sin()" function.
* A nullary call uses time value
- Eg, fn:p_inlet()
* A unary call acts as a remapper function.
- Eg, fn:intakeType(6.25)
- previously simply reused the scan token, which works fine for
non-nested tokenizations but becomes too fragile with nesting.
Now changed to use tagged unions that can be copied about
and still retain some rudimentary knowledge of their types,
which can be manually triggered with a destroy() call.
- provide an 'identifier' non-terminal as an additional catch
to avoid potential leakage on parsing failure.
- adjust lemon rules and infrastructure:
- use %token to predefine standard tokens.
Will reduce some noise on the generated headers by retaining the
order on the initial token names.
- Define BIT_NOT, internal token rename NOT -> LNOT
- handle non-terminal vector values.
Support vector::x, vector::y and vector::z constants
- permit fieldExpr access to time().
Probably not usable or useful for an '#eval' expression,
but useful for a Function1.
- provisioning for hooks into function calls. Establishes token
names for next commit(s).
Returns a 0/1 value corresponding to function object trigger levels.
Usage:
\verbatim
<entryName> functionObjectTrigger;
<entryName>Coeffs
{
triggers (1 3 5);
defaultValue false; // Default when no triggers activated
}
\endverbatim
ENH: add reset() method for Constant Function1
ENH: allow forced change of trigger index
- the triggers are normally increase only,
but can now override this optionally
Description
Function1 wrapper that maps the input value prior to it being used by
another Function1.
Example usage for limiting a polynomial:
\verbatim
<entryName>
{
type inputValueMapper;
mode minMax;
min 0.4;
max 1.4;
value polynomial
(
(5 1)
(-2 2)
(-2 3)
(1 4)
);
}
\endverbatim
Here the return value will be:
- poly(0.4) for x <= 0.4;
- poly(1.4) for x >= 1.4; and
- poly(x) for 0.4 < x < 1.4.
Example usage for supplying a patch mass flux for a table lookup:
\verbatim
<entryName>
{
type inputValueMapper;
mode function;
function
{
type functionObjectValue;
functionObject surfaceFieldValue1;
functionObjectResult sum(outlet,phi);
}
value
{
type table;
file "<system>/fanCurve.txt";
}
}
\endverbatim
Where:
\table
Property | Description | Required
mode | Mapping mode (see below) | yes
function | Mapping Function1 | no*
min | Minimum input value | no*
max | Maximum input value | no*
value | Function of type Function1<Type> | yes
\endtable
Mapping modes include
- none : the input value is simply passed to the 'value' Function1
- function : the input value is passed through the 'function' Function1
before being passed to the 'value' Function1
- minMax : limits the input value to 'min' and 'max' values before being
passed to the 'value' Function1
Note
Replaces the LimitRange Function1 (v2106 and earlier)
Returns a value retrieved from a function object result.
Usage:
<entryName> functionObjectValue;
<entryName>Coeffs
{
functionObject <name>;
functionObjectResult <function object result field name>
}
Function1 can now be created with an object registry, e.g. time or mesh
database. This enables access to other stored objects, e.g. fields,
dictionaries etc. making Function1 much more flexible.
Note: will allow TimeFunction1 to be deprecated
- created new functionObjects::properties class derived from IOdictionary
- replaces raw state IOdictionary owned by functionObjectList
- state dictionary access/manipulators moved from stateFunctionObject
- stateFunctionObject now acts as a light wrapper around
functionObjecties::properties
- updated dependent code
- more closely reflect what the binaries report
- report the installation path
- change PS1 case/separator to roughly correspond to package names
STYLE: adjust README to mention upcoming v2112
- use `#word` to concatenate, expand content with the resulting string
being treated as a word token. Can be used in dictionary or
primitive context.
In dictionary context, it fills the gap for constructing dictionary
names on-the-fly. For example,
```
#word "some_prefix_solverInfo_${application}"
{
type solverInfo;
libs (utilityFunctionObjects);
...
}
```
The '#word' directive will automatically squeeze out non-word
characters. In the block content form, it will also strip out
comments. This means that this type of content should also work:
```
#word {
some_prefix_solverInfo
/* Appended with application name (if defined) */
${application:+_} // Use '_' separator
${application} // The application
}
{
type solverInfo;
libs (utilityFunctionObjects);
...
}
```
This is admittedly quite ugly, but illustrates its capabilities.
- use `#message` to report expanded string content to stderr.
For example,
```
T
{
solver PBiCG;
preconditioner DILU;
tolerance 1e-10;
relTol 0;
#message "using solver: $solver"
}
```
Only reports on the master node.
- use FACE_DATA (was SURFACE_DATA) for similarity with polySurface
ENH: add expression value enumerations and traits
- simple enumeration of standard types (bool, label, scalar, vector)
that can be used as a value type-code for internal bookkeeping.
GIT: relocate pTraits into general traits/ directory
- releases ownership of the pointer. A no-op (and returns nullptr)
for references.
Naming consistent with unique_ptr and autoPtr.
DOC: adjust wording for memory-related classes
- add is_const() method for tmp, refPtr.
Drop (ununsed and confusing looking) isTmp method from refPtr
in favour of is_pointer() or movable() checks
ENH: noexcept for some pTraits methods, remove redundant 'inline'
- test for const first for tmp/refPtr (simpler logic)
- previously had codeAddSup used for both incompressible and
compressible source terms. However, it was not actually possible to
use it for compressible sources since any references to the 'rho'
parameter would cause a compilation error for the incompressible case.
Added 'codeAddSupRho' to distinguish the compressible case.
User must supply one or both of them on input.
- decomposePar: -no-fields to suppress decomposition of fields
- makeFaMesh: -no-decompose to suppress creation of *ProcAddressing
and fields, -no-fields to suppress decomposition of fields only
- switch from default topology merge to point merge if degenerate
blocks are detected. This should alleviate the problems noted in
#1862.
NB: this detection only works for blocks with duplicate vertex
indices, not ones with geometrically duplicate points.
ENH: add patch block/face summary in blockMesh generation
- add blockMesh -verbose option to override the static or dictionary
settings. The -verbose option can be used multiple times to increase
the verbosity.
ENH: extend hexCell handling with more cellShape-type methods
- allows better reuse in blockMesh.
Remove blockMesh-local hex edge definitions that shadowed the
hexCell values.
ENH: simplify some of the block-edge internals
- similar to -dry-run handling, can be interrogated from argList,
which makes it simpler to add into utilities.
- support multiple uses of -dry-run and -verbose to increase the
level. For example, could have
someApplication -verbose -verbose
and inside of the application:
if (args.verbose() > 2) ...
BUG: error with empty distributed roots specification (fixes#2196)
- previously used the size of distributed roots to transmit if the
case was running in distributed mode, but this behaves rather poorly
with bad input. Specifically, the following questionable setup:
distributed true;
roots ( /*none*/ );
Now transmit the ParRunControl distributed() value instead,
and also emit a gentle warning for the user:
WARNING: running distributed but did not specify roots!
COMP: implicit cast scope name to C++-string in IOobject::scopedName
- handles 'const char*' and allows a check for an empty scope name
COMP: avoid potential name conflict in local function (Istream)
- reportedly some resolution issues (unconfirmed) with Fujitsu clang
- 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
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.
