- improve handling of changes in ParaView/VTK or cmake parameters (#1693)
* adjust internals to support recording of an unlimited number of
configuration parameters and use file `cmp` instead of trying
to check strings ourselves.
ENH: new wmake/scripts/wmake.cmake-args handler
- additional handling of -prefix=... as CMAKE_INSTALL_PREFIX export.
- in some contexts, can use instead of AllwmakeParseArguments
- bin/tools/create-mpi-config to query/write values for system openmpi.
In some cases this can be used to avoid an mpicc requirement at runtime.
- adjust openfoam session to include -test-tutorial forwarding to the
tutorials/AutoTest. This helps with writing installation tests.
- adjust foamConfigurePaths to latest version
- removal of gperftools default config, as per develop
- remove MSWindows components (code and makefiles)
- use cxx, hxx extensions to reduce possible confusion with other
"list" and "vector" classes
- use C++ versions for C headers
- align wmake have_* scripts to support version query as per current
develop branch
- use config.sh/ fallbacks when the corresponding *_ARCH_PATH is empty
(eg, BOOST, CGAL, FFTW).
This aids when building outside of the regular OpenFOAM environment.
- add '[-+.~]' to the recognized qualifiers.
This allows simple readable names such as
WM_COMPILER=Clang-vendor
but also opens the FUTURE (not yet supported) possibility of
combining in additional information. For example,
WM_COMPILER=Clang~openmp
WM_COMPILER=Clang+cuda~openmp
by using '+' (add) and '~' (subtract) notation similar to what
spack uses.
CONFIG: support 'override' rules
- if present, compiler-family 'override' rules are included after
compiler-family 'general' rules have been included. This allows a
central means for including dynamically generated content to
override some values.
Some examples:
To handle different gcc versions (system compiler):
wmake/rules/...Gcc/override
```
ifneq (,$(findstring 9, $(WM_COMPILER)))
cc := gcc-9
CC := g++-9 -std=c++11
endif
```
To handle different openmp on Darwin (#1656):
wmake/rules/darwin64Clang/override
```
# Use libomp (not libgomp) unless openmp is disabled
ifeq (,$(findstring "~openmp", "$(WM_COMPILER)"))
COMP_OPENMP = -DUSE_OMP -Xpreprocessor -fopenmp
LINK_OPENMP = -lomp
else
include $(GENERAL_RULES)/no-openmp
endif
```
This treatment arguably fits into wmake/rules/darwin64Clang/general,
but it serves to illustrate a possible use case.
- missed detection of system libraries when installed with multiarch
paths like /usr/lib/x86_64-linux-gnu
CONFIG: improve handling of group/user config files (#928)
- changed bashrc handling of FOAM_CONFIG_NOUSER to use
FOAM_CONFIG_MODE instead. Propagate into foamEtcFile to make this
a stickier control.
This change allows better control, but also enables cluster
installations to define their own value within the OpenFOAM prefs.sh
file to prevent users accidentally mis-configuring things if
necessary.
- remove undocumented handling of an (a)ll mode in foamEtcFile to
avoid potential pitfalls.
- add support for FOAM_CONFIG_ETC handling.
This allows injection of an extra search layer when finding
project etc files
ENH: improvements to foamConfigurePaths (#928)
- handle FOAM_CONFIG_ETC implicitly, or explicitly with the new
-etc option.
STYLE: more explicit wording in foamConfigurePaths usage (#1602)
- document that an absolute path (eg, -scotch-path) overrides/ignores
the equivalent ThirdParty setting (eg, -scotch)
- longer options -system-compiler and -third-compiler for -system
and -third, respectively. Clearer as to their purpose.
- adjust the location sanity check to look for META-INFO directory.
- '-c' option (as per shell), '-Dkey[=value]' option to provide
preferences via the command-line. For example,
etc/openfoam -DWM_COMPILER=Clang -int64 ./Allwmake -j -s -l
These can also be combined with other options. Eg,
etc/openfoam -DWM_COMPILER=Clang \
-c 'wmake -show-path-cxx -show-cxxflags'
- relocated from bin/tools/ => etc/ for easier access
- bin/tools/openfoam.in : for autoconfig-style installation
- Auto-detect if the shell script was executed with openfoam and
interpret accordingly.
Simple example,
--------------
#!/usr/bin/openfoam
cd "${0%/*}" || exit # Run -*-sh-*- from this dir
blockMesh
simpleFoam
--------------
Note it is NOT currently possible to provide any other parameters
this way. Eg,
`#!/usr/bin/openfoam -sp` (NOT)
This will either fail to run, or result in infinite recursion.
- incorrectly set BINARY format in the construction of the received
data (a side-effect of the parameter ordering).
Now use the same default parameters as IFstream and set the correct
filename subsequent to construction.
- the foamConfigurePaths script is quite simplistic and aggressive in
what it changes. This was particularly evident when using it to
change gcc/clang versions.
Restructured the corresponding compiler settings to define default
versions (eg, "default_gcc_version") that limits the scope of
changes performed by foamConfigurePaths and makes it easier to
understand if changing manually.
- the gcc c++/9 includes now inline strncpy, which obliterates
the previous method of suppressing the warning.
Now simply allocate additional space for the nul character.
COMP: silence some icc warnings
- indexing error in the output of values resulted in uniform output in
most cases.
- allocation error for on-the-fly triangulation
ENH: changed decomposed storage from DynamicList to plain faceList for
clearer allocation control and better overhead
Including `nu` in `DphitEff` even though it is not present in (LUU:Eq. 17)
provided higher level of resemblance to benchmarks for the tests considered,
particularly for the peak skin friction (yet, pressure-related predictions
were unaffected). Users can switch off `nu` in `DphitEff` by using
`includeNu` entry in `kEpsilonPhitFCoeffs` in order to follow the
reference paper thereat. `includeNu` is left `true` by default.
See GitLab issue #1560,
LUU: Laurence, D. R., Uribe, J. C., & Utyuzhnikov, S. V. (2005).
When more than one volumetric B-Splines control boxes are present, the
sensitivity constituents corresponding to the non-active design
variables were not bounded(zeroed) correctly. The resultant
sensitivities, used in the optimization, were bounded correctly, so this
was more a bug pertaining to the output file of the sensitivities rather
than a functional one.
When activeDesignVariables are not set explicitly, all design variables
are treated as active. These were allocated properly when starting from
0 but not when starting from an intermediate optimisation cycle
(e.g. running 5 optimisation cycles, stopping and restarting).
TUT: added a new tutorial including the restart of an optimisation run
to help identify future regression
The controlBoxes wordList was removed from NURBS3DVolume in the
pre-release phase but writeMorpherCPs was not updated accordingly.
TUT: added the invocation of writeMorpherCPs in one of the tutotials to
help identify future regression
- The core of the FatalIOError message was not printed due to exiting
with FatalError instead of FatalIOError
- Changed the TypeName in all derived classes of displacementMethod so
that the toc printed by the FatalIOError corresponds to what the user
should add in dynamicMeshDict
When a contact resistance is used the T field on each coupled
patch is different due to the thermal resistance. Thus, instead
of solving for a unique Tw at the wall, we solve for Tw1 at one side
then, the Tnbr internal becomes Tw2, which is the T of the nbr
patch.
Many possibilities:
- use as a simple calculator with vectors, tensors etc.
- test validity of expression syntax
As a calculator:
foamCalc '(vector(1,2,3) ^ vector(4,5,6)) * sqrt(34)'
The same, but with debugging:
foamCalc -debug-switch fieldExpr=6 \
'mag((vector(1,2,3) ^ vector(4,5,6))) * sqrt(34)'
- previously just reported gcc/clang versions, but these are not
necessarily the ones actually being used (eg, clang-9 vs clang).
Now use the path from `wmake -show-path-cxx` to improve the accuracy,
and also support other compiler types.
1) New skewCorrectedSnGrad for non-orthogonal and skewness corrector
2) New freeSurfacePressure and freeSurfacePressure working with
interfaceTrackingFvMesh
3) New interfaceTrackingFvMesh
- now use debug 2 for scanner and debug 4 for parser.
Provided better feedback about what is being parsed (debug mode)
- relocate debug application to applications/tools/foamExprParserInfo
See GL #1433
Applies corrections to turbulence kinetic energy equation and turbulence
viscosity field for incompressible multiphase flow cases.
Turbulence kinetic energy is over-predicted in VOF solvers at the phase
interface and throughout the water column in nearly-potential flow regions
beneath surface waves.
This fvOption applies corrections based on the references:
Buoyancy source term in turbulence kinetic energy equation:
Devolder, B., Rauwoens, P., and Troch, P. (2017).
Application of a buoyancy-modified k-w SST turbulence model to
simulate wave run-up around a monopile subjected to regular waves
using OpenFOAM.
Coastal Engineering, 125, 81-94.
Correction to turbulence viscosity field:
Larsen, B.E. and Fuhrman, D.R. (2018).
On the over-production of turbulence beneath surface waves in
Reynolds-averaged Navier-Stokes models
J. Fluid Mech, 853, 419-460
Example usage:
multiphaseStabilizedTurbulence1
{
type multiphaseStabilizedTurbulence;
active yes;
multiphaseStabilizedTurbulenceCoeffs
{
// Optional coefficients
lambda2 0.1; // A value of 0 sets the nut correction to 0
Cmu 0.09; // from k-epsilon model
C 1.51; // model coefficient from k-omega model
alpha 1.36; // 1/Prt
}
}
Thanks go to the Turbulence Technical Committee, and the useful discussions
with and code testing by Bjarke Eltard-Larsen and David Fuhrman (Technical
University of Denmark).
ENH: modify fWallFunction for kEpsilonPhitF model
The k-epsilon-phit-f turbulence closure model for incompressible and
compressible flows.
The model is a three-transport-equation linear-eddy-viscosity turbulence
closure model alongside an elliptic relaxation equation:
- Turbulent kinetic energy, \c k,
- Turbulent kinetic energy dissipation rate, \c epsilon,
- Normalised wall-normal fluctuating velocity scale, \c phit,
- Elliptic relaxation factor, \c f.
Reference:
\verbatim
Standard model (Tag:LUU):
Laurence, D. R., Uribe, J. C., & Utyuzhnikov, S. V. (2005).
A robust formulation of the v2−f model.
Flow, Turbulence and Combustion, 73(3-4), 169–185.
DOI:10.1007/s10494-005-1974-8
\endverbatim
The default model coefficients are (LUU:Eqs. 19-20):
\verbatim
kEpsilonPhitFCoeffs
{
Cmu 0.22, // Turbulent viscosity constant
Ceps1a 1.4, // Model constant for epsilon
Ceps1b 1.0, // Model constant for epsilon
Ceps1c 0.05, // Model constant for epsilon
Ceps2 1.9, // Model constant for epsilon
Cf1 1.4, // Model constant for f
Cf2 0.3, // Model constant for f
CL 0.25, // Model constant for L
Ceta 110.0, // Model constant for L
CT 6.0, // Model constant for T
sigmaK 1.0, // Turbulent Prandtl number for k
sigmaEps 1.3, // Turbulent Prandtl number for epsilon
sigmaPhit 1.0, // Turbulent Prandtl number for phit = sigmaK
}
\endverbatim
Note
The name of the original variable replacing 'v2' is 'phi' (LUU:Eq. 14).
However, the name 'phi' preexisted in OpenFOAM; therefore, this name was
replaced by 'phit'
qem and qin were not set to zero for the wideBand model BC.
qin was used in the grey model BC to calculate Ir(the total
incoming heat flux). As it is now set to zero, the grey model
loops over the incoming rays to calculate Ir instead of relaying
on qin stored in radiativeIntensityRay.
- follows the principle of least surprise if the expansion behaviour
for #eval and expressions (eg, exprFixedValue) are the same. This
is possible now that we harness the regular stringOps::expand()
within exprString::expand()
Adding check for p.active at the end of KinematicParcel::move.
p.hitFace() is called only for active parcels.
Setting to zero the initialization for stored lists of stick and
escape parcels
in LocalInteraction and StandardWallInteraction models
NOTE: KinematicParcel::hitPatch counts overall system escaped
parcels and mass based on polyPatch type and not on type of
patchInteractionModel. Thus, if a patch is a Wall for fluid
but escape for parcel the overall report will be wrong but
the local report for each patch is correct
- the PDRsetFields utility processes a set of geometrical obstructions
to determine the equivalent blockage effects.
These fields are necessary inputs for PDRFoam calculations.
After setting up the geometries, the -dry-run option can be used to
generate a VTK file for diagnosis and post-processing purposes.
- this is an initial release, with improvements slated for the future.
NOTE
- the field results may be less than fully reliable when run in
single-precision. This howver does not represent a realistic
restriction since the prepared fields target a combustion
application which will invariably be double-precision.
- locate where the user is less tempted to change it (#1515).
It really should be considered an invariant environment variable.
STYLE: wmake -help information to stdout, die errors to stderr
- The wmake -show-path-{c,cxx} options return the fully qualified
paths to the respective compilers. This can be useful when verifying
that the correct compiler is indeed configured.
- The -help-full to display the "advanced" options, but in the normal
case just show the basic options.
- reuse more of stringOps expansions to reduce code and improve the
syntax flexiblity.
We can now embed "pre-calculated" values into an expression.
For example,
angle 35;
valueExpr "vector(${{cos(degToRad($angle))}}, 2, 3)";
and the ${{..}} will be evaluated with the regular string evaluation
and used to build the entire expression for boundary condition
evaluation.
Could also use for fairly wild indirect referencing:
axis1 (1 0 0);
axis2 (0 1 0);
axis3 (0 0 1);
index 100;
expr "$[(vector) axis${{ ($index % 3) +1 }}] / ${{max(1,$index)}}";
- Failed due to double*Matrix<float> multiplication.
Style changes
- use SquareMatrix with Identity on construction
- use Zero in constructors
- remove trailing space and semi-colons
- skip processing OSspecific/MSwindows since this can cause duplicate
doxygen entries
STYLE: adjust formatting in code templates
STYLE: use std::string methods without extra qualifications
- ensure that the updateControl is "non-sticky" on re-read,
even if we do not support runtime-modifiable here
STYLE: add syntax example (wingMotion), but with updateInterval 1
- synchronize the scalar interval value with the integer version.
This ensures that the interval() method returns the correct
representative value.
- added clear() method to reset to 'always' (pass-through)
- ensure that the updateControl is "non-sticky" on re-read,
even if we do not support runtime-modifiable here
STYLE: add syntax example (wingMotion), but with updateInterval 1
The adjoint library is enhanced with new functionality enabling
automated shape optimisation loops. A parameterisation scheme based on
volumetric B-Splines is introduced, the control points of which act as
the design variables in the optimisation loop [1, 2]. The control
points of the volumetric B-Splines boxes can be defined in either
Cartesian or cylindrical coordinates.
The entire loop (solution of the flow and adjoint equations, computation
of sensitivity derivatives, update of the design variables and mesh) is
run within adjointOptimisationFoam. A number of methods to update the
design variables are implemented, including popular Quasi-Newton methods
like BFGS and methods capable of handling constraints like loop using
the SQP or constraint projection.
The software was developed by PCOpt/NTUA and FOSS GP, with contributions from
Dr. Evangelos Papoutsis-Kiachagias,
Konstantinos Gkaragounis,
Professor Kyriakos Giannakoglou,
Andy Heather
[1] E.M. Papoutsis-Kiachagias, N. Magoulas, J. Mueller, C. Othmer,
K.C. Giannakoglou: 'Noise Reduction in Car Aerodynamics using a
Surrogate Objective Function and the Continuous Adjoint Method with
Wall Functions', Computers & Fluids, 122:223-232, 2015
[2] E. M. Papoutsis-Kiachagias, V. G. Asouti, K. C. Giannakoglou,
K. Gkagkas, S. Shimokawa, E. Itakura: ‘Multi-point aerodynamic shape
optimization of cars based on continuous adjoint’, Structural and
Multidisciplinary Optimization, 59(2):675–694, 2019
- when using VTK from ParaView sources it can better to tag them as
such, but simultaneously not mask the ParaView with hardware
rendering.
The additional ParaView_MESA_DIR variable allows this.
The balance of library and path setup is unaffected by this.
DOC: update doc/BuildIssues
- `Pkt` was directed to `GName` to allow wall functions
are usable by kkLOmega model
- `Pkt` was changed to a non-const object, so that omegaWallFunc
can modify `Pkt` at the wall, if need be.
- Elementwise backward compatibility was checked by
pimpleFoam/RAS/ellipsekkLOmega
- New implementation was checked by changing omega:hole boundary
in pimpleFoam/RAS/ellipsekkLOmega to omegaWallFunction
QRMatrix (i.e. QR decomposition, QR factorisation or orthogonal-triangular
decomposition) decomposes a scalar/complex matrix \c A into the following
matrix product:
\verbatim
A = Q*R,
\endverbatim
where
\c Q is a unitary similarity matrix,
\c R is an upper triangular matrix.
Usage
Input types:
- \c A can be a \c SquareMatrix<Type> or \c RectangularMatrix<Type>
Output types:
- \c Q is always of the type of the matrix \c A
- \c R is always of the type of the matrix \c A
Options for the output forms of \c QRMatrix (for an (m-by-n) input matrix
\c A with k = min(m, n)):
- outputTypes::FULL_R: computes only \c R (m-by-n)
- outputTypes::FULL_QR: computes both \c R and \c Q (m-by-m)
- outputTypes::REDUCED_R: computes only reduced \c R (k-by-n)
Options where to store \c R:
- storeMethods::IN_PLACE: replaces input matrix content with \c R
- storeMethods::OUT_OF_PLACE: creates new object of \c R
Options for the computation of column pivoting:
- colPivoting::FALSE: switches off column pivoting
- colPivoting::TRUE: switches on column pivoting
Direct solution of linear systems A x = b is possible by solve() alongside
the following limitations:
- \c A = a scalar square matrix
- output type = outputTypes::FULL_QR
- store method = storeMethods::IN_PLACE
Notes
- QR decomposition is not unique if \c R is not positive diagonal \c R.
- The option combination:
- outputTypes::REDUCED_R
- storeMethods::IN_PLACE
will not modify the rows of input matrix \c A after its nth row.
- Both FULL_R and REDUCED_R QR decompositions execute the same number of
operations. Yet REDUCED_R QR decomposition returns only the first n rows
of \c R if m > n for an input m-by-n matrix \c A.
- For m <= n, FULL_R and REDUCED_R will produce the same matrices
- handle zero or negative values as being identical to 1.
As per timeStep control and what the comments suggested.
- drop old outputTime enumeration, since this is covered by the
writeTime enumeration and a corresponding Enum name.
- support construction of a "pass-through" control object that always
executes and add some method to test for these conditions and be able
to output some meaning full information.
Eg,
if (ctrl.execute())
{
if (!ctrl.always())
{
Info<< "Sampling executed based on " << ctrl.type() << nl;
}
...
}
To produce "Sampling executed based on runTime"
Calculates the acoustic power due to the volume of isotropic turbulence
using Proudman's formula
The acoustic power \f$ P_A \f$ [W/m3] in terms of turbulence \f$ k \f$
and \f$ \epsilon \f$ is given as:
\f[
P_A = alpha_\epsilon \rho \epsilon M_t^5
\f]
where \f$ alpha_\epsilon \f$ is a constant (0.1) and
\f[
M_t = \frac{\sqrt{2 k}}{a_0}
\f]
with \f$ a_0 \f$ the speed of sound. The acoustic power is also output in
dB using:
\f[
L_P = 10 \log \frac{P_A}{P_ref}
\f]
where \f$ P_ref \f$ is a constant (1e-12 W/m3)
Usage
Example of function object specification to calculate the Proudman acoustic
power
proudmanAcousticPower1
{
type proudmanAcousticPower;
libs ("libfieldFunctionObjects.so");
...
// Required additional entries for incompressible calculations
rhoInf 1.225;
aRef 340;
}
Where the entries comprise:
Property | Description | Required | Default value
type | type name: proudmanAcousticPower | yes |
rhoInf | Freestream density for incompressible cases | no |
aRef | Reference spped of sound for incompressible cases | no |
alphaEps | Model coefficient | no | 0.1
Note
- The freestream density and reference speed of sound are only necessary
when a thermodynamics package is unavailable, typically for incompressible
cases.
- Allows user-defined control of when the mesh motion occurs,
which can be especially useful in situations where the mesh motion
is much slower than any of the fluid physics.
For example, in constant/dynamicMeshDict:
updateControl runTime;
updateInterval 0.5;
to have mesh motion triggered every 1/2 second.
Note that the _exact_ time that the mesh motion actually occurs may
be slightly differently since the "runTime" triggering is fuzzy in
nature. It will trigger when the threshold has been crossed, which
will depend on the current time-step size.
- The -Wno-deprecated-copy flag for gcc-9.2.0
In the future we may indeed wish to explicitly request default
generated constructors and assignment operators, but at the moment
these are still acceptable.
- The -Wno-alloc-size-larger-than flag for mingw compilations
Related to differences in PTRDIFF_MAX vs SIZE_MAX on the target.
Several issues related to this can be found in the gcc bug reports
and on stackoverflow etc.
COMP: delay evaluation of fieldToken enumeration types
- lazy evaluation at runTime instead of compile-time to make the code
independent of initialization order.
Otherwise triggers problems on gcc-4.8.5 on some systems where
glibc is the same age, or older.
Feature particle patch postpro filtering
### Summary
Adds options to write particle-patch interactions to file, and to select particle fields to post-process for the `patchPostProcessing` cloud function object
### Resolved bugs (If applicable)
none
### Details of new models (If applicable)
Cloud patch interaction models:
Optionally write patch interaction statistics, e.g. number and mass of particles that stick, escape etc. to file using the optional `writeToFile` entry, e.g.
```
localInteractionCoeffs
{
patches
(
"(walls|cyc.*)"
{
type rebound;
}
"inlet|outlet"
{
type escape;
}
);
// New optional entry
writeToFile yes;
}
```
Cloud function objects:
New `fields` optional entry can be used to select which particle fields to post-process; if empty or the entry is not given all fields are written (to provide backwards compatibility)
```
patchPostProcessing1
{
type patchPostProcessing;
// Optional new entry
fields (position "U.*" d T nParticle);
maxStoredParcels 20;
patches
(
cycLeft_half0
cycLeft_half1
);
}
```
See the `$FOAM_TUTORIALS/lagrangian/reactingParcelFilm/filter` tutorial for an example
### Risks
Low risk
See merge request Development/openfoam!301
Feature expressions
### Summary
This branch represents an implementation of what is considered to be the most useful aspects of swak4Foam ([Swiss-Army-Knife for FOAM](https://openfoamwiki.net/index.php/Contrib/swak4Foam)) from Bernhard Gschaider, namely the ability to use text-based expressions instead of coding in C++ for the following cases:
- expression-based boundary conditions (also known as _groovy_ boundary conditions)
- expression-based setFields (also known as _funky_ set fields)
The idea of what we currently term *expressions* was pioneered by
(Bernhard Gschaider) and is now firmly established in `swak4Foam`.
Among other things, expressions attempt to bridge the gap between
using standard, predefined boundary conditions and writing dedicated,
special-purpose ones. Although part of this gap is now covered within
OpenFOAM by using dynamically compiled user coding (eg, coded boundary
conditions), there remains substantial areas where it can be
significantly more convenient to have a series of predefined functions
and expression sytax with some access to base OpenFOAM field
functionality that enables rapid deployment of boundary conditions, or
custom-defined `setFields` without writing code.
A significant portion of `swak4Foam` expressions has been adapted for
direct integration into OpenFOAM. During the integration and rewrite,
we have tried to pare things down to a smaller subset with the aim of
covering 90% or more of the common cases. The remaining cases are left
to be reassessed for extending the *expressions* functionality in the
future, but they also may be better served with other approaches (eg,
with coded conditions) that were not available when `swak4Foam` was
originally conceived.
To the greatest extent possible, the integrated *expressions* have
been designed to avoid name clashes with `swak` so it should remain
possible to use the most recent versions of `swak` without problem.
### Risks
- New functionality, so low chance of regression.
- The scope of the functionality will be revised in the future
### Naming (for `swak4Foam` users)
The following are the *expressions* correspondences to `swak`:
- The `exprFixedValue` and `exprGradient` boundary conditions are
roughly equivalent to the _groovy_ boundary conditions.
- The utilities `setExprFields` and `setExprBoundaryFields` are
roughly equivalent to the _funky_ utilities of similar name.
The naming of the boundary conditions and utilities not only reflects
the slightly different input requirements, but simultaneously seeks to
avoid any potential name-clash with `swak4Foam` in a mixed
environment.
The names for the boundary condition dictionary entries tend be
shorter and slightly different (eg, `valueExpr` vs `valueExpression`)
to serve as a small reminder that the *expressions* syntax is slightly
different than the *groovy* equivalents. It also allows the user to
fashion dictionary entries that are sufficient for **both** boundary
condition variants and quickly toggle between them simply by changing
the boundary condition `type`.
See merge request Development/openfoam!300
Limits fields to user-specified min and max bounds
Usage
Example of function object specification:
limitFields1
{
type limitFields;
libs ("libfieldFunctionObjects.so");
...
fields (U);
limit max;
max 100;
}
Where the entries comprise:
Property | Description | Required | Default
type | type name: limitFields | yes |
fields | list of fields to process | yes |
limit | bound to limit - see below | yes |
min | min limit value | partly |
max | max limit value | partly |
The "limit" entry can take the value:
- min : specify a minimum value
- max : specify a maximum value
- both : specify a minimum value and a maximum value
The optional 'fields' entry can be used to limit which particle fields are
written to file. If empty/not specified, all properties are written to
maintain backwards compatibility.
patchPostProcessing1
{
type patchPostProcessing;
maxStoredParcels 20;
fields (position "U.*" d T nParticle);
patches
(
cycLeft_half0
cycLeft_half1
);
}
- replace stringOps::toScalar with a more generic stringOps::evaluate
method that handles scalars, vectors etc.
- improve #eval to handle various mathematical operations.
Previously only handled scalars. Now produce vectors, tensors etc
for the entries. These tokens are streamed directly into the entry.
This condition applies a scalar multiplier to the value of another
boundary condition.
Usage
Property | Description | Required | Default value
scale | Time varing scale | yes |
patch | patchField providing the raw patch value | yes |
Example of the boundary condition specification to scale a reference
velocity of (15 0 0) supplied as a fixedValue by a table of values
that ramps the scale from 0 to 1 over 1 second:
<patchName>
{
type scaledFixedValue;
scale table
(
( 0 0)
( 1.0 1.0)
(100.0 1.0)
);
patch
{
type fixedValue;
value uniform (15 0 0);
}
}
- The previous option 'write-nut' controlled the writing of turbulence
nut, but other turbulence fields were always written.
These have been shown to be a source of instability for many cases.
This commit replaces the 'write-nut' option by a 'writeTurbulenceFields'
option that controls the writing of all turbulence fields.
If not set, only the velocity field is written.
For compatibility, the old 'write-nut' option is still recognized
but is redirected to 'writeTurbulenceFields'.
Set the m4 -I include accordingly to have the folllowing:
- the directory of the parser.
- include/ in the top-level source tree of the current target
(eg, src/finiteVolume/include-m4/ when compiling libfiniteVolume)
- include/ from OpenFOAM
Additional -dry-run option for makeParser, wrap-lemon for expanding m4
only.
Extend m4 wrapping support to include bison as well.
- include the trailing newline for the "// comment" form, but also add
in leading space removal. This ensure that we do not introduce odd
indentation, while also eliminating lines that are solely C++
comments.
- output the "uniform", "nonuniform" Field entry tags as words instead
of raw character strings, which can help for direct tokenization or
when sending/receiving via Pstreams.
- some support for "uniform" bool fields. Calculating an averaged
value for a boolField does not work very well, but we simply define
that the field average is 'true' when more than 1/2 of its values
are true. Not exactly true, but allows templated definitions to work
smoothly.
- additional output method writeValue().
This outputs the single (uniform) value or the first value of the
field.
- ITstream append() would previously have used the append from the
underlying tokenList, which leaves the tokenIndex untouched and
renders the freshly appended tokens effectively invisible if
interspersed with primitiveEntry::read() that itself uses tokenIndex
when building the list.
The new append() method makes this hidden ITstream bi-directionality
easier to manage. For efficiency, we only append lists
(not individual tokens) and support a 'lazy' resizing that allows
the final resizing to occur later when all tokens have been appended.
- The new ITstream seek() method provides a conveniently means to move
to the end of the list or reposition to the middle.
Using rewind() and using seek(0) are identical.
ENH: added OTstream to output directly to a list of tokens
---
BUG: List::newElem resized incorrectly
- had a simple doubling of the List size without checking that this
would indeed be sufficient for the requested index.
Bug was not triggered since primitiveEntry was the only class using
this call, and it added the tokens sequentially.
This adds automatic deletion of cells inside small gaps. This is
generally used to avoid having excessive numbers of cells in irrelevant
areas of a geometry. It is nearly the opposite of automatic gap refinement
- that refines cells to resolve the gap; this functionality removes cells
to not mesh the gap.
The proximity handling will remove those cells which are inside 'thin' gaps
where 'thin' is defined as a distance of 2*'blockLevel'
It will
- detect surfaces which have the new 'blockLevel' specification
- convert this to a minimum gap distance
- detect cells which are inside this gap
- remove these cells and add exposed faces to the nearest 'real' patch
- The case files may contain #... comment lines
- The geometry file may contain an optional "extents" entry
- Properly handle element id specifications (off|assign|ignore|given).
- Partially handle node id specifications (off|assign|ignore|given).
Treat "given" like "ignore", since results in the lightest amount of
coding and in many cases the "given" node ids are in fact 1-based
contiguous values and thus no different than "ignore" for our
purposes.
- allows use of Enum in more situations where a tiny Map/HashTable
replacement is desirable. The new methods can be combined with
null constructed for to have a simple low-weight caching system
for words/integers instead of fitting in a HashTable.
ENH: downgrade error on type-mismatch to a warning
- Ensight data files generated by OpenFOAM will start with the name of
the data type (Eg, "scalar", "vector" etc), but this convention may
fail for data files that have been generated elsewhere.
- since pointPatchField is not derived from Field, methods such as
negate() or a unary min(), max() are missing.
These have apparently not been needed thus far, but are used
indirectly via GeometricField.
- improves similarity to autoPtr. Simplifies coding.
Example,
tmp<volScalarField> tfield;
// sometime later...
tfield.reset
(
volScalarField::New("myfield", mesh, dimensionedScalar(Zero))
);
- as per tmp, disallow tmpNrc assignment from literal nullptr
- as per autoPtr, allow explicit test as bool (same as valid).
- can be useful when a scalarField has been used to store booleans and
we need to recover a bool directly and deal with potential rounding
issues.
ENH: support "any" as a Switch counterpart to "none"
- now indicate that the dictionary entry is missing, not that it is
an unknown function type.
STYLE: adjust PatchFunction1New.C to have logic structure look similar
- save in META-INFO/build-info for later re-compilation without git.
This improves tracking beyond simply referring to the the patch level.
The information is tagged with an underscore to distinguish from
"real" build information when git is available.
STYLE: improved shell syntax, pushd/popd guards etc.
- Previously, the default mapping method was `planarInterpolation` which was
silently suppressed by the default 'interpolate{R,U,L}=false'.
STYLE: changes:
`0` to `Zero`,
`lookupOrDefault` to `getOrDefault`
improves header documentation
- silently deprecate 'startsWith', 'endsWith' methods
(added in 2016: 2b14360662), in favour of
'starts_with', 'ends_with' methods, corresponding to C++20 and
allowing us to cull then in a few years.
- handle single character versions of starts_with, ends_with.
- add single character version of removeEnd and silently deprecate
removeTrailing which did the same thing.
- drop the const versions of removeRepeated, removeTrailing.
Unused and with potential confusion.
STYLE: use shrink_to_fit(), erase()
Example - create p-rgh from p:
pressure-p-rgh
{
type pressure;
libs (fieldFunctionObjects);
writeControl writeTime;
mode static;
rho rhoInf;
rhoInf 1;
hydrostaticMode subtract;
g (0 -9.81 0);
hRef 0;
}
- the hydrostaticMode entry is optional - setting is shown during construction
- g and/or hRef values are retrieved from the database if not specified
- This scheme is useful to calculate the face interpolation values for
the Gauss gradient when the diffussion coefficient is discontinuous
across a face. This sheme is used for Gauss grad.
- foamExec was removed as part of commit 6c68c34e1a but
overlooked the fact that it is partly still needed by foamJob.
When running in parallel, it is used to source the etc/bashrc env.
Reinstated a stripped down form, which has been relocated to
bin/tools directory (it should not be directly called by the user).
The previous version switching functionality has nonetheless be
dropped since it only worked only when a rigid naming convention for
OpenFOAM installations was followed.
ENH: add foamJob log=, -log-app, -no-log options, improved coding quality
- use sed instead of foamDictionary and avoid log file
- ensure consistent behaviour with plot script
GIT: added missing 0/k field : inlet values still need adjustment
- can be helpful, for example, when the refCast has been used on a
boundary patch. Knowing which patch index triggered the problem
helps with isolating the issue.
For example,
$ someSolver -info-switch writeOptionalEntries
- note that values changed via the command-line are changed after the
etc/controlDict entries, but *before* any case-local
system/controlDict entries.
However, in many testing cases the command-line options eliminate
the need for such local file modifications.
ENH: cleanup handling of local debug switches in Time
- add as methods directly on simpleObjectRegistry to avoid code
duplication
STYLE: adjust internal naming of ITstream parameters
- now reports the dictionary, entry, default. For example,
Dictionary: <case>/0/nut.boundaryField.wall Entry: Cmu Default: 0.09
Dictionary: <case>/0/nut.boundaryField.wall Entry: kappa Default: 0.41
Dictionary: <case>/0/nut.boundaryField.wall Entry: E Default: 9.8
- suppress reporting for debug, optimisation switches since this
generates extremely noisy output
- Now accept '/' when reading variables without requiring
a surrounding '{}'
- fix some degenerate parsing cases when the first character is
already bad.
Eg, $"abc" would have previously parsed as a <$"> variable, even
although a double quote is not a valid variable character.
Now emits a warning and parses as a '$' token and a string token.
- add toScalar evaluation, embedded as "${{EXPR}}".
For example,
"repeat ${{5 * 7}} times or ${{ pow(3, 10) }}"
- use direct string concatenation if primitive entry is only a string
type. This prevents spurious quotes from appearing in the expansion.
radius "(2+4)";
angle "3*15";
#eval "$radius*sin(degToRad($angle))";
We want to have
'(2+4)*sin(degToRad(3*15))'
and not
'"(2+4)"*sin(degToRad("3*15"))'
ENH: code refactoring
- refactored expansion code with low-level service routines now
belonging to file-scope. All expansion routines use a common
multi-parameter backend to handle with/without dictionary etc.
This removes a large amount of code duplication.
- add floor/ceil/round methods
- support evaluation of sub-strings
STYLE: add blockMeshDict1.calc, blockMeshDict1.eval test dictionaries
- useful for testing and simple demonstration of equivalence
- SubField and SubList assign from zero
- SubField +=, -=, *=, /= operators
- SubList construct from UList (as per SubField)
Note: constructing an anonymous SubField or SubList with a single
parameter should use '{} instead of '()' to avoid compiler
ambiguities.
- drop plugin support for Qt4 (old paraview)
- handle upcoming changes in VTK version naming in CMake files
* VTK_MAJOR_VERSION becomes VTK_VERSION_MAJOR etc.
- Improves header file documentations
- Adds const specifier to various objects
- Allows various model constants to be user-defined
- Changes from lookupOrDefault() to getOrDefault()
- Consistent namespace usage:
- If the WF belongs to only Foam:: namespace, use Foam:: explicitly
- If the WF belongs to more than one namespaces, put the WF in namespace
parentheses
- Adds the missing dashes in comments required by Doxygen
- Corrects capitalisation in comments
- The terminology 'viscous sublayer' was preferred over 'laminar sublayer'
due to the fact that the sublayer is not laminar.
- The order of initialisation of fields is changed to be the same across all.
OpenFOAM.org commits for
src/TurbulenceModels/turbulenceModels/derivedFvPatchFields/wallFunctions
were reviewed.
The parts of the commits made by OpenFOAM.org removing various code
duplications across wall functions were picked up by keeping the remaining
functionalities the same.
The duplications were mainly due to:
- wall function model coefficients
- yPlusLam(), checkPatch(), write() methods
The duplications were united under the base nutWallFunction.
- since a zero-sized FixedList is disallowed, the accessors to the
first/last elements are always known.
This allows Pair second() to be noexcept as well (as per Tuple2)
- the #eval directive is similar to the #calc directive, but for evaluating
string expressions into scalar values. It uses an internal parser for
the evaluation instead of dynamic code compilation. This can make it
more suitable for 'quick' evaluations.
The evaluation supports the following:
- operations: - + * /
- functions: exp, log, log10, pow, sqrt, cbrt, sqr, mag, magSqr
- trigonometric: sin, cos, tan, asin, acos, atan, atan2, hypot
- hyperbolic: sinh, cosh, tanh
- conversions: degToRad, radToDeg
- constants: pi()
- misc: rand(), rand(seed)
- previously allowed mapped value modification with a const iterator.
However, this can lead to incorrect access patterns.
Now tie the constness of the mapped value to that of the iterator.
- Remove deprecated iterator object() method.
Was only used internally and was superseded by the val() method
in an earlier version.
ENH: change isPointer to isPointerLike
- can distinguish between real pointers and wrapped pointers
- this largely reverts 3f0f218d88 and 4ee65d12c4.
Consistent addressing with support for wrapped pointer types (eg,
autoPtr, std::unique_ptr) has proven to be less robust than desired.
Thus rescind HashTable iterator '->' dereferencing (from APR-2019).
- for special cases when normal writing is to be completely disabled
and replaced with alternate means (eg, via a function object).
- support "adjustable" as "adjustableRunTime" alias to reduce typing
for writeControl or outputControl
- use HashTable emplace instead of insert to avoid unneeded argument
(for HashSet).
- use emplace when generating zero-initialized values for
HashTable::operator()
- drop unused parameter from Detail::HashTableSingle,
adjust templates parameter names
- forward HashTable::operator[] to the semantically identical
HashTable::at() to avoid code duplication
- call also be used non-interactively for simple 'one-shot' use of
OpenFOAM utilities or solvers
STYLE: use dash instead of brackets for '- see www.OpenFOAM.com'
- less cluttered in combination with API information
- now maintains a correct list of geometry instances, without assuming
contiguous file numbering. However, if the numbering is contiguous,
the more compact case representation will be used.
- an advanced feature, for example when sampling on a static patch
while some motion occurs elsewhere. [use with caution]
- If the sampled surface dictionary is modified during run-time, the
ensight file indexing for the geometry will become out of sync.
This is addressed in a subsequent commit.
- this can be useful for preloading of libraries, or for utilities
that don't use system/controlDict.
The additional libraries can be specified individually:
myUtil -lib lib1 -lib lib2 -lib lib3
When specified like this, the options add up.
Or as a 'captured' list using OpenFOAM's standard arg list handling:
myUtil -lib '(' lib1 lib2 lib3 ')'
myUtil -lib \( lib1 lib2 lib3 \)
or as single argument list:
myUtil -lib '("lib1" "lib2" "lib3")'
When specified as a single argument, would normally take advantage
of the transparent handling of word vs fileName and omit the string
quotes:
myUtil -lib '(lib1 lib2 lib3)'
ENH: dlOpen error messages now propagated into dlLibraryTable
- this makes the context more relevant and also avoids the previous
annoyance of double warnings (one from the POSIX loader, and one
from dlLibraryTable)
STYLE: mark -noFunctionObjects and -withFunctionObjects as 'advanced'
- reduces clutter. Still visible with -help-full
- add additional rule (ending '.ll') for the combination of
flex for C-code but compiling the result as C++.
This can be needed for re-entrant parsers.
- update bison rule to handle renaming of skeleton files.
Use a wrap-bison script to manage this.
- relax casting rules
* down-cast of labelToken to boolToken
* up-cast of wordToken to stringToken.
Can use isStringType() test for word or string types
- simplify constructors, move construct etc.
- expose reset() method as public, which resets to UNDEFINED and
clears allocated storage etc.
DEFEATURE: remove assign from word or string pointer.
- This was deprecated 2017-11 and now removed.
For this type of content transfer, move assignment should be used
instead of stealing pointers.
1) Add softWall rigidBody restrain
2) Add linearSpringDamper sixDoF restrain to work as soft rope
3) dynamicMotionSolverListFvMesh changed to dictionary based input
4) Add Time reference access to sixDof restraints
5) Add drivenLinearMotion to solidBodyMotionFunctions.
- synchronization, reduction only makes sense on processor-coupled
patches. Since cyclic baffles are within a single processor domain,
they are not reduced. So need to skip the sanity test for these.
- the use of 'paraview --version' can be fail if the build host
doesn't have the necessary graphics. For this case, try to obtain
the ParaView API number from the associated include directory.
- the read offset missed the tag_ member entirely and thus the entire
particle information would be corrupt (incorrectly interpreted) as
well as potential violation of adjacent (trailing) memory locations.
- allows some internal handling for reading dissimilar storage types.
Eg, scalars written as float (WM_SP), but read as double (WM_DP)
- reading binary parcel coordinates with dissimilar storage types is
still pending
- change contiguous from a series of global functions to separate
templated traits classes:
- is_contiguous
- is_contiguous_label
- is_contiguous_scalar
The static constexpr 'value' and a constexpr conversion operator
allow use in template expressions. The change also makes it much
easier to define general traits and to inherit from them.
The is_contiguous_label and is_contiguous_scalar are special traits
for handling data of homogeneous components of the respective types.
- in addition to m() and n(), provide Matrix mRows()/nRows(), nCols()
methods. These provide unambiguous access names.
'mRows()' == for internal consistency with MatrixSpace.
'nRows()' == a commonly used naming.
- with 1906, OpenFOAM is purely C++ code and the last toolchain bits C
code have been avoided. Thus relax the wmake C rule for including
WM_COMPILE_OPTION. This makes it much easier to add different
compiler options with fewer files.
For example, for Broadwell-specific options:
cd wmake/rules/linux64Gcc
cp c++Opt c++OptBdw
edit this file and then use WM_COMPILE_OPTION=OptBdw
- ensure that WM_COMPILE_OPTION is always non-empty
- a top-level cloud::nParcels() virtual, which is overloaded by the
first level of Cloud inheritance. This permits quick determination of
cloud sizes, even when retrieved from registry with the base level.
Eg,
cloud* cldPtr = mesh.cfindObject<cloud>("myCloud");
label nParcels = (cldPtr ? cldPtr->nParcels() : 0);
- make writeLagrangianPositions on by default unless explicitly
disabled in the InfoSwitches.
Flag output errors (where neither coordinates nor positions are
written) with Fatal.
- additional IOField helper functions in cloud
STYLE: simplify iterator inheritance
- can now specify literal matches for sub-dictionary methods:
isDict(key, keyType::REGEX)
optionalSubDict(key, keyType::REGEX)
subDict(key, keyType::REGEX)
subOrEmptyDict(key, keyType::REGEX, mandatory)
There is no change in behaviour of the methods, just the search option
is now exposed as an optional parameter.
NOTE: minor breaking change for subOrEmptyDict()
old: subOrEmptyDict(key, bool=false)
new: subOrEmptyDict(key, keyType::option=keyType::REGEX, bool=false)
This affects code that previously explicitly set the bool parameter.
Within OpenFOAM itself, this only affected a single file:
KinematicCloud.C
- this is principally for cases where reduced indentation is desired,
such as when streaming to a memory location. If the indentation size
is zero or one, only a single space will be used to separate the
key/value.
This change does not affect the stream allocation size, since the
extra data falls within the padding.
ENH: relocate label/scalar sizes from Istream to IOstream.
- could allow future use for output streams as well?
Due to padding, reorganization has no effect on allocated size
of output streams.
STYLE: add read/write name qualifier to beginRaw, endRaw
- removes ambiguity for bi-directional streams
STYLE: fix inconsistent 'const' qualifier on std::streamsize
- base Ostream was without const, some derived streams with const
- allows full recovery of allocated space, not just addressable range.
This can be particularly useful for code patterns that repeatedly
reuse the same buffer space. For example,
DynamicList<char> buf(1024);
// some loop
{
OListStream os(std::move(buf));
os << ...
os.swap(buf);
}
Can read back from this buffer as a second operation:
{
UIListStream is(buf);
is >> ...
}
- When building OpenFOAM for different platform combinations
(single/double, int32/int64) the build information that is compiled
into the OpenFOAM lib can become out of sync.
This is because the update trigger (wmakeBuildInfo -check) is
independent of the targetted platform. The added file
'src/OpenFOAM/Alltouch' provides a direct means of forcing a rebuild
of the version information. Eg,
src/OpenFOAM/Alltouch
wmake src/OpenFOAM
Also provide an additional 'wmakeBuildInfo -remove' to forcibly
remove META-INFO/build-info, if that is desired.
- symmetric with writeRaw() etc for the output stream. These are
methods that are not required by normal users, but which provide
a finer granularity for reading.
- additional information about the current stream position when
endList fails. This may help when tracing errors.
STYLE: change return type of beginRaw()/endRaw() to bool
- was of type Ostream& for output, but return value was unused.
Having bool may be better for encapsulating logic
STYLE: remove unused Istream::readEndBegin() function
- in InterfaceCompositionPhaseChangePhaseSystem, the mass transfer
rates are updated as a side-effect of the massTransfer() method,
which makes these fields non-const.
- adapted openfoam.org code. Original commit message:
Instead of adapting tet base points cell-by-cell, the dangling
points are pre-computed and then the adaptations to the base points
are made face-by-face. This correctly adapts faces which have
different dangling points relative to the owner and neighbour cells.
- treat the faces that would be exposed on a subset as boundary faces
for the erosion algorithm
STYLE: adjust code for consistency between isoSurfaceCell and isoSurfaceTopo
- the behaviour of std::rename with overwriting an existing file is
implementation dependent:
- POSIX: it overwrites.
- Windows: it does not overwrite.
- for Windows need to use the ::MoveFileEx() routine for overwriting.
More investigation is needed for proper handling of very long names.
- this cannot be left as a configurable value (on windows), since it
needs to be enabled even prior to reading the etc/controlDict file,
in case the OpenFOAM installation path itself contains spaces.
- add an 'isoAlgorithm' keyword to distance surface and cutting plane
to advance further testing of the isoSurfaceTopo algorithm.
Does not yet handle the full spectrum of bound boxes, cellZones etc.
- unfriend HashSet, HashTable IO operators
- global min(), max(), minMax() functions taking a labelHashSet and an
optional limit. For example,
labelHashSet set = ...;
Info<< "min is " << min(set) << nl;
Info<< "max (non-negative) " << max(set, 0) << nl;
- make HashTable iterator '->' dereferencing more consistent by also
supporting non-pointer types as well.
- read HashTable values in-situ to avoid copying
- the Enum::readEntry() method was previously as bit sloppy with
respect to the enumeration that it accepted. If the input was
non-mandatory, typos would go unnoticed. Now tighten things so that
if an enumeration is found, it must also be valid.
STYLE: remove unused/deprecated Enum::lookupOrFailsafe() method
- this was only used in a few places internally in 1712 and 1806 but
has since then been superseded by getOrDefault() with an optional
'failsafe' flag.
- An identity is often useful when generating connectivity and offset
information.
- The optional repeat value for vtk::write() allows it to also be used
as a fill method.
- when searching for a file that may not actually exist,
the short-cut optimization could lead to the 'constant' directory
being ignored.
STYLE: simplify logic in points0MotionSolver::points0IO
- the scotch interface still uses non-const pointers when passing in
values. For the ConstPrecisionAdaptor this means that we need to cheat
with a constCast(). Using ref() will rightly trigger complaints about
trying to modify a const object.
Modifications to help avoid inadvertent overwriting of tutorialsTest:
- new '-force' option to overwrite existing directory
- generate a 'tutorialsTest/Alltest' script that disallows the
possibilty of self-recursion
- reverse mapping for the original point ids. This can be useful
when searching a subset of points, but needing to store access to
the original point index.
- move constructor.
- Allow use/not-use subset as an optional constructor argument for
more convenient caller logic.
- changed for 1906 to have a regIOobject always cleanup its
objectRegistry entry. No need to explicitly 'release' ownership
for this to now happen.
- doxygen formatting for MeshObject
- add a '-SPDP' option
- remove the '-archOption' for forcing a '-m32' build on 64-bit
architecture, which is now considered too obscure.
Must edit files manually if this option is really required.
The following three synthetic turbulence inflow boundary conditions are
examined through single-cell-domain smooth-wall plane channel flow setup:
- turbulentDFSEMInlet
- turbulentDigitalFilterInlet variant=digitalFilter
- turbulentDigitalFilterInlet variant=reducedDigitalFilter
The examinations are performed in terms of the first-/second-order turbulence
statistics provided by (Moser et al., (1999)) doi.org/10.1063/1.869966
from smooth-wall plane channel flow direct numerical simulations at Re=395.
Serial executing:
./Allrun
Parallel (decompositionMethod=scotch) executing:
./Allrunparallel
A set of libraries and executables creating a workflow for performing
gradient-based optimisation loops. The main executable (adjointOptimisationFoam)
solves the flow (primal) equations, followed by the adjoint equations and,
eventually, the computation of sensitivity derivatives.
Current functionality supports the solution of the adjoint equations for
incompressible turbulent flows, including the adjoint to the Spalart-Allmaras
turbulence model and the adjoint to the nutUSpaldingWallFunction, [1], [2].
Sensitivity derivatives are computed with respect to the normal displacement of
boundary wall nodes/faces (the so-called sensitivity maps) following the
Enhanced Surface Integrals (E-SI) formulation, [3].
The software was developed by PCOpt/NTUA and FOSS GP, with contributions from
Dr. Evangelos Papoutsis-Kiachagias,
Konstantinos Gkaragounis,
Professor Kyriakos Giannakoglou,
Andy Heather
and contributions in earlier version from
Dr. Ioannis Kavvadias,
Dr. Alexandros Zymaris,
Dr. Dimitrios Papadimitriou
[1] A.S. Zymaris, D.I. Papadimitriou, K.C. Giannakoglou, and C. Othmer.
Continuous adjoint approach to the Spalart-Allmaras turbulence model for
incompressible flows. Computers & Fluids, 38(8):1528–1538, 2009.
[2] E.M. Papoutsis-Kiachagias and K.C. Giannakoglou. Continuous adjoint methods
for turbulent flows, applied to shape and topology optimization: Industrial
applications. 23(2):255–299, 2016.
[3] I.S. Kavvadias, E.M. Papoutsis-Kiachagias, and K.C. Giannakoglou. On the
proper treatment of grid sensitivities in continuous adjoint methods for shape
optimization. Journal of Computational Physics, 301:1–18, 2015.
Integration into the official OpenFOAM release by OpenCFD
- now only needed when specify compiling -m32 on a 64-bit system.
Internally use the __SIZEOF_LONG__ compiler macro (gcc, icc, llvm)
to define when long is actually an int32_t.
- remove make target for wmdep (flex-based scanner), which eliminates
a bootstrap dependency on flex.
As of OpenFOAM-v1806, wmdep has been superseded by wmdepend
(ragel-based scanner).
- replace dirToString binary with shell/awk equivalent for simpler
maintenance. The utility is very rarely used (auto scanning to
create Make/files) so there is no performance difference.
Integration of VOF MULES new interfaces. Update of VOF solvers and all instances
of MULES in the code.
Integration of reactingTwoPhaseEuler and reactingMultiphaseEuler solvers and sub-models
Updating reactingEuler tutorials accordingly (most of them tested)
New eRefConst thermo used in tutorials. Some modifications at thermo specie level
affecting mostly eThermo. hThermo mostly unaffected
New chtMultiRegionTwoPhaseEulerFoam solver for quenching and tutorial.
Phases sub-models for reactingTwoPhaseEuler and reactingMultiphaseEuler were moved
to src/phaseSystemModels/reactingEulerFoam in order to be used by BC for
chtMultiRegionTwoPhaseEulerFoam.
Update of interCondensatingEvaporatingFoam solver.
- overload the ref() method to allow modification of the referenced
(non-const) field directly. Same as constCast(), but less typing
and less prone to error.
- construct ConstPrecisionAdaptor from tmp for improved efficiency.
- the updated surface writers must be explicitly tagged as being
Time-aware (useTimeDir) to have them splice Time (in this case freq)
into the output path.
The older writers worked in the opposite way. They extracted a time
value from the naming of the output directory (which was fragile).
- If applied:
This commit allows the user to compute:
- the Lamb vector (https://en.wikipedia.org/wiki/Lamb_vector),
- on-the-fly or via postProcess utility
- for a given volVectorField (one per functionObject entry)
- Why:
The motivation is the literature-reported quantitative connection
between the Lamb vector (divergence) and the spatially localised
instantaneous fluid motions, e.g. high- and low-momentum fluid
parcels, which possess considerable level of capacity to affect
the rate of change of momentum, and to generate forces such as drag.
- Verification:
- Smooth-wall plane channel flow case (Moser et al. 1999) by
# Curtis et al. (2008) On the Lamb vector divergence
in Navier–Stokes flows, doi:10.1017/S0022112008002760
- What's next:
- The verification-show case
- Extended code guide entry titled "Lamb vector"
- remove registration and ownership before deleting a regIOobject
from within objectRegistry to avoid possible recursion.
- regIOobject destructor now removes any registered object from
registry regardless if ownedByRegistry or not. It also removes
always removes the ownership flag to avoid possible recursion.
- the regIOobject::checkOut() now unconditionally clears file watches.
These will only be there if the object is registered (a no-op for an
unregistered object), but this additional safety is needed to manage
case where the registration has been modified elsewhere (eg, by the
objectRegistry).
ENH: define addition/subtraction operations for scalar and complex
- required since construct complex from scalar is explicit
- additional tests in Test-complex
- forces c++DBUG='-DFULLDEBUG -g -O0' for the compilation, to allow
localized debugging during development without file editing and
while retaining the WM_COMPILE_OPTION (eg, Opt)
Note that switching between 'wmake' and 'wmake -debug' will not
cause existing targets to be rebuilt. As before, these are driven by
the dependencies. An intermediate wclean may thus be required.
- additional coefficients:
- Side force coefficient: direction in curl(lift,drag),
- Yaw moment coefficient: rotation axis in dir(lift)
- Roll moment coefficient: rotation axis in dir(drag)
Order of output
- forces(drag,side,lift)
- moments(roll,pitch,yaw)
Note
- For force coeffs, front and rear axles' contributions are computed
Calculates and outputs the pressure fields p_rgh and ph_rgh based on the
option that was previously hard-coded in the fireFoam solver
Usage
Example of function object specification to calculate hydrostatic pressure:
\verbatim
hydrostaticPressure1
{
type hydrostaticPressure;
libs ("libinitialisationFunctionObjects.so");
...
}
\endverbatim
Where the entries comprise:
\table
Property | Description | Required | Default value
log | Log to standard output | no | yes
p_rgh | Name of p_rgh field | no | p_rgh
ph_rgh | Name of ph_rgh field | no | ph_rgh
pRef | Name of pressure ref field | no | pRef
rho | Name of density field | no | rho
U | Name of velocity field | no | U
gh | Name of gravity*height volume field | no | gh
ghf | Name of gravity*height surface field | no | ghf
nCorrectors | Number of correctors when solving ph_rgh | no | 5
\endtable
Note
Calculates the hydrostatic pressure on construction/re-initialisation;
the execute and write functions are not used.
- generalize identity matrix constructors for non-scalar types
- add constructors using labelPair for the row/column sizing information.
For a SquareMatrix, this provides an unambiguous parameter resolution.
- reuse assignment operators
STYLE: adjust matrix comments
- adjust naming of quaternion 'rotationSequence' to be 'eulerOrder'
to reflect its purpose.
- provide rotation matrices directly for these rotation orders in
coordinateRotations::euler for case in which the rotation tensor
is required but not a quaternion.
Modified revert of commit 6c6f777bd5.
- The "alphaContactAngleFvPatchScalarField" occurs in several
places in the code base:
- as abstract class for two-phase properties
- in various multiphase solvers
To resolve potential linking conflicts, renamed the abstract class
as "alphaContactAngleTwoPhaseFvPatchScalarField" instead.
This permits potential linking of two-phase and multi-phase
libraries without symbol conflicts and has no effect on concrete
uses of two-phase alphaContactAngle boudary conditions.
- support move insert/set and emplace insertion.
These adjustments can be used for improved memory efficiency, and
allow hash tables of non-copyable objects (eg, std::unique_ptr).
- extend special HashTable output treatment to include pointer-like
objects such as autoPtr and unique_ptr.
ENH: HashTable::at() method with checking. Fatal if entry does not exist.
All remote contributions to interpolation stencils now
get added as 'processor' type lduInterfaces. This guarantees
a consistent matrix, e.g. initial residual is normalised to 1.
Second change is the normalisation of the interpolation discretisation
which uses the diagonal from the unmodified equation. This helps
GAMG.
- for codedFunctionObject and CodedSource the main code snippets
were not included in the SHA1 calculation, which meant that many
changes would not be noticed and no new library would be compiled.
As a workaround, a dummy 'code' entry could be used solely for the
purposes of generating a SHA1, but this is easily forgotten.
We now allow tracking of the dynamicCodeContext for the coded
objects and append to the SHA1 hasher with specific entries.
This should solve the previous misbehaviour.
We additionally add information about the ordering of the code
sections. Suppose we have a coded function object (all code
segments are optional) with the following:
codeExecute "";
codeWrite #{ Info<< "Called\n"; #};
which we subsequently change to this:
codeExecute #{ Info<< "Called\n"; #};
codeWrite "";
If the code strings are simply concatenated together, the SHA1 hashes
will be identical. We thus 'salt' with their semantic locations,
choosing tags that are unlikely to occur within the code strings
themselves.
- simplify the coded templates with constexpr for the SHA1sum
information.
- Correct the CodedSource to use 'codeConstrain' instead of
'codeSetValue' for consistency with the underlying functions.
- amalgamate dlSym() and dlSymFound() into a single dlSymFind() backend
with optional 'required' argument. This makes it possible to
query and assign at once.
- previously would have different SHA1 depending on whether the
string was a C-string, a C++-string or if the SHA1 was calculated
directly or via the OSHA1stream.
- SHA1("string")
- OSHA1stream << "string";
- OSHA1stream << string("string");
By avoiding string quoting on output, they now all deliver the same
result. This also means that the following will no longer change the SHA1
content, since it does not add anything:
osha<< string() << string() << string() << string();
This would have previously add a pair of double quotes each time!
- Eg, with surface writers now in surfMesh, there are fewer libraries
depending on conversion and sampling.
COMP: regularize linkage ordering and avoid some implicit linkage (#1238)
- in case of cell overlapping a patch : set cell to hole always
- in case of cell changing from hole to calculated: set to hole
and continue. Do so before 'flood filling' holes.
Patch supplied by Nicolas Edh.
- unnecessary. Can deduce labelRange from the pair of labels.
These are all the same:
list[labelRange(18,3)] = 100;
list[labelRange{18,3}] = 100;
list[{18,3}] = 100;
Removing the run-time handling of std::initializer_list in favour of
compile-time deduction allows the future use of sliceRange as well.
Eg,
list[sliceRange{18,3,2}] = 100;
list[{18,3,2}] = 100;
- Enhancements provided by Y. Inoue at RIST (http://www.hpci-office.jp)
- Use allToAll to only swap local data (excludes master processor; saves memory)
- Memory saving is noticeable >= 4000 cores
- fix typo in makefiles/info that affected wmake -show-compile-c
- additional safeguard in src/OpenFOAM/Make/options against self-linking.
This is not normally required unless PROJECT_LIBS has been added into
the link stage.
- extracts values from the arch "LSB;label=32;scalar=64" header entry
to provision for managing dissimilar primitive sizes.
Compensate for the additional IOobject members by narrowing the types
for the (objectState, readOption, writeOption) enumerations
- with the changes added in #1256 and corresponding updates to
ThirdParty we can stop exporting these variables:
WM_CC WM_CFLAGS WM_CXX WM_CXXFLAGS WM_LDFLAGS
solaris:
- rename WM_ARCH from SunOS to solaris64 for consistency with wmake/rules
- drop non-64 solaris from wmake/rules
- remove automatic selection of FJMPI. This should be done in the bashrc
or prefs.sh file instead.
- remove old (likely inaccurate) exported flags, rely on wmake -show-xyz
or user config instead
darwin:
- remove '-Ddarwin' from the exported WM_CFLAGS, WM_CXXFLAGS.
Not used elsewhere (ThirdParty)
- the only code location using BiIndirectList are debug sections
within polyTopoChange.
No need to construct/assign directly from a BiIndirectList since
the '()' method provides a simple alternative.
- use an IndirectListBase class for various indirect list types.
- new SortList type
In some places the SortList can be used as a lightweight alternative
to SortableList to have the convenience of bundling data and sort
indices together, but while operating on existing data lists.
In other situations, it can be useful as an alternative to
sortedOrder. For example,
pointField points = ...;
labelList order;
sortedOrder(points, order);
forAll(order, i)
{
points[order[i]] = ...;
}
Can be replaced with the following (with the same memory overhead)
pointField points = ...;
SortList<point> sortedPoints(points);
for (point& pt : sortedPoints)
{
pt = ...;
}
- new SliceList type (#1220), which can be used for stride-based
addressing into existing lists
- change from UpdateableMeshObject to TopologicalMeshObject
- change inheritance order to have MeshObject be registered first
and mark the IOobject descriptor as unregistered
- the objectRegistry destructor seems to be called too late.
Explicitly clear the objectRegistry within the Time destructor to
ensure that it always happens.
- used fallback of 0 instead of the results time.
This discrepancy caused the case file to have two timesets that
only differed by the first (incorrect) entry.
- used fallback of 0 instead of the results time.
This discrepancy caused the case file to have two timesets that
only differed by the first (incorrect) entry.
- when running in serial but within a processor directory,
argList::globalPath() is to be used instead of Time.globalPath()
For other cases there is no difference.
- this is somewhat like labelRange, but with a stride.
Can be used to define slices (of lists, fields, ..) or as a range specifier
for a for-loop. For example,
for (label i : sliceRange(0, 10, 3))
{
...
}
- with the wmake rules we may have some compiler options bound to the
internal compiler variable. For example,
CC = g++ -std=c++11 -m64
c++FLAGS = ...
So shift any flags from CC to CXXFLAGS for the output of
'wmake -show-cxx', 'wmake -show-cxxflags', etc.
This makes it much easier to handle the values correctly elsewhere.
Eg,
CXX="$(wmake -show-cxx)" CXXFLAGS="$(wmake -show-cxxflags)" \
./configure
- provide dedicated detection 'have_ptscotch' function that can be
used after the 'have_scotch' function.
It sets the PTSCOTCH_ARCH_PATH, PTSCOTCH_INC_DIR, PTSCOTCH_LIB_DIR
and helps when the serial and parallel versions are located with
different logic.
- file-local static for saving the old action, which moves system
dependencies out of the header files.
- set/reset of signals as file-local functions
STYLE: use csignal header instead of signal.h
- this adds support for various STL operations including
* sorting, filling, find min/max element etc.
* for-range iteration
STYLE: use constexpr for VectorSpace rank
- similar to the global '/' operator, but taking raw strings and not
performing any stripping.
Was previously a local function within POSIX.C, but it is useful enough
to be in fileName itself.
- having whitespace in fileName can be somewhat fragile since it means
that the fileName components do not necessarily correspond to a
'Foam::word'. But in many cases it will work provided that spaces
are not present in the final portion of the simulation directory
itself.
InfoSwitches
{
// Allow space character in fileName (use with caution)
allowSpaceInFileName 0;
}
- now use doClean=true as default for fileName::validate(). Was false.
Unlike fileName::clean() this requires no internal string rewrite
since the characters are being copied. Also handle any path
separator transformations (ie, backslash => forward slash) at the
same time. This makes it resemble the std::filesystem a bit more.
- can be useful for retrieving the compilation flags for use with other
make systems (eg, cmake)
* wmake -show-compile (C++ not C)
* wmake -show-cxx
* wmake -show-cxxflags
- operators are still incomplete, as are dimensioned fields,
field-fields etc.
- split complexFields into separate complexField, complexVectorField files
- add construction from and conversion to std::complex, which allows
easier wrapping of functions
- add Foam:: functions for complex versions of sin, cos, ...
- The 'used()' method was for transitional compatibility with the now
defunct PackedBoolList.
The canonical method name for returning a labelList of 'on' bits is
toc().
- was historically defined as (1 1), but it is more consistent with
the concept of one to have a real component only.
Now defined as (1 0): 1+0i
STYLE: remove obscure '!' operator for complex conjugate
- either use the member function or the '~' operator
- These are not defined in the C++ standard for cmath, so allow for
compilation without them. Will need to provide replacements in the
future or rework.
- new regExpCxx wrapper for C++11 regex support with drop-in
compatibility with existing code.
- regExpPosix (was regExp), for future phase out in favour of regExpCxx.
- The regExp header will continue to be used for defining an
appropriate typedef corresponding to the preferred implementation.
- instead of deciding beforehand if a surface format requires a separate
geometry file (or if a geometry file should be written if no fields were
written) now determine afterwards if something was written.
This improves the overall reliability (consistency) and is more
convenient for the caller as well.
- PtrDynList support for move append list:
can be used to concatenate pointer lists into a single one
- include resize in PtrDynList squeezeNull as being a natural
combination
- support sorting operations for pointer lists (PtrListOps)
- comparison operator, for sorting based on the position of the origin.
- allow modification of the origin.
- zero-initialise for null constructor: base components are vectors
and cheap to initialise.
- 'unfriend' the output operator: it uses public access methods
- remove writeGeometry() in favour of write() and make it pure virtual
so that all writers must explicitly deal with it.
- establish proxy extension at construction time and treated as an
invariant thereafter. This avoids potentially surprising changes in
behaviour when writing.
- with -mcpu=native for automatic detection and -armpl for linking in
the performance libraries
STYLE: relocate -mcpu into compiler instead of compiler-flags (#1225)
- prior to sampledSurface supporting different interpolation schemes a
workaround means was used to simulate cellPoint -> face
interpolation, with averaging of vertex interpolation.
We instead now use cellPoint interpolation directly for the face
values when 'interpolate=true'.
- normally findInstance will 'bottom out' with the constant directory
while doing its reverse time search. This mechanism however fails
when searching for negative start values (if there are none in the
list). Add additional logic for this so that constant will also be
used in these situations.
Note: to have decomposePar work for all times, may need the -constant option
to trigger the proper time list.
- construct from positions
- reset positions, minEdgeLen, find grid index
ENH: add accessor for obtaining the size of a single i-j-k dimension
- eg, obtain the 'i' dimension with any of these methods:
ijkAddr.size(vector::X)
ijkAddr.sizes().x()
ijkAddr.sizes()[0]
- this is a simple container for fields with i-j-k addressing.
It does not support field operations directly, but is primarily
intended to be used when assembling field information with i-j-k
logic. After assembly, the field can be transferred to a regular
field for normal operations. Eg,
IjkField<scalar> assemble({15, 16, 200});
// .. fill in i-j-k fields
Field<scalar> final(std::move(assemble));
assemble.clear(); // be pedantic
...
- While a rectilinear mesh can be created with blockMesh, not every mesh
created with blockMesh will satisfy the requirements for being a
rectilinear mesh.
This alternative to blockMesh uses a single block that is aligned
with the xy-z directions and specifications of the control points,
mesh divisions and expansion ratios. For example,
x
{
points ( -13.28 -0.10 6.0 19.19 );
nCells ( 10 12 10 );
ratios ( 0.2 1 5 );
}
y { ... }
z { ... }
With only one block, the boundary patch definition is simple and the
canonical face number is used directly. For example,
inlet
{
type patch;
faces ( 0 );
}
outlet
{
type patch;
faces ( 1 );
}
sides
{
type patch;
faces ( 2 3 );
}
...
- After a mesh is defined, it is trivial to retrieve mesh-related
information such as cell-volume, cell-centres for any i-j-k location
without an actual polyMesh.
STYLE: remove -noFunctionObjects from blockMesh
- no time loop, so function objects cannot be triggered anyhow.
- PtrList::release() method.
Similar to autoPtr and unique_ptr and clearer in purpose than
using set(i,nullptr)
- Construct from List of pointers, taking ownership.
Useful when upgrading code. Eg,
List<polyPatch*> oldList = ...;
PtrList<polyPatch> newList(oldList);
...
BUG: incorrect resizing method names (PtrDynList) in previously unused code
- this functionality was originally added to allow sampling of volume
fields onto a surface in order to perform calculations on them.
However, the sampling framework essentially mirrored the
sampledSurface, but was less complete.
It is now possible to store sampled surfaces on a registry and
do calculation with their fields. This is the preferred method,
and thus removing the surfMeshSample duplicate code.
- previously wrapped raw points/faces with a meshedSurfRef on input,
but now handle the raw -> meshedSurf logic directly within
surfaceWriter to avoid holding references to temporaries
Since the updated meshedSurfRef is now modifiable, it can be used
directly as a redirection mechanism within surfaceWriter.
- add explicit close() in destructor
- A negative expansion ratio is geometrically invalid and will
normally cause issues (FatalError).
However, we can trap this type of input and interpret it as the
inverse expansion ratio - ie, the expansion ratio in the opposite
direction. This can be especially convenient when generating a blockMesh
with a symmetrical expansion. It permits using the same expansion
ratio (with a sign change) instead of providing the reciprocal values
manually.
COMP: revert demand-driven point creation in blockMesh (db9b35b50d)
- appears to have caused a dangling reference on some systems
ENH: add a lightweight ijkAddressing class
- it can be used for an i-j-k to linear lookup of meshes or fields,
where applicable.
Velocity boundary condition generating synthetic turbulence-alike
time-series for LES and DES turbulent flow computations.
To this end, two synthetic turbulence generators can be chosen:
- Digital-filter method-based generator (DFM)
\verbatim
Klein, M., Sadiki, A., and Janicka, J.
A digital filter based generation of inflow data for spatially
developing direct numerical or large eddy simulations,
Journal of Computational Physics (2003) 186(2):652-665.
doi:10.1016/S0021-9991(03)00090-1
\endverbatim
- Forward-stepwise method-based generator (FSM)
\verbatim
Xie, Z.-T., and Castro, I.
Efficient generation of inflow conditions for large eddy simulation of
street-scale flows, Flow, Turbulence and Combustion (2008) 81(3):449-470
doi:10.1007/s10494-008-9151-5
\endverbatim
In DFM or FSM, a random number set (mostly white noise), and a group
of target statistics (mostly mean flow, Reynolds stress tensor profiles and
length-scale sets) are fused into a new number set (stochastic time-series,
yet consisting of the statistics) by a chain of mathematical operations
whose characteristics are designated by the target statistics, so that the
realised statistics of the new sets could match the target.
Random number sets ---->-|
|
DFM or FSM ---> New stochastic time-series consisting
| turbulence statistics
Turbulence statistics ->-|
The main difference between DFM and FSM is that the latter replaces the
streamwise convolution summation in DFM by a simpler and a quantitatively
justified equivalent procedure in order to reduce computational costs.
Accordingly, the latter potentially brings resource advantages for
computations involving relatively large length-scale sets and small
time-steps.
pointNormals calculation gets triggered through processorfvPatches
so on processors that don't have these bypass this. This leads
to the global reduction hanging.
- avoid potential ambiguities in naming of mesh faces/edges
vs. block faces/edges
- additional methods characterizing the number of faces
(internal, boundary, total) associated with a blockDescriptor
- cellLabel() accessor and checkIndex() methods
- restore demand-driven behaviour of block, cache the calculated cells
and refactor generation of block boundary faces to improve potential
reuse.
- construct from MinMax, optional start index for identity factory
method to match Foam::identity()
- use GREAT instead of VGREAT in inverted scalarRange.
Consistent with boundBox - to reduce the potential of overflow
if calculating the span.
- add min()/max() methods to labelRange
- Extended runTimePostProcessing to include access to "live"
simulation objects such a geometry patches and sampled surfaces
stored on the "functionObjectObjects" registry.
- Add 'live' runTimePostProcessing of cloud data.
Extracts position and fields from the cloud via its objectRegistry writer
- For the "live" simulation objects, there are two new volume filters
that work directly with the OpenFOAM volume fields:
* iso-surface
* cutting planes
Both use the VTK algorithms directly and support multiple values.
Eg, can make multiple iso-levels or multiple planes parallel to each
other.
- When VTK has been compiled with MPI-support, parallel rendering will
be used.
- Additional title text properties (shadow, italic etc)
- Simplified handling of scalar-bar and visibility switches
- Support multiple text positions. Eg, for adding watermark text.
- fits better into the general sampling framework, improves flexibilty
and allows code reduction.
ENH: include surface fields on sampledSurfaces that support it
- The writers have changed from being a generic state-less set of
routines to more properly conforming to the normal notion of a writer.
These changes allow us to combine output fields (eg, in a single
VTK/vtp file for each timestep).
Parallel data reduction and any associated bookkeeping is now part
of the surface writers.
This improves their re-usability and avoids unnecessary
and premature data reduction at the sampling stage.
It is now possible to have different output formats on a per-surface
basis.
- A new feature of the surface sampling is the ability to "store" the
sampled surfaces and fields onto a registry for reuse by other
function objects.
Additionally, the "store" can be triggered at the execution phase
as well
- when windows portable executables (.exe or .dll) files are loaded,
their dependent libraries not fully loaded. For OpenFOAM this means
that the static constructors which are responsible for populating
run-time selection tables are not triggered, and most of the run-time
selectable models will simply not be available.
Possible Solution
=================
Avoid this problem by defining an additional library symbol such as
the following:
extern "C" void libName_Load() {}
in the respective library, and tag this symbol as 'unresolved' for
the linker so that it will attempt to resolve it at run-time by
loading the known libraries until it finds it. The link line would
resemble the following:
-L/some/path -llibName -ulibName_Load
Pros:
- Allows precise control of forced library loading
Cons:
- Moderately verbose adjustment of some source files (even with macro
wrapping for the declaration).
- Adjustment of numerous Make/options files and somewhat ad hoc
in nature.
- Requires additional care when implementing future libraries and/or
applications.
- This is the solution taken by the symscape patches (Richard Smith)
Possible Solution
=================
Avoid this problem by simply force loading all linked libraries.
This is done by "scraping" the information out of the respective
Make/options file (after pre-processing) and using that to define
the library list that will be passed to Foam::dlOpen() at run-time.
Pros:
- One-time (very) minimal adjustment of the sources and wmake toolchain
- Automatically applies to future applications
Cons:
- Possibly larger memory footprint of application (since all dependent
libraries are loaded).
- Possible impact on startup time (while loading libraries)
- More sensitive to build failures. Since the options files are
read and modified based on the existence of the dependent
libraries as a preprocessor step, if the libraries are initially
unavailable for the first attempt at building the application,
the dependencies will be inaccurate for later (successful) builds.
- This is solution taken by the bluecape patches (Bruno Santos)
Adopted Solution
================
The approach taken by Bruno was adopted in a modified form since
this appears to be the most easily maintained.
Additional Notes
================
It is always possible to solve this problem by defining a corresponding
'libs (...)' entry in the case system/controlDict, which forces a dlOpen
of the listed libraries. This is obviously less than ideal for large-scale
changes, but can work to resolve an individual problem.
The peldd utility (https://github.com/gsauthof/pe-util), which is
also packaged as part of MXE could provide yet another alternative.
Like ldd it can be used to determine the library dependencies of
binaries or libraries. This information could be used to define an
additional load layer for Windows.
- reduces some dictionary clutter and probably looks less confusing
than having an ending that may not correspond to the current OS.
Eg, "fvOptions" instead of "libfvOptions.so", "libfvOptions.dylib" ...
- convenience dlOpen method for multiple files
- add iterators, begin/end, empty() methods for STL behaviour.
Use standard algorithms where possible
* std::fill, std::copy
* std::min_element, std::max_element
- access methods consistent with other OpenFOAM containers:
* data(), cdata(), uniform()
- Use ListPolicy to impose output line breaks
- Can recover matrix storage for re-use elsewhere.
For example, to populate values with 2D i-j addressing and later
release it as flat linear storage.
- construct/assign moveable
- added minMax() function for Matrix
- additional inplace +=, -=, *=, /= operations
- add named methods at() and rowData() to Matrix.
Allows a better distinction between linear and row-based addressing
- low-level matrix solve on List/UList instead of Field
- can be used to check the validity of input values.
Example:
dict.getCheck<label>("nIters", greaterOp1<label>(0));
dict.getCheck<scalar>("relax", scalarMinMax::zero_one());
- use 'get' prefix for more regular dictionary methods.
Eg, getOrDefault() as alternative to lookupOrDefault()
- additional ops for convenient construction of predicates
ENH: make dictionary writeOptionalEntries integer
- allow triggering of Fatal if default values are used
ENH: additional scalarRange static methods: ge0, gt0, zero_one
- use GREAT instead of VGREAT for internal placeholders
- additional MinMax static methods: gt, le
- in addition to managing different vendors and versions, it may also
be necessary or desirable to have a particular variant
(eg, profiling, release, etc).
Devise a new meaningful name for the variant and create a
corresponding wmake rule.
Eg, SYSTEMOPENMPI-profiling with a corresponding
"wmake/rules/linux64Gcc/mplibSYSTEMOPENMPI-profiling" file
that has suitable content for your system.
CONFIG: intel-mpi use intel64/ paths only for config and wmake rules (#1153)
- previously adjusted the config files, but missed the changes
required for the wmake rules too.
Now simply migrate to using "intel64/{include,bin,lib}"
instead of the older naming "{include,bin,lib}64"
These changes work since at least intel-mpi 2015 (5.x), but possibly
earlier as well
- This simple container provides a means of storing faces/points
(ie, surfaces) with registered dimensioned fields.
The main registry is used to hold face-based data, a secondary
sub-registry is used to hold point-based data. This allows the same
name for CellData and PointData fields without name collisions.
ENH: Several modifycations to avoid erroneuos rays to be shot
from wrong faces.
ENH: Updating tutorials and avoiding registration of the
coarse singleCellFvMesh
Adding solarLoad tutorial case simpleCarSolarPanel
ENH: Changes needed for the merge
- was WM_PROJECT_API in the environment and FOAM_API in dictionaries.
Make these both consistently FOAM_API.
This is a non-breaking change, since the value of WM_PROJECT_API
(added in 1812) and/or FOAM_API is purely informative.
For the current correct values, always use
* foamEtcFile -show-api
* wmakeBuildInfo -show-api
- If using a non-clang compiler suite (gcc, intel, etc) the additional
lbraries required for mesa with llvm pipelines may not be found.
Provide a mesa_llvm configuration with in the 'vtk' config file.
Can use the usual types of settings
* mesa_llvm=llvm-4.0.1
* mesa_llvm=none
* mesa_llvm=system
- Note: mpich now builds libmpi.so instead of libmpich.so
- define both -DMPICH_SKIP_MPICXX and -DOMPI_SKIP_MPICXX regardless of
using openmpi or mpich. This simplifies the files and does not harm.
- previously just removed duplicate literals, but now remove any
duplicates.
- Replace previous wordHashSet implementation with a linear search
instead. The lists are normally fairly small and mostly just have
unique entries anyhow. This reduces the overall overhead.
- simplifies their use when reordering lists etc.
(word, fileName, keyType, wordRe)
- "unfriend" IO operators for string types. They require no internal access
- add compile/uncompile methods to keyType for symmetry with wordRe
- when outputting keyType/wordRe, be more explicit about them using
writeQuoted()
- delay dereferencing of optional subRegion entries until an
objectRegistry is required.
This improves usabilty when reference objects do not yet exist
at the time of construction.
The occurrence is from cells with vertices that are shared between two faces
only (these vertices can originate from hex refinement). Decomposing both faces
can occasionally produce triangles with identical vertices and this results in a
non-manifold edge which triggers the erosion procedure.
Avoided by detecting cells with these special vertices and making sure the tet-decomposition
never uses the same points on the faces using them.
Patch contributed by Mattijs Janssens
- can now safely use labelList::null() instead of emptyLabelList for
return values. No special treatment required for lists.
Possible replacements:
if (notNull(list) && list.size()) -> if (list.size())
if (isNull(list) || list.empty()) -> if (list.empty())
The receiver may still wish to handle differently to distinguish
between a null list and an empty list, but no additional special
protection is required when obtaining sizes, traversing, outputting
etc.
- relocate zone IO from Detail::MeshedSurfaceIOAllocator into surfMesh
directly to allow re-purposing of MeshedSurfaceIOAllocator
- provide meshedSurf::emptySurface zero-sized placeholder implementation
- add concrete implementation of meshedSurf::zoneIds() to simplify
overloading
- previously had a single pointer/value zeros (8 bytes), this meant
that the reinterpret cast to a List would yield a reference that
could be unsafe under certain conditions.
Eg,
const labelList& myList = labelList::null();
Info<< myList.size() << nl; // OK since size is the first parameter
SubList<label>(myList, 0); // Unsafe
The SubList usage is unsafe since it passes in pointer and size into
the underlying UList. However, the pointer from the labelList::null()
will be whatever happens to be around in memory immediately after the
NullObject singleton. This is mostly not a problem if the List size
is always checked, but does mean that the data pointer is rather
dubious.
- Increase the size of the nullObject singleton to 32 bytes of zeros
to ensure that most reinterpret casting will not result in objects
that reference arbitrary memory.
The 32-byte data size is rather arbitrary, but covers most basic
containers.
- The findObject() methods are template-typed and used to locate a
particular Type/name combination.
Eg,
volScalarField* ptr = obr.findObject<volScalarField>("xyz");
- The findIOobject() methods are un-typed and use the name only.
Eg,
regIOobject* ptr = obr.findIOobject("xyz");
The typed versions will be most commonly used, but the un-typed lookup
can be useful in a templating.
- Simplified findObject* methods to use findIOobject* as the backend.
- similar to what erase() does, but as a mutable operation (#1180)
- replace basicThermo lookupAndCheckout (commit 880c98757d) with
the new objectRegistry::checkOut() method.
- implemented as lazy evaluation with an additional update() method.
This avoids unnecessary changes until the values are actually
required.
- apply mesh motion changes for momentum, volFieldValue,
specieReactionRates function objects
- changed ensightOutput from a class solely comprising static methods to
a namespace and added in sub-namespaces Detail and Serial.
This makes it easier to "mix-in" functions at different levels.
Refactored and combined some serial/parallel code where possible.
The general ensightOutput namespace has now shifted to be in the
fileFormats lib, while leaving volField outputs in the conversion lib
and cloud outputs in the lagrangian-intermediate lib.
The ensightCloud namespace is now simply folded into the new
ensightOutput namespace.
These changes clean up some code, reduce fragmentation and
duplication and removes the previous libconversion dependency for
sampling.
- use int for ensight nTypes constexpr
Note: issue #1176 is unaffected except for the change in file name:
ensightOutputTemplates.C -> ensightOutputVolFieldTemplates.C
- improved the selection mechanism to include using a bitSet
cell selection (more efficient and convenient).
Use templated implementation internally to remove the previous
reliance on a NullObject.
Eg,
#define FOAM_CONFIGURED_PROJECT_ETC "/usr/share/openfoam/etc"
This provides some easy to file patching locations, but is not yet
integrated in the build system at all.
- in some circumstances we need to pass a bool value upwards to the
caller and know if the true/false value was set based on real input
or is a default value.
Eg, in the object::read() we might normally have
enabled_(dict.readIfPresent(key, true));
but would lose information about why the value is true/false.
We can change that by using
enabled_(dict.readIfPresent<Switch>(key, Switch::DEFAULT_ON));
After which we can use this information is testing.
if
(
child.enabled().nonDefault()
? child.enabled()
: parent.enabled()
)
{ ... }
And thus enable output if the parent requested it explicitly or by
default and it has not been explicitly disabled in the child.
No difference when testing as a bool and the text representation
of DEFAULT_ON / DEFAULT_OFF will simply be "true" / "false".
ENH: add construction of Switch from dictionary (similar to Enum)
Previously silently accepted '-o' as being equivalent to '-output',
but the former could be misinterpreted meaning an output file (which
it is not) instead of an output directory.
- instead of
WM_COMPILER=GccKNL WM_COMPILE_OPTION=Opt
-> linux64GccKNLDPInt32Opt
now specify
WM_COMPILER=Gcc WM_COMPILE_OPTION=OptKNL
-> linux64GccDPInt32OptKNL
This makes it easier (and more obvious) for adding different tweaks
without needing to generate too many files.
Eg,
cd wmake/rules/linux64Gcc
cp cOpt cOptBdw
cp c++Opt c++OptBdw
edit these two files and then use WM_COMPILE_OPTION=OptBdw
CONFIG: provide some default c/c++ flags in General compiler rules
- can make is easier when deriving new compile options, and ensures
that '-02' is enabled as an initial default.
- finds the correct root directory location before creating
the lnInclude directory
Eg,
from within something like src/finiteVolume/fields/fvPatchFields/..
wmakeLnInclude -update -root
it backtracks to find the top-level directory with Make/
and makes the lnInclude directory there:
Using /home/mark/openfoam/OpenFOAM-plus/src/finiteVolume
ln: /home/mark/openfoam/OpenFOAM-plus/src/finiteVolume/lnInclude
- Can result in inadvertent conversions where the user should really
know or check if the pointer is valid prior to using.
- Still have several places to fix that are using the deprecated copy
construct and copy assignment
- changed the sectorCoeffs keyword to 'point' from 'axisPt'
for more similarity with other dictionaries.
Continue to accept 'axisPt' for compatibility.
- now free anything owned by the registry when doing a clear.
- the myriad of other ways to remove items (and potentially leaking)
have not yet been addressed:
* set, erase, retain, filterKeys, filterValues, filterEntries
- Uses the user-specified value for the HTC calculation
{
type externalCoupledTemperature;
outputTemperture fluid; // or wall;
htcRefTemperature user; // or cell (default)
Tref 293.15;
}
- was for parallel compilation across multiple hosts, but less useful
with modern CPUs with higher number of cores and/or hyperthreading.
Fragile use and dependent on a 'lockfile' utility that is not often
installed.
- previously stated that the patch level would be 0, but this would
necessitate many revert commits after merging in the master branch.
It is better to leave the meaning open.
- support for optional 'enabled' keyword to selectively disable a
single sampled surface.
ENH: add sampledSurface::withSurfaceFields() method
- can be used to distinguish which samplers support surface fields.
Currently this is only sampledPatch
- remove unused and deprecated emptyList() casting function.
This function is disllowed by many modern compilers and is no longer
used within OpenFOAM - was deprecated 2018-07.
- this protected method was previously used directly for the list
output and had the check for 2 or more elements in it. Now simply
test the List content and handle the output preference separately.
- introduced a ListPolicy details to make the transition between
a short list (space separated) and a long list (newline separated)
more configurable.
We suppress line breaks for commonly used types that often have
short content: (word, wordRes, keyType).
- was WM_PROJECT_API in the environment and FOAM_API in dictionaries.
Make these both consistently FOAM_API.
This is a non-breaking change, since the value of WM_PROJECT_API
(added in 1812) and/or FOAM_API is purely informative.
For the current correct values, always use
* foamEtcFile -show-api
* wmakeBuildInfo -show-api
- If using a non-clang compiler suite (gcc, intel, etc) the additional
lbraries required for mesa with llvm pipelines may not be found.
Provide a mesa_llvm configuration with in the 'vtk' config file.
Can use the usual types of settings
* mesa_llvm=llvm-4.0.1
* mesa_llvm=none
* mesa_llvm=system
- accidentally introduced by 27c62303ad
STYLE: trial use of brace-initialized dimensionSet
- instead of writing
dimensionedScalar(dimensionSet(1, -2, -2, 0, 0, 0), Zero);
we can use C++11 brace-initialization to bundle the parameters
for the dimensionSet construction and simply write
dimensionedScalar({1, -2, -2, 0, 0, 0}, Zero);
Note the following is incorrect syntax (extra brackets):
dimensionedScalar(({1, -2, -2, 0, 0, 0}), Zero);
- Global functions are unary or combining binary functions, which are
defined in MinMax.H (MinMaxOps.H).
There are also global reduction functions (gMinMax, gMinMaxMag)
as well as supporting 'Op' classes:
- minMaxOp, minMaxEqOp, minMaxMagOp, minMaxMagEqOp
Since the result of the functions represents a content reduction
into a single MinMax<T> value (a min/max pair), field operations
returning a field simply do not make sense.
- Implemented for lists, fields, field-fields, DimensionedField,
GeometricField (parallel reducing, with boundaries).
- Since the minMax evaluates during its operation, this makes it more
efficient for cases where both min/max values are required since it
avoids looping twice through the data.
* Changed GeometricField writeMinMax accordingly.
ENH: clip as field function
- clipping provides a more efficient, single-pass operation to apply
lower/upper limits on single or multiple values.
Examples,
scalarMinMax limiter(0, 1);
limiter.clip(value)
-> returns a const-ref to the value if within the range, or else
returns the appropriate lower/upper limit
limiter.inplaceClip(value)
-> Modifies the value if necessary to be within lower/upper limit
Function calls
clip(value, limiter)
-> returns a copy after applying lower/upper limit
clip(values, limiter)
-> returns a tmp<Field> of clipped values
- in 1812 propagated through the distinction between areaNormal and
unitNormal (issue #885).
In older versions, the normal() always meant the area-normal for
certain of these primitive.
However, the .org version changed this to now return the unit-normal
instead, but with the same method name. Thus add the deprecated
message to avoid future inadvertent uses of normal() without being
certain which one is being meant.
- a valid() method (same as !empty() call) for consistency with other
containers and data types
- a centre() method (same as midpoint() method) for consistency with
other OpenFOAM geometric entities
Had this:
Tuple2() {}
Instead of:
Tuple2() : f_(), s_() {}
which is the same as
Tuple2() = default;
This meant that Tuple2<scalar, scalar>() was not being zero-initialized
- a FixedList is generally small so there is little advantage
in a compact output form for uniform content. Eg, "2{-1}"
By avoiding this compact form we obtain output that is also
consistent with Tuple2, for example.
- make FixedList construct from Istream explicit
- relocate the pair_entry (HashTable) and unary_entry (HashSet) into
the Detail namespace and add output handling.
The output handling at this level removes the reliance on zero::null
output (HashSet) and allows direct support of pointers.
This means that the following now works
HashTable<T*> tbl;
os << tbl;
It also means that we don't need to overload operator<< for
HashPtrTable anymore.
- avoid delete/new when calling HashSet::set(). If the entry already
exists there is no reason to remove it and add another one with the
same content.
STYLE: HashTable iterators now have a val() method
- identical to the object() iterator method, but shorter to type.
- fixed some more places with an explicit AUTO_WRITE.
BUG: revert handling of the readOption. It should not be NO_READ.
In cases where the user a IOobject without specifying read/write, it
defaults to NO_READ anyhow. However, the move constructor can also
be called with empty lists and a read option. This has the same
signature, but obviously will not work with NO_READ.
- identical to found(), which should be used for more consistency.
The contains() is a remnant from when hashedWordList was generalized
from a speciesTable (OCT 2010)
- looks slightly messier without associative arrays, but improves
portability. Should now also work with dash.
STYLE: support wmakeBuildInfo -cmp and -check options as equivalent
- number of particles per parcel info to kinematic cloud
- added turbulent dispersion to basicHeterogeneousReactingParcel
- corrected dhsTrans in MUCSheterogeneousRate::calculate
- added cloud macro system to reactingParcelFoam and fixed calculation
of average particles per parcel
- added progress variable dimension to reacting model (nF)
- added ReactingHeterogeneous tutorial
- provide a lookupOrDefault constructor form, since this is a fairly
commonly used requirement and simplifies the calling sequence.
Before
dimensionedScalar rhoMax
(
dimensionedScalar::lookupOrDefault
(
"rhoMax",
pimple.dict(),
dimDensity,
GREAT
)
);
After
dimensionedScalar rhoMax("rhoMax", dimDensity, GREAT, pimple.dict());
- read, readIfPresent methods with alternative lookup names.
- Mark the Istream related constructors with compile-time deprecated
warnings.
BUG: read, readIfPresent methods not handling optional dimensions (#1148)
- this scripts are largely pre-git era and not used much anymore.
Relocate to a legacy/ sub-directory while we see if there are
actually any still being used.
- the utility had automatic triangulation removed some time ago, but
never changed its name.
- catch old uses with a surfaceMeshTriangulate deprecated script
- can be used as a more natural test on the iterator.
For example, with
HashTable<..> table;
auto iter = table.find(...);
Following are now all equivalent:
1. if (iter != table.end()) ...
2. if (iter.found()) ...
3. if (iter) ...
- similar to autoPtr and unique_ptr. Returns the pointer value without
any checks. This provides a simple way for use to use either
an autoPtr or a tmp for local memory management without accidentally
stealing the pointer.
Eg,
volVectorField* ptr;
tmp<volVectorField> tempField;
if (someField.valid())
{
ptr = someField.get();
}
else
{
tempField.reset(new volVectorField(....));
ptr = tmpField.get();
}
const volVectorField& withField = *ptr;
STYLE: make more tmp methods noexcept
Averages columns of cells for layered meshes.
For each patch face, calculates the average value of all cells attached in
the patch face normal direction, and then pushes the average value back
to all cells in the column.
Useful for channel-like cases where we want to average fields in the
spanwise direction.
Example of function object specification:
columnAverage1
{
type columnAverage;
libs ("libfieldFunctionObjects.so");
...
patches (front side);
fields (U p);
}
Where the entries comprise:
\table
Property | Description | Required | Default value
type | type name: fieldMinMax | yes |
patches | list of patches to collapse onto | yes |
fields | list of fields to process | yes |
\endtable
- this corresponds to 'never match', which may be useful in combination
with -constant selection.
Eg,
surfaceMeshTriangulate -constant -time none
selects only the constant entry and suppresses any automatic time loop
STYLE: adjust help for the standard -times option
- indicate that times can be comma or space separated, since this is
otherwise not apparent. Don't mention semicolon separators in the help
since that just adds even more clutter.
- support .vtp format for geometry, surface, line, cloud.
- use native reader for handling vtk, vtp, obj, stl surface files.
For other formats, use the MeshedSurface (the surfMesh lib) to
handle reading and Foam::vtk::Tools::Patch to handle the
conversion to vtkPolyData. This combination is more memory efficient.
- update tutorial case to include vtp surface geometry
- note that it does not actually triangulate unless necessary, should
probably receive a new name.
- use newer constructs for handling processor/non-processor patch
selection etc.
- for quantities such as face area/normals etc, it can be useful to
calculate directly and avoid the overhead of caching all the values.
STYLE: comments, use HashTable lookup() method in whichPoint()
- this allows more use of the runTimePostProcessing functionObject
that will fail more gracefully if the proper version could not be
built.
The dummy functionObject simply emits a message that it is not available.
- this is identical to either of these solutions:
* getEnv("FOAM_CASE")
* stringOps::expand("<case>")
but with a closer resemblance to argList or Time globalPath(),
which makes the intent clearer.
Avoids using raw strings in the caller, which improves compile-time checks.
Used in situations where a class has no derivation path or other
access to a time registry or command args.
- provide relativePath() for argList and for Time.
These are relative to the case globalPath().
Eg,
Info<< "output: " << runTime.relativePath(outputFile) << nl;
- partial solution for issue #1091
This generates file properties that are case-relative,
Eg,
plane0
{
p
{
file "<case>/postProcessing/plane0/1/p_plane0.vtk";
}
U
{
file "<case>/postProcessing/plane0/1/U_plane0.vtk";
}
}
This allows the case to be moved elsewhere and still find its files.
This functionality was previously added for vtkCloud, but now also
applies to streamLine, sampledSets and sampledSurfaces
- it is sufficient to provide the total number of times that findBinary()
failed instead of flooding the screen with messages
Full verbose warnings still emitted when debugging is on.
- makes the intent clearer and avoids the need for additional
constructor casting. Eg,
labelList(10, Zero) vs. labelList(10, 0)
scalarField(10, Zero) vs. scalarField(10, scalar(0))
vectorField(10, Zero) vs. vectorField(10, vector::zero)
- now use findEtcEntry() instead to handle file or directory.
Added findEtcEntries(), which provides provides a common code basis
for findEtcDirs(), findEtcFiles() ...
- this simplifies use of a unified test for directory or file.
fileName::Type what = myfile.type(true, true);
if (what == FILE) ...
if (what == DIRECTORY) ...
- Use distinct bit values for fileName::Type, for possible use in
the future.
- related to issue #1121, since we need a more flexible way of
expanding file or directory.
An alternative would be to add checkGzip to Foam::exists() and
Foam::type() functions, but that would make the code there more
confusing and in the fileHandler classes.
- for some special cases we wish to mark command-line arguments as
being optional, in order to do our own treatment. For example,
when an arbitrary number of arguments should be allowed.
Now tag this situation with argList::noMandatoryArgs().
The argList::argsMandatory() query can then be used in any further
logic, including the standard default argument checking.
- with the new default check, can consolidate the special-purpose
"setRootCaseNonMandatoryArgs.H"
into the regular
"setRootCase.H"
- revert to a simple "setRootCase.H" and move all the listing related
bits to a "setRootCaseLists.H" file. This leaves the information
available for solvers, or whoever else wishes, without being
introduced everywhere.
- add include guards and scoping to the listing files and rename to
something less generic.
listOptions.H -> setRootCaseListOptions.H
listOutput.H -> setRootCaseListOutput.H
- Now also responds to the contents of the trigger file,
processing action= contents similar to used with external coupling.
Previously it only handled an action that was defined in the
dictionary. With this update, the user can chose a diferent action
simply by echoing the appropriate action string into the trigger
file.
- similar to the foamEtcFile script -mode=... option, the specific
search location (user/group/other) can now also specified for
string expansions and as a numerical value for etcFile()
For example, if searching for group or other (project) controlDict,
but not wishing to see the user controlDict:
1. foamEtcFile -mode=go controlDict
2. fileName dictFile("<etc:go>/controlDict");
dictFile.expand();
3. etcFile(controlDict, false, 0077);
The default behaviour for searching all contexts is unchanged.
1. foamEtcFile controlDict
2. fileName dictFile("<etc>/controlDict");
dictFile.expand();
3. etcFile(controlDict);
- the local third-party headers are to be searched before any MPI
include directories. This stops the situation where an mpi-specific
version of ptscotch.h is installed into the MPI directories.
This "system" version may well have a different SCOTCH_Num size
(32 bit vs 64 bit) from the third-party library etc.
- change previous default (convert all faceZones unless -noFaceZones
specified) with the default behaviour to only convert face zones on
request.
- uses the '-faceZones' option as per foamToEnsight
- the result of lsof, which is used in the etc/cshrc to locate the
installation, may contain trailing information about host and mount
point.
There is also a moderate concern with people sourcing the
file indirectly with their own version in the same directory.
For example, a 'etc/cshrc-site' that actually sources 'etc/cshrc'.
This leads to multiple matches in the lsof output, so we only take
the first one, stop there and hope they didn't do something even
trickier.
- the counterpart to floatVector, doubleTensor, which can be useful
for connecting to programs that always expect double precision for
the arguments, when using single-precision for OpenFOAM itself.
Eg,
doubleVector pos = ...;
vtkcamera->SetPosition(pos.v_);
- prefer this to using the OPENFOAM define since this improves the
internal consistency with the build information.
The API information could change between builds without the
etcFiles.C being recompiled whereas the value of
Foam::foamVersion::api is force updated during the build (triggers
recompilation of globals.Cver)
Reports the min|max|average AMI weights to text file and optionally
writes VTK surfaces of the sum of the weights, and mask field for
ACMI patches.
Example usage:
AMIWeights
{
type AMIWeights;
libs ("libfieldFunctionObjects.so");
writeControl writeTime;
writeFields yes;
}
Reference:
Comte-Bellot, G., and Corrsin, S., "Simple Eulerian Time Correlation of
Full- and Narrow-Band Velocity Signals in Grid-Generated, 'Isotropic'
Turbulence," Journal of Fluid Mechanics, Vol. 48, No. 2, 1971,
pp. 273–337.
- now placed under postProcessing/checkMesh and postProcessing/checkAMI,
respectively.
Output files are now also tagged with the id of the patch, in case
there are multiple AMI patches in use.
- the problem occurred when running the writers in a parallel solver
or utility but requesting output on the master only.
Adjusted the logic to avoid globalIndex for these cases.
Previously the if (parallel_) checks were happening later, after the
globalIndex had already been created.
- use cellCentres() instead of volField equivalent for vtk conversion
- make looping variables more consistent
- centralize the transcription of OpenFOAM -> vtk tuples
Adding reflecting fluxes to Solar load radiation model.
Adding functionality to the boundary radiation models and new
place holder for basic wall types such as transparent, opaqueDiffusive,
opaqueReflective,etc.
Changing radiation wall models to run time selectable.
Adding multi-band capabilities to VF model and improving the set up
for using solar loads in VF and fvDOM radiation models.
The freestreamFvPatchField previously employed a fixed value when supplying
the inlet values. This commit extends the BC so that users can use another
patch to supply the values via the new freestreamBC entry, e.g. to set the
velocity to an atmospheric boundary layer profile:
inlet
{
type freestream;
freestreamBC
{
type atmBoundaryLayerInletVelocity;
flowDir (1 0 0);
zDir (0 0 1);
Uref 20;
Zref 20;
z0 uniform 0.1;
zGround uniform 935;
}
}
The earlier specification is also maintained for backwards compatibility, e.g.
inlet
{
type freestream;
freestreamValue uniform (300 0 0);
}
- provide default WM_DIR if not already set, to improve robustness if a
reduced environment is used
- add etc/ to WM_PROJECT_SITE search. This makes the site directory
structure consistent with the OpenFOAM structure.
Eg,
WM_PROJECT_SITE/etc/..
WM_PROJECT_SITE/bin/..
WM_PROJECT_SITE/platforms/..
- Don't set/export WM_OSTYPE. The default is POSIX and is properly
defaulted throughout, including in CMakeLists-OpenFOAM.txt (also for
Catalyst)
- Use the OPENFOAM define (eg, 1806, 1812), which normally corresponds
to a major release, to define an API level. This remains consistent
within a release cycle and means that it is possible to manage
several sub-versions and continue to have a consistent lookup.
The current API value is updated automatically during the build
and cached as meta data for later use, even when the wmake/ directory
is missing or OpenFOAM has not yet be initialized.
The version information reported on program start or with -help
usage adjusted to reflect this. The build tag from git now also
carries the date as being more meaningful to trace than a hash
value.
- Update etc/bashrc and etc/cshrc to obtain the project directory
directly instead of via its prefix directory. The value obtained
corresponds to an absolute path, from which the prefix directory
can be obtained.
The combination of these changes removes the reliance on any
particular directory naming convention.
For example,
With an 1812 version (API level):
WM_PROJECT_VERSION=myVersion
installed as /some/path/somewhere/openfoam-mySandbox
This makes the -prefix, -foamInstall, -projectVersion, -version
values of foamEtcFiles, and similar entries for foamConfigurePaths
superfluous.
WM_PROJECT_INST_DIR is no longer required or used
ENH: improve handling and discovery of ThirdParty
- improve the flexibility and reusability of ThirdParty packs to cover
various standard use cases:
1. Unpacking initial release tar files with two parallel directories
- OpenFOAM-v1812/
- ThirdParty-v1812/
2. With an adjusted OpenFOAM directory name, for whatever reason
- OpenFOAM-v1812-myCustom/
- openfoam-1812-other-info/
3. Operating with/without ThirdParty directory
To handle these use cases, the following discovery is used.
Note PROJECT = the OpenFOAM directory `$WM_PROJECT_DIR`
PREFIX = the parent directory
VERSION = `$WM_PROJECT_VERSION`
API = `$WM_PROJECT_API`, as per `foamEtcFiles -show-api`
0. PROJECT/ThirdParty
- for single-directory installations
1. PREFIX/ThirdParty-VERSION
- this corresponds to the traditional approach
2. PREFIX/ThirdParty-vAPI
- allows for an updated value of VERSION (eg, v1812-myCustom)
without requiring a renamed ThirdParty. The API value
would still be '1812' and the original ThirdParty-v1812/
would be found.
3. PREFIX/ThirdParty-API
- this is the same as the previous example, but using an unadorned
API value. This also makes sense if the chosen version name also
uses the unadorned API value in its naming
(eg, 1812-patch190131, 1812.19W03)
4. PREFIX/ThirdParty-common
- permits maximum reuse for various versions, but only for
experienced user who are aware of potential version
incompatibilities
Directory existence is checked as is the presence of an Allwmake file
or a platforms/ directory. This reduces the potential of false positive
matches and limits the selection to directories that are either
with sources (has the Allwmake file), or pre-compiled binaries (has
the platforms/ directory).
If none of the explored directories are found to be suitable,
it reverts to using a PROJECT/ThirdParty dummy location since
this is within the project source tree and can be trusted to
have no negative side-effects.
ENH: add csh support to foamConfigurePaths
- this removes the previously experienced inconsistence in config file
contents.
REMOVED: foamExec
- was previously used when switching versions and before the
bashrc/cshrc discovery logic was added. It is now obsolete.
- Uses the user-specified value for outputTemperature:
{
type externalCoupledTemperature;
outputTemperture fluid; // or wall;
}
Otherwises uses 'wall' as a default (for compatibility) and emits a
warning.
The T.out header now reflects the type of output. Eg,
# Values: area Tfluid qDot htc
- tutorials based on squareBend used Default_Boundary_Region explicitly
defined since they predated the defaultPatch renaming (2008).
The name 'Default_Boundary_Region' was for convenience as the default
name when converting to PROSTAR or CCM formation, but can now be
changed to something more generic.
- define wall boundary conditions for squareBend using a general regex
to allow future splitting of wall types by name.
- check if the first argument corresponds to an OpenFOAM value for
'true' (as per Switch).
True == 't', 'y', 'true', 'yes', 'on'. Everything else is not true.
- when the first argument is '-dict', it initializes the value
with a query via foamDictionary.
Eg,
isTrue -dict mydict -entry parallel
==> value=$(foamDictionary mydict -entry parallel -value)
isTrue $value
a missing entry is silently treated as false.
ENH: add getNumberOfPatchFaces function in RunFunctions
- simple extraction of nFaces from boundary file for given patch/region
- append the commit hash value with the commit date when creating
the build string information and drop the version prefix.
This provides an immediate overview of when the code was last
changed. The prefixed version information can be dropped from
the build string, since it is readily available in other forms.
- was PREFIX/site, now PROJECT/site
This avoids several issues when installing OpenFOAM in clusters
without an intermediate OpenFOAM-specific installation prefix.
The 'site' directory may have a reserved meaning in these situations
and it is undesirable to 'leak' upwards into the parent directory to
look for configuration files.
Placing the default within the project directory avoids this.
Alternative locations can be given via the WM_PROJECT_SITE variable.
- removed reliance on ParaView_INCLUDE_DIR variable for conveying the
major.minor version information when compiling. This can be somewhat
fragile and also adds variable that is an unnecessary when running
(only used when compiling).
Instead use `have_pvplugin_support` function in paraviewFunctions
wmake script to determine the maj.min from the PV_PLUGIN_PATH
since we have already defined the output path there with paraview
maj.min numbering.
Can now build with paraview from the operating system,
provided that it has develop headers available.
ParaView_VERSION=system
In the etc/config.sh/paraview setup, the maj.min is taken from
the corresponding `paraview --version` output and used when
defining the PV_PLUGIN_PATH.
During the build, the include path taken from `paraview-config`
for a system installation, from the guess installation root
of the paraview binary, or ParaView_DIR otherwise.
NB: using a system ParaView for building runTimePostProcessing is unsupported.
- these types of builds appear to have various library resolution issues
(eg, libexpat not being loaded). Additionally, the build logic does
not yet cover this type of use case.
- cfindObject() for const pointer access.
- getObject() for mutable non-const pointer access, similar to the
objectRegistry::getObjectPtr()
- cfindObject(), findObject(), getObject() with template type access
to also check the headerClassName.
For example,
cfindObject("U") -> good
cfindObject<volVectorField>("U") -> good
cfindObject<volScalarField>("U") -> nullptr
This allows inversion of looping logic.
1) Obtain the names for a particular Type
for (const word& objName : objs.sortedNames<Type>())
{
const IOobject* io = objs[objName];
...
}
2) Use previously obtained names and apply to a particular Type
for (const word& objName : someListOfNames)
{
const IOobject* io = objs.cfindObject<Type>(objName);
if (io)
{
...
}
}
- if FOAM_EXT_LIBBIN is unset and some scripts set this to /usr/lib*
as a fallback (eg, to avoid an undefined value) this will cause a
system library to be found before appropriate *_ARCH_PATH entry.
This was noticed during a scotch compilation without third-party:
resulting in the system library (/usr/lib64/libscotch.so) to be found
instead of the SCOTCH_ARCH_PATH location
(/usr/lib64/mpi/gcc/openmpi/lib64/).
Simply changing the search order doesn't work for use, since we wish
to retain a preference for any dynamic libraries discovered in a
real FOAM_EXT_LIBBIN.
Circumvent these issues by only taking libraries from
FOAM_EXT_LIBBIN if it also points to a location within ThirdParty.
- can now things like ref(), boundaryFieldRef(), primitiveFieldRef()
with an optional argument that avoids triggering any update events
Instead of
Field<Type>& iF = const_cast<Field<Type>&>(fld.primitiveField());
can now write
Field<Type>& iF = fld.primitiveFieldRef(false);
or simply
auto& iF = fld.primitiveFieldRef(false);
- can be used, for example, to visualize all wall cells - for quality
or other purposes - without requiring an intermediate faceSet for
the selection. Request arising from pending merge !213.
- now supports a parcel selection mechanism like vtkCloud,
giving the ability to select a subset of parcels.
For example, a given stride, or removal of parcels with a small
diameter.
Eg,
dataCloud output Time: 3.2
Applying parcel filtering to 994 parcels
- add stride 4
- subtract field U : (less 0.2)
After filtering using 214/994 parcels
- add output precision control for dataCloud
- vtkWrite with moving mesh was not updated the subsets properly,
which caused it to crash.
- foamToVTK -overwrite ignored for single region cases,
was working for multi-region cases
- minor documentation changes
Description
Calculates the energy spectrum for a structured IJK mesh
Usage
Example of function object specification:
energySpectrum1
{
type energySpectrum;
libs ("libfieldFunctionObjects.so");
}
Where the entries comprise:
\table
Property | Description | Required | Default value
type | type name: energySpectrum | yes |
log | write info to standard output | no | yes
\endtable
Output data is written to the file \<timeDir\>/energySpectrum.dat
- Added quoting to handle spaces in environment values in commit 50852b33
(#1007, #1008). However, quoting is only needed for eval mode.
In regular mode, quoting should not be part of the output, instead it
should be done on the caller side.
- provide edit for adjusting the ThirdParty and fallback site variables.
This is useful when packaging into a single directory, and possibly
without any ThirdParty dependencies.
- support '-prefix' (similar to auotconfig) as an alternative to
'-foamInstall'. Use this prefix to set the prefix directly.
Bypasses and disables the bash sourcing magic.
- Within strings it is preferable to use the "<etc>" instead.
Most use cases for the old "~OpenFOAM" expansion have been obsoleted
by the #includeEtc directive.
- use std::string instead of c-string for the string constants
- centralize some definitions of resources into foamVersion.H
Now expose some of the hard-coded values used in foamEtcFiles()
so that they can be known or even overridden as required.
Relocate to src/OpenFOAM/include as a constant location.
- uses wmake, without OpenFOAM libraries.
The application and libray serve as a minimal test case for wmake,
but can also be used to generate a minimal library/executable pair
target for testing of packaging etc.
- For compatibility, access to the old global names is provided via
macros
#define FOAMversion foamVersion::version
#define FOAMbuild foamVersion::build
#define FOAMbuildArch foamVersion::buildArch
- this isolation makes it easier to provide additional scoped methods
for dealing with version related information. Eg, printBuildInfo()
- foamVersion.H now includes stdFoam.H for consistent use
of compatibility compiler defines.
- move forward declaration of Detail, Module namespaces to stdFoam.H
- doxygen documentation of Foam namespace in stdFoam.H
- generalize output text wrapping, use for usage notes
- add -help-man option for generating manpage content for any OpenFOAM
application or solver.
bin/tools/foamCreateManpage as helper
- The changes in foamCleanPath introduced for issues (#1007, #1008)
include quoted output of the cleaned environment variable.
When used in foamCreateModuleInclude, the quotes make their way
into the final environment. Avoid this by using the -sh-env
eval format instead.
- add environment extraction of MANPATH changes
- 'unfriend' operators on dimensionSet, since they operate without
requiring access to non-public members.
- add missing invTransform() function for dimensionSet.
- make inv(const dimensionSet&) available as
operator~(const dimensionSet&), which can be used instead
of (dimless/ds).
- writing of dictionary entry with the name of the dimensionedType
suppressed if it is identical to the keyword.
This corresponds to the input requirements.
- deprecate dimensionedType constructors using an Istream in favour of
versions accepting a keyword and a dictionary.
Dictionary entries are almost the exclusive means of read
constructing a dimensionedType. By construct from the dictionary
entry instead of doing a lookup() first, we can detect possible
input errors such as too many tokens as a result of a input syntax
error.
Constructing a dimensionedType from a dictionary entry now has
two forms.
1. dimensionedType(key, dims, dict);
This is the constructor that will normally be used.
It accepts entries with optional leading names and/or
dimensions. If the entry contains dimensions, they are
verified against the expected dimensions and an IOError is
raised if they do not correspond. On conclusion, checks the
token stream for any trailing rubbish.
2. dimensionedType(key, dict);
This constructor is used less frequently.
Similar to the previous description, except that it is initially
dimensionless. If entry contains dimensions, they are used
without further verification. The constructor also includes a
token stream check.
This constructor is useful when the dimensions are entirely
defined from the dictionary input, but also when handling
transition code where the input dimensions are not obvious from
the source.
This constructor can also be handy when obtaining values from
a dictionary without needing to worry about the input dimensions.
For example,
Info<< "rho: " << dimensionedScalar("rho", dict).value() << nl;
This will accept a large range of inputs without hassle.
ENH: consistent handling of dimensionedType for inputs (#1083)
BUG: incorrect Omega dimensions (fixes#2084)
- use forwarding templates for the factory method
- avoid double use of dynamic_cast.
Don't need implicit use in isA<>, can use result directly
STYLE: updated iteration over HashTable of mesh objects
- was using coordinate-system and transform() which is the
local-to-global mapping, whereas it should be invTransform() which
is the global-to-local mapping
- this seems to be the only reliable means of obtaining the values.
Using typeName_() yields the wrong value.
Using the typeName causes initialization issues
(segfault when executing on some systems).
- support name filtering by class based on <Type> or predicates.
Eg,
objects.sortedNames<volScalarField>(namePattern);
vs objects.sortedNames(volScalarField::typeName, namePattern);
These can also be used directly for untyped name matching.
Eg,
objects.sortedNames<void>(namePattern);
Can also use a predicate:
objects.sortedNames(wordRe("vol.*Field"), namePattern);
objects.sortedNames
(
[](const word& clsName){ return clsName.startsWith("vol"); },
namePattern
);
- add IOobjectList::count() methods
- lookupClass<Type>() to use types instead of class variables.
- additional helpers for parallel: allNames(), checkNames()
- provide filterClasses() and filterObjects(), prune_0() method
forwarding to HashTable methods for easier access.
- in parameter form, check if it headerClassName() corresponds to the
specified class name
- in templated form, check if headerClassName() corresponds to the
Type:typeName value.
Specialization for <void> always returns true (ie, no checks)
- replace explicit use of word, wordRe, wordRes, wordHashSet as filters
with a MatchPredicate, since they all satisfy the requirements for
use a predicate. This change reduces code duplication, allows other
matcher types (eg, keyType) as well as lambda functions.
- add special treatment for a 'const char*' parameter
for lookupClass() and the now-deprecated single item lookup() method
to promote these parameters to 'word'.
- naming similar to objectRegistry, with unambiguous resolution.
The lookup() methods have different return types depending on the
calling parameter.
STYLE: use IOobjectListTemplates.C for implementations
- previously included as local definition within IOobjectList.C,
but will be adding more templated methods soon.
- adjust parameters (eg, matchName instead of matcher) to show their
function
ENH: handle objectRegistry::names<void>(...)
- this is equivalent to no Type restriction, and can be used when
filtering names. Eg,
obr.names<void>(wordRe..);
- Start brief descriptions with 'Deprecated(YYYY-MM)' so that it is
readily visible in the short method description. Consistent date
format (YYYY-MM), placed immediately after the \deprecated tag.
commit 3f9c7bf411
commit 3cf177e759
====
ENH: add geometric decomposition constraint (issue #921)
- geometric decomposition constraints may be used to prevent the
decomposition of regions of the mesh.
The geometric constraint is applied according to the face centres,
which define the connectivity between cells.
Specified in decomposeParDict
constraints
{
geometric
{
type geometric;
geometry
{
box1
{
type box;
min (-10 -10 -10);
max (1 1 1);
}
ball1
{
type sphere;
origin (-2 -2 1);
radius 1;
}
}
}
}
ENH: add 'grow' option for geometric decomposition constraint (issue #921)
- the 'grow' option includes an additional check to include cell faces
for any cell that already has two or more of its faces "unblocked".
This could indicate a connection over a corner, but does not distinguish
between connectivity introduced by the constraint and the connectivity
defined by other constraints.
ENH: geometric decomposition constraint using topoSetFaceSource (issue #921)
- replaced use of searchableSurface with a more general and
more efficient topoSetFaceSource instead.
Since searchableSurface is also available as a topoSetFaceSource,
there is no loss in functionality, but using topoSetFaceSource allow
directly looping over the faces without creating of an additional
List of volumeTypes.
This fixes the static-initialisation order problem - fieldTypes.C
referes to labelIOField etc. which are after it in Make/files and
hence the link order.
- now takes a const UList<T> as input and returns a List<T>
instead of trying to use the same ListType for both.
This avoids previously encountered issues when a UList was passed in.
- add specialized bitSet handling within subset(), where we can benefit
from faster traversal of sparse selections and have a better estimate
of the final output size.
- local token shifting was missing when getting the next file chunk
(while in the middle of parsing that text).
As well as adding the correct shifting, also tag the local buffer
with nullptr when it is done. Be extra paranoid and check the
raw buffer range before passing off to std::string.
- Default format is now XML binary (base64) instead of legacy format.
The old -xml option is redundant and ignored.
The new -legacy option can be used to force legacy output instead.
- Polyhedral decomposition is now off by default (old -poly is ignored).
The option -poly-decomp forces decomposition of polyhedrals into
primitive shapes.
- reduced memory footprint by reading and converting fields
successively.
- Creation of symlinks to processor files is no longer required or
desired. The old -noLinks option is ignored.
- Ignore -useTimeName option. Always number according to timeIndex.
- align input parameters and some of the behaviour with vtkWrite
The output is now postProcessing/<name> for similar reasoning as
mentioned in #866 - better alignment with other function objects, no
data collision with foamToEnsight output.
- separate controls for internal and boundary meshes
- can restrict conversion based on zone names, enclosing volumes,
bounding box.
- parallel output.
The output is now postProcessing/<name> for similar reasoning as
mentioned in #866 - better alignment with other function objects, no
collision with foamToVTK output.
- align the input parameters with those of vtkCloud so that we can
specify the ASCII precision and the padding width for the output
file names as well.
- emit TimeValue field, support file series generation
- support internal or boundary meshes, combining the result into a vtm
file.
- can restrict conversion based on zone names, enclosing volumes,
bounding box
- handle tmp fields in interpolate methods
- special method interpolateInternal() for creating a volume field
with zero-gradient treatment for patches from an internal field.
This method was previously also called interpolate(), but that
masked the ability to subset the internal field only.
Ensight output needs the volume field:
uses interpolateInternal().
VTK output has separate handling of internal and patch fields:
uses interpolate().
ENH: added fvMeshSubset mesh() method for baseMesh or subMesh.
- simplies coding when the fvMeshSubset may or may not be in active use.
ENH: update foamToEnsight to use newer methods in wrapped form
- static interpolate functions with renaming for manual use with
fvMeshSubset (when fvMeshSubsetProxy may be too limiting in
functionality)
- helps reduce clutter in the topoSetDict files.
Caveats when using this.
The older specification styles using "name" will conflict with the
set name. Eg,
{
name f0
type faceSet;
action add;
source patchToFace;
sourceInfo
{
name inlet;
}
}
would flattened to the following
{
name f0
type faceSet;
action add;
source patchToFace;
name inlet;
}
which overwrites the "name" used for the faceSet.
The solution is to use the updated syntax:
{
name f0
type faceSet;
action add;
source patchToFace;
patch inlet;
}
- faceBitSet, pointBitSet and faceBoolSet (similar to cellBitSet)
* allows topo sources in a wider variety of places.
* With copy or move constructors.
- cylinderToPoint, searchableSurfaceToFace, searchableSurfaceToPoint,
sphereToFace, sphereToPoint sources
- optional innerRadius for sphere and cylinder sources to treat as hollow.
- support "sets" as well as "set" for cellToCell, faceToFace... sources.
* convenience and avoids writing the set during processing.
- now applicable to labelLists.
Note:
in some situations it will be more efficient to use
Foam::identity() directly. Eg,
globalIndex globalCells(mesh.nCells());
...
labelList cellIds
(
identity(globalCells.localSize(), globalCells.localStart())
);
- previously simply read files until the input stream went bad and no
more lines could be read. With the more stringent checking of
values read (commit 0ce7e364a4) this approach causes problems.
Use the underlying tokenizer instead to decide about termination.
- for space-savings the VTK fields are normally written as 'float'
rather than double. When a double field contains very large values,
these can result in a overflow when converted to float.
Now trap these with the appropriate numeric limits.
No warning when these values are clipped: it should be readily
apparent from the output.
ENH: handle symmTensor component swapping directly on VTK output.
- use VTK output routines in vtkSurfaceWriter to benefit from the
above changes
- a failed attempt to read a value (eg, word, label, scalar) from a
stream now always provokes a FatalIOError.
This helps avoid some difficult to trace input errors.
- old 'DELETE' enum was easily confused with 'REMOVE', which removes
the set, not the elements from the set.
- provide corresponding subtractSet() method
STYLE: HashSet set/unset instead of insert/erase methods in topoSetSource
- simplifies switching to/from bitSet storage
- make hasFaceId a top-level virtual method and remove keepIds
equivalent from sampledTriSurfaceMesh. This makes the property
available without casting.
- New sampling type 'none'.
Can be used to temporarily disable a sampling surface definition,
or to provide boilerplate for overwriting later.
- as part of the cleanup of dictionary access methods (c6520033c9)
made the dictionary class single inheritance from IDLList<entry>.
This eliminates any ambiguities for iterators and allows
for simple use of range-for looping.
Eg,
for (const entry& e : topDict))
{
Info<< "entry:" << e.keyword() << " is dict:" << e.isDict() << nl;
}
vs
forAllConstIter(dictionary, topDict, iter))
{
Info<< "entry:" << iter().keyword()
<< " is dict:" << iter().isDict() << nl;
}
- more dictionary-like methods, enforce keyType::LITERAL for all
lookups to avoid any spurious keyword matching.
- new readEntry, readIfPresent methods
- The get() method replaces the now deprecate lookup() method.
- Deprecate lookupOrFailsafe()
Failsafe behaviour is now an optional parameter for lookupOrDefault,
which makes it easier to tailor behaviour at runtime.
- output of the names is now always flatted without line-breaks.
Thus,
os << flatOutput(someEnumNames.names()) << nl;
os << someEnumNames << nl;
both generate the same output.
- Constructor now uses C-string (const char*) directly instead of
Foam::word in its initializer_list.
- Remove special enum + initializer_list constructor form since
it can create unbounded lookup indices.
- Removd old hasEnum, hasName forms that were provided during initial
transition from NamedEnum.
- Added static_assert on Enum contents to restrict to enum or
integral values. Should not likely be using this class to enumerate
other things since it internally uses an 'int' for its values.
Changed volumeType accordingly to enumerate on its type (enum),
not the class itself.
- this helps for many cases outlined in issue #1007, but can also be
useful when simply using symlinks for shorter or reorganized
directory structures.
Update of overRhoPimpleDyMFoam and overInterDyMFoam solvers.
Adding corresponding tutorials with best possible settings
The main effort was put on reducing pressure spikes as the
stencil change with hole cells on the background mesh.
- writes positions and a single field (eg, diameter) in plain ASCII files,
suitable for importing in a spreadsheet or manipulation with
scripting tools.
- code integrated from
https://develop.openfoam.com/Community/OpenFOAM-addOns
New name: findObject(), cfindObject()
Old name: lookupObjectPtr()
Return a const pointer or nullptr on failure.
New name: findObject()
Old name: --
Return a non-const pointer or nullptr on failure.
New name: getObjectPtr()
Old name: lookupObjectRefPtr()
Return a non-const pointer or nullptr on failure.
Can be called on a const object and it will perform a
const_cast.
- use these updated names and functionality in more places
NB: The older methods names are deprecated, but continue to be defined.
- these currently only with bool parameters, but the return value should
nonetheless always be a bool value:
andOp(), orOp(), lessOp(), lessEqOp(), greaterOp(), greaterEqOp()
- renamed the unused eqEqOp() to equalOp() for naming consistency with
the equal() global function.
ENH: equalOp() specialization for scalars
- function object version of the equal() function.
The default constructor uses the same tolerance (VSMALL),
but can also supply an alternative tolerance on construction.
Description
Calculates the spatial minimum and maximum extents of a field
The extents are derived from the bound box limits after identifying
the locations where field values exceed the user-supplied threshold
value.
Usage
Example of function object specification:
fieldExtents1
{
type fieldExtents;
libs ("libfieldFunctionObjects.so");
...
writeToFile yes;
log yes;
fields (alpha);
threshold 0.5;
patches ();
}
Where the entries comprise:
Property | Description | Required | Default
type | type name: fieldExtents | yes |
writeToFile | write extents data to file | no | yes
log | write extents data to standard output | no | yes
internalField | Process the internal field | no | yes
threshold | Field value to identify extents boundary | yes |
referencePosition | Reference position | no | (0 0 0)
fields | list of fields to process | yes |
patches | list of patches to process | no | <all>
Output data is written to the file \<timeDir\>/fieldExtents.dat
Note
For non-scalar fields, the magnitude of the field is employed and
compared to the threshold value.
- with the 'cwd' optimization switch it is possible to select the
preferred behaviour for the cwd() function.
A value of 0 causes cwd() to return the physical directory,
which is what getcwd() and `pwd -P` return.
Until now, this was always the standard behaviour.
With a value of 1, cwd() instead returns the logical directory,
which what $PWD contains and `pwd -L` returns.
If any of the sanity checks fail (eg, PWD points to something other
than ".", etc), a warning is emitted and the physical cwd() is
returned instead.
Apart from the optical difference in the output, this additional
control helps workaround file systems with whitespace or other
characters in the directory that normally cause OpenFOAM to balk.
Using a cleaner symlink elsewhere should skirt this issue.
Eg,
cd $HOME
ln -s "/mounted volume/user/workdir" workdir
cd workdir
# start working with OpenFOAM
- foamCleanPath now only splits the environment variable on ':', which
allows other directories with spaces or '(..)' etc to pass through
without major issue.
- The filter arguments are split on whitespace, colons or semi-colons.
- use keyType::option enum to consolidate searching options.
These enumeration names should be more intuitive to use
and improve code readability.
Eg, lookupEntry(key, keyType::REGEX);
vs lookupEntry(key, false, true);
or
Eg, lookupEntry(key, keyType::LITERAL_RECURSIVE);
vs lookupEntry(key, true, false);
- new findEntry(), findDict(), findScoped() methods with consolidated
search options for shorter naming and access names more closely
aligned with other components. Behave simliarly to the
methods lookupEntryPtr(), subDictPtr(), lookupScopedEntryPtr(),
respectively. Default search parameters consistent with lookupEntry().
Eg, const entry* e = dict.findEntry(key);
vs const entry* e = dict.lookupEntryPtr(key, false, true);
- added '*' and '->' dereference operators to dictionary searchers.
- use the dictionary 'get' methods instead of readScalar for
additional checking
Unchecked: readScalar(dict.lookup("key"));
Checked: dict.get<scalar>("key");
- In templated classes that also inherit from a dictionary, an additional
'template' keyword will be required. Eg,
this->coeffsDict().template get<scalar>("key");
For this common use case, the predefined getXXX shortcuts may be
useful. Eg,
this->coeffsDict().getScalar("key");
- not used by the ISstream parser, but suitable for other parsing
methods where true/false concept should be distinguishable from
integer values.
Only constructed via the token::boolean() static method, not
directly assignable.
This avoids any potential ambiguities with label.
- this also removes the '-newTimes' option cruft from appearing
everywhere. reconstructPar and redistributePar are unaffected by this
since they define their own -newTimes option independently.
- same as !isPattern(), but can be more readable.
- add wordRe enum state 'UNKNOWN', which has the identical value as
'DETECT' but used for a return value.
- makes an easier overview of the rotation matrix coefficients
(issue #863).
Provided as a distinct commit for easier examination of the lines changed.
Previously the coordinate system functionality was split between
coordinateSystem and coordinateRotation. The coordinateRotation stored
the rotation tensor and handled all tensor transformations.
The functionality has now been revised and consolidated into the
coordinateSystem classes. The sole purpose of coordinateRotation
is now just to provide a selectable mechanism of how to define the
rotation tensor (eg, axis-angle, euler angles, local axes) for user
input, but after providing the appropriate rotation tensor it has
no further influence on the transformations.
--
The coordinateSystem class now contains an origin and a base rotation
tensor directly and various transformation methods.
- The origin represents the "shift" for a local coordinate system.
- The base rotation tensor represents the "tilt" or orientation
of the local coordinate system in general (eg, for mapping
positions), but may require position-dependent tensors when
transforming vectors and tensors.
For some coordinate systems (currently the cylindrical coordinate system),
the rotation tensor required for rotating a vector or tensor is
position-dependent.
The new coordinateSystem and its derivates (cartesian, cylindrical,
indirect) now provide a uniform() method to define if the rotation
tensor is position dependent/independent.
The coordinateSystem transform and invTransform methods are now
available in two-parameter forms for obtaining position-dependent
rotation tensors. Eg,
... = cs.transform(globalPt, someVector);
In some cases it can be useful to use query uniform() to avoid
storage of redundant values.
if (cs.uniform())
{
vector xx = cs.transform(someVector);
}
else
{
List<vector> xx = cs.transform(manyPoints, someVector);
}
Support transform/invTransform for common data types:
(scalar, vector, sphericalTensor, symmTensor, tensor).
====================
Breaking Changes
====================
- These changes to coordinate systems and rotations may represent
a breaking change for existing user coding.
- Relocating the rotation tensor into coordinateSystem itself means
that the coordinate system 'R()' method now returns the rotation
directly instead of the coordinateRotation. The method name 'R()'
was chosen for consistency with other low-level entities (eg,
quaternion).
The following changes will be needed in coding:
Old: tensor rot = cs.R().R();
New: tensor rot = cs.R();
Old: cs.R().transform(...);
New: cs.transform(...);
Accessing the runTime selectable coordinateRotation
has moved to the rotation() method:
Old: Info<< "Rotation input: " << cs.R() << nl;
New: Info<< "Rotation input: " << cs.rotation() << nl;
- Naming consistency changes may also cause code to break.
Old: transformVector()
New: transformPrincipal()
The old method name transformTensor() now simply becomes transform().
====================
New methods
====================
For operations requiring caching of the coordinate rotations, the
'R()' method can be used with multiple input points:
tensorField rots(cs.R(somePoints));
and later
Foam::transformList(rots, someVectors);
The rotation() method can also be used to change the rotation tensor
via a new coordinateRotation definition (issue #879).
The new methods transformPoint/invTransformPoint provide
transformations with an origin offset using Cartesian for both local
and global points. These can be used to determine the local position
based on the origin/rotation without interpreting it as a r-theta-z
value, for example.
================
Input format
================
- Streamline dictionary input requirements
* The default type is cartesian.
* The default rotation type is the commonly used axes rotation
specification (with e1/e2/3), which is assumed if the 'rotation'
sub-dictionary does not exist.
Example,
Compact specification:
coordinateSystem
{
origin (0 0 0);
e2 (0 1 0);
e3 (0.5 0 0.866025);
}
Full specification (also accepts the longer 'coordinateRotation'
sub-dictionary name):
coordinateSystem
{
type cartesian;
origin (0 0 0);
rotation
{
type axes;
e2 (0 1 0);
e3 (0.5 0 0.866025);
}
}
This simplifies the input for many cases.
- Additional rotation specification 'none' (an identity rotation):
coordinateSystem
{
origin (0 0 0);
rotation { type none; }
}
- Additional rotation specification 'axisAngle', which is similar
to the -rotate-angle option for transforming points (issue #660).
For some cases this can be more intuitive.
For example,
rotation
{
type axisAngle;
axis (0 1 0);
angle 30;
}
vs.
rotation
{
type axes;
e2 (0 1 0);
e3 (0.5 0 0.866025);
}
- shorter names (or older longer names) for the coordinate rotation
specification.
euler EulerRotation
starcd STARCDRotation
axes axesRotation
================
Coding Style
================
- use Foam::coordSystem namespace for categories of coordinate systems
(cartesian, cylindrical, indirect). This reduces potential name
clashes and makes a clearer declaration. Eg,
coordSystem::cartesian csys_;
The older names (eg, cartesianCS, etc) remain available via typedefs.
- added coordinateRotations namespace for better organization and
reduce potential name clashes.
This fix changes how the intersections loop ignores previously
intersected faces. It now marks them by their index so that subsequent
iterations ignore them.
Before this change, after an intersection was found the start point was
advanced by a small amount to move the past the intersection. The
problem with this was if multiple boundary faces or the end point were
in close proximity to the intersection then the move forward might span
them. This could lead to intersections being missed or counted multiple
times, in some cases indefinitely.
Based on a patch contributed by Mattijs Janssens
Resolves bug report https://bugs.openfoam.org/view.php?id=1147
- Can now retrieve or set a column/row of a tensor.
Either compile-time or run-time checks.
Get
t.col<1>(); t.col(1);
t.row<1>(); t.row(1);
Set
t.col<1>(vec); t.col(1,vec);
t.row<1>(vec); t.row(1,vec);
The templated versions are compile-time checked
t.col<3>();
t.col<3>(vec);
The parameter versions are run-time checked
t.col(3);
t.col(3,vec);
ENH: provide named access to tensor/tensor inner product as inner()
Helper function to calculate the current face area vs the area returned
from the current point locations. Useful for ACMI-type baffles where we
scale the face areas without moving points.
- nBoundaryFaces() is often used and is identical to
(nFaces() - nInternalFaces()).
- forward the mesh nInternalFaces() and nBoundaryFaces() to
polyBoundaryMesh as nFaces() and start() respectively,
for use when operating on a polyBoundaryMesh.
STYLE:
- use identity() function with starting offset when creating boundary maps.
labelList map
(
identity(mesh.nBoundaryFaces(), mesh.nInternalFaces())
);
vs.
labelList map(mesh.nBoundaryFaces());
forAll(map, i)
{
map[i] = mesh.nInternalFaces() + i;
}
- this provides internal consistency and allows direct use of the
coordinate angle with sin(), cos() functions.
It eliminates potential issues that could otherwise arise from
alternative user input.
Eg, in mixerFvMesh it would have previously been possible to specify
the coordinate system to use degrees or radians, but these units were
not checked when determining the tangential sweep positions.
NOTE: this may represent a breaking change if user coding has been
relying on cylindrical coordinate system in degrees.
Previously had 3 possibilities for handling exposed internal faces
1. use default "oldInternalFaces"
2. specify -patch, to use the specified (existing) patch
3. specify -patches, to use the geometrically closest patches
Now relaxed the restriction on -patch to allow specification of a new
(not yet existing) patch name. This improves flexibility, but won't
catch typing mistakes.
Harmonize behaviour of -patches and -patch. When -patches is used to
specify a single, non-regex patch name, it now behaves identically to
-patch. Since the getList handling for options already allows special
treatment for single parameter lists, the following will work
identically:
subsetMesh -patch patch0
subsetMesh -patches patch0
subsetMesh -patches '( patch0 )'
In the future it might be reasonable to fully combine the behaviour of
'-patch' and '-patches' and treat them as aliases for each other.
ENH: support subsetMesh on a cellZone.
- when the '-zone' option is specified, the command argument is treated
as the name (or names) of cellZones to be selected instead of as the
name of the cellSet.
The command argument can be a single word, regex, or list of
word/regex.
Eg,
subsetMesh -zone -patch mypatch mixer
subsetMesh -zone -patch mypatch '(mixer "moving.*" )'
STYLE: simplify set handling and other code cleanup in subsetMesh
Using: OpenFOAM-plus (see www.OpenFOAM.com)
Build: plus-7ab57cc5d014 (OPENFOAM=1807)
Arch: LSB;label=32;scalar=64
- This can be useful for development versions, or when the version
at build time uses some other naming scheme (#1010)
- 'signed' input parameter only mandatory for distance > 0.
A distance <= 0 is always signed and the input parameter is ignored.
- Use normal distance when distance == 0. This has no effect when
the surface has no open edges, but improves on rounding issues
around the zero crossing when the surface has open edges.
This may still need future revisiting.
- use parallel list writing, beginDataArray methods.
- use static_assert to restrict conversion of non-label integral types
- cache .vtp.series information by fileName instead of by cloud name.
This issues if the output directory changes, and simplifies code.
ENH: emit TimeValue in files generated by vtkCloud
- additional information for passing to ParaView
ENH: vtkCloud output to postProcessing/ (issue #866)
- better alignment with other function objects, no collision with
foamToVTK output.
- avoid duplicate code by relocating cellZone selection and bounding box
sub-selection into cuttingPlane and cuttingSurfaceBaseSelection.
Allows reuse by inherited classes (sampledPlane, surfMeshSamplePlane).
- takes two general actions:
1. orient edge in canonical direction (positive gradient) and detect
any edge intersection.
2. edge intersection alpha (0-1)
- refactor into a cuttingSurfaceBase intermediate class with the
actions as templated parameters rather than function pointers. This
allows the use of lambda functions with captures from the caller.
- The test condition
[ -n "$cur" -a ... ]
fails if $cur starts with '-le', which bash interprets as a further
test op. Splitting the test condition solves the problem:
[ -n "$cur" ] && [ ... ]
- Since the local edges are oriented according to the gradient,
they can also be used to determine the correct face orientation.
This generalizes the algorithm for future reuse.
- Provides a means of accumulating file entries for generating vtm
by accumulate blocks, datasets and writing them later.
Only a single block depth is currently supported and the methods
are kept fairly simple.
- Output formats such as vtp, vtu follow a particular internal data
structure (HEAD, FIELD_DATA, PIECE, CELL_DATA/POINT_DATA) and other
output conventions. This writer base tracks these expected output
states internally to help avoid logic errors in the callers.
- parallel list output for foamVtkOutput
- simplified '.series' file output
- beginDataArray() method instead of openDataArray() + closeTag()
since this seems to be the most common use anyhow.
With an optional argument for leaving the tag open, this works the
same as openDataArray() which may be deprecated in the future.
- begin/end methods for CellData, PointData, FieldData (commonly used)
- templating parameters for file headers, content version,
legacy fields. This improves coding robustness and convenience of use.
- use formatter and higher-level methods for legacy output
- attribute quoting character now part of the formatter itself
instead of as an argument for xmlAttr().
Toggle with quoting() method.
- pair-wise processing of xml attributes, which also allows them to be
passed as optional entries when creating an xml tag.
- xmlComment with multiple arguments
- allows cell point labels will use global numbering, but only for
unmerged points. We'd ideally like to avoid point merging per se,
and instead use VTK point blanking instead (as required).
This approach allows parallel collation of the output into a single
piece directly.
- there were previously no hashing mechanisms for lists so they
would fall back to the definition for primitives and hash the
memory location of the allocated List object.
- provide a UList::Hash<> sub-class for inheritance, and also a global
specialization for UList<T>, List<T> such that the hash value for
List<List<T>> cascades properly.
- provide similar function in triFace to ensure that it remains
similar in behaviour to face.
- added SymmHash to Pair, for use when order is unimportant.
STYLE: use string::hash() more consistently
- no particular reason to use Hash<word>() which forwards to
string::hash() anyhow
- With argList::noFunctionObjects() we use the logic added in
4b93333292 (issue #352)
By removing the '-noFunctionObjects' option, we automatically
suppress the creation of function-objects via Time (with argList
as a parameter).
There is generally no need in these cases for an additional
runTime.functionObjects().off() statement
Use the argList::noFunctionObjects() for more direct configuration
and reduce unnecessary clutter in the -help information.
In previous versions, the -noFunctionObjects would have been redundant
anyhow, so we can also just ignore it now instead.
- allows use with any container with begin(), end() and where the
"*iterator" dereference returns a label, which is used for indexing
into the list of points.
This container could be labelUList, bitSet, labelHashSet, etc
- takes a direct approach of determining which cells are cut and walks
the cell faces directly to build the resulting surface.
- better handling of corner cases.
* Avoids redundant points when the cut passes exactly through a
mesh point.
* Supresses generation of duplicates faces when the plane cut
coincides exactly with a mesh face.
- for severely concave cells where the plane cuts a face multiple times
there is currently no remedial action taken, except to note the
failure and unwind the insertion of the corresponding points and
faces.
- signedDistance() method is like distance() but retains
the positive/negative sign for the side of the plane.
- the sign() method returns the sign as -1,0,+1 integer for
classification purposes where it is important to distinguish between
a zero value and a positive value (eg, for cutting). Optional
tolerance can be supplied to round for zero.
- refactor and inlined simple and frequently used methods.
- add boundBox faceCentre() method, which can be useful for creating
clipping planes from a bounding box.
Relocated treeBoundBox faceNormals to boundBox since they apply
equally there - the meaning of the faces (x-min, x-max, etc)
is the same, even if the point addressing for the faces differs.
- rationalized code dealing with extraction of name or indices from
coordinateSystems, polyBoundaryMesh, faBoundaryMesh, fvBoundaryMesh,
ZoneMesh to use internal implementations that allow direct
searching/matching without building an intermediate list of names.
- simpler and more efficient handling of patch group matching.
- centralizes IOobject handling and treatment of alternative locations.
If an alternative file location is specified, it will be used instead.
- provide decompositionMethod::canonicalName instead of using
"decomposeParDict" in various places.
- treat as a List constant without requiring inclusion of ListOps.H
- replace use of emptyList<label>() with emptyLabelList directly.
The emptyList<T>() casting is disallowed with many modern compilers
and now marked as deprecated (expect early removal).
- relocate labelList typedef to List.H for more general access.
Similar reasoning to having labelUList defined in UList.H
- makes for easier extraction of boundary values since it encapsulates
start/size directly.
Eg,
SubList<T>(allValues, patches.range());
or
bitSet(blocked, patches.range(patchi));
- allows for simpler unpacking of a full list, or list range into any
sufficiently large integral type.
For example,
processorPolyPatch pp = ...;
UOPstream toNbr(pp.neighbProcNo(), pBufs);
toNbr << faceValues.unpack<char>(pp.range());
General:
* -roots, -hostRoots, -fileHandler
Specific:
* -to <coordinateSystem> -from <coordinateSystem>
- Display -help-compat when compatibility or ignored options are available
STYLE: capitalization of options text
- avoids compiler ambiguity when virtual methods such as
IOdictionary::read() exist.
- the method was introduced in 1806, and was thus not yet widely used
- behaves the same as the valid() method, but can be queried directly
like a normal raw pointer and as per std::unique_ptr.
Eg,
autoPtr<T> ptr = ...
if (ptr) ...
- advanced options are not displayed with -help, but only with
-help-full, which helps retain a better overview of the standard
options. Replaces previous ad hoc suppression of -listSwitches,
-listRegisteredSwitches etc.
- simplifies usage.
Support syncPar check on names() to detect inconsistencies.
- simplify readFields, ReadFields and other routines by using these
new methods.
- what was previously termed 'setLargeCellSubset()' is now simply
'setCellSubset()' and supports memory efficient interfaces.
The new parameter ordering avoids ambiguities caused by default
parameters.
Old parameter order:
setLargeCellSubset
(
const labelList& region,
const label currentRegion,
const label patchID = -1,
const bool syncCouples = true
);
New parameter order:
setCellSubset
(
const label regioni,
const labelUList& regions,
const label patchID = -1,
const bool syncCouples = true
);
And without ambiguity:
setCellSubset
(
const labelUList& selectedCells,
const label patchID = -1,
const bool syncCouples = true
);
- support bitSet directly for specifying the selectedCells for
memory efficiency and ease of use.
- Additional constructors to perform setCellSubset() immediately,
which simplifies coding.
For example,
meshParts.set
(
zonei,
new fvMeshSubset(mesh, selectedCells)
);
Or even
return autoPtr<fvMeshSubset>::New(mesh, selectedCells);
- enclosed with a #ifdef Foam_argList_1712 .. #endif pair
(defined by default).
In a later release, this can be disabled by default.
ENH: add input length check for -hostRoots option
Also extended the cubic equation test routine and modified the error
methods so that they more accurately generate the round of error of
evaluation.
This resolves bug report https://bugs.openfoam.org/view.php?id=3015
- instead of dict.lookup(name) >> val;
can use dict.readEntry(name, val);
for checking of input token sizes.
This helps catch certain types of input errors:
{
key1 ; // <- Missing value
key2 1234 // <- Missing ';' terminator
key3 val;
}
STYLE: readIfPresent() instead of 'if found ...' in a few more places.
- the opposite problem from issue #762. Now we also test if the input
token stream had any tokens at all.
- called by the dictionary get<> and readEntry() methods.
- ignore implicit-fallthrough for ragel generated code.
- add -Wno-deprecated-declarations for c++LESSWARN.
These principally associated with older CGAL versions and their use
of particular mpfr routines.
Some special adjustments are undertaken for distance = 0.
- With the isoSurfaceCell algorithm is used, additional checks for open
surfaces edges are used to limit the extend of resulting distance
surface. The resulting surface elements will not, however, contain
partial cell coverage.
- Always treated as signed (ignoring the input value), since it is
nearly impossible to generate any surface otherwise.
- the original intention was to avoid vtp output when the clouds are
empty anyhow. However, it is useful for post-processing to have
clouds with zero parcels (eg, before the start of injection).
Pruning of empty clouds is now an option in the vtkCloud dictionary
controls, with the default being false (no pruning). This represents
a non-breaking change in behaviour since it generates more output
than previously.
Example,
{
type vtkCloud;
//- Suppress writing of empty clouds (default: false)
prune true;
}
This method waits until all the threads have completed IO operations and
then clears any cached information about the files on disk. This
replaces the deactivation of threading by means of zeroing the buffer
size when writing and reading of a file happen in sequence. It also
allows paraFoam to update the list of available times.
Patch contributed by Mattijs Janssens
Resolves bug report https://bugs.openfoam.org/view.php?id=2962
- functionObjectLibs -> libs
- redirectType -> name
- change deprecated writeCompression flags types to Switch.
- cleanup some trailing ';;' from some dictionaries
- The problem is not 100% reproducible, but be somewhat conservative
and now only close(stdin) for pure background (daemon-like) use of
Foam::system(), where it can be useful.
Using Foam::system() for launching background processes is currently
only used for the doc browser.
- since 1612, FOAM_INST_DIR and foamInstDir longer have any
special meanings when sourcing the bashrc or cshrc files.
Thus no need for special treatment in any of the dispatch wrappers.
Retained FOAM_INST_DIR as (unexported) variable in etc/bashrc,
just in case people are using patched versions of etc/bashrc
as part of their installation.
ENH: relax prefix restrictions on foamCreateVideo (issue #904)
- shift the implicit '.' to be part of the default prefix. This allows
things like "-image myimages_00" to work as might be expected.
- respect trailing '-', '.', '_' for the image prefix name.
For example,
-image press_ to accept press_*.png
- additional -mask width option (for avconv)
- The additional output generated by #calc directives in the
controlDict or decomposeParDict causes issues for the RunFunctions
extraction of 'application' and 'numberOfSubdomains'.
Avoid by using -disableFunctionEntries, which also has the side-effect
of disabling '#include'.
- major() and minor() are GNU macros in sys/sysmacros.h
and generates warning on some systems (eg, Ubuntu 18.04)
use getMajor() and getMinor() as method names instead.
- corrected the mass based correction and updated the misleading function
arguments
- moved the option to the optimisation switches, e.g.:
OptimisationSwitches
{
experimentalDdtCorr 1;
}
- default remains off/no (0)
twoPhaseMixtureThermo writes the temperatures during construction only
for them to be read again immediately after by construction of the
individual phases' thermo models. When running with collated file
handling this behaviour is not thread safe. This change deactivates
threading for the duration of this behaviour.
Patch contributed by Mattijs Janssens
- for larger problems with a smaller region of interest, can apply a
bounding to limit the size of the ensight geometry and fields created.
Since the implementation uses a fvMeshSubset, there is an additional
per-process memory overhead.
A high output frequency should be avoided with moving meshes, since
this indirectly forces a frequent update of the submesh.
- const version of offsets().
- empty() method to test for empty offsets, or zero overall size
- reset() methods for reseting the sizes. For example, when the context
has shifted slightly.
- localStart() methods, similar to localSize() methods
STYLE: make globalIndex single parameter constructors explicit
- added line::last() for consistency with edge::last()
- adjusted unitVec() to return Zero for small vectors.
Consistent with VectorSpace normalised() and vector::normalise()
- Don't remove the constant/polyMesh directory if it contains a
blockMeshDict or blockMeshDict.m4 file. Offer a reminder that
system/ is the normal place for it.
- add additional control via a Foam::infoDetailLevel flag, which is
supported by a 'DetailLevel' macro. Eg,
DetailLevel << "some information" << nl
- When infoDetailLevel is zero, the stdout for all Foam::system() calls
are also redirected to stderr to prevent child output from
appearing on the parent.
- close stdin before exec in system call.
- convenient way to temporarily suspend the SIGFPE handler.
Eg,
// Normal code with SIGFPE enabled ...
sigFpe::set();
{
// Ignore SIGFPE in this scope ...
sigFpe::ignore noFpeHandling;
...
}
- use Enum instead of NamedEnum
- shorter form for dimensionedScalar
- reduce verbosity about missed seeding for DTRM cloud.
Re-enable old warnings in debug mode.
- some paraview versions (eg, on windows) don't support float, only double.
This mostly affected the vtkSurfaceWriter.
The foamToVTK is also affected, but since it also supports the XML
output formats (vtp, vtu) these can be used instead.
- affected manually generated legacy output (vtkSetWriter, vtkSurfaceWriter)
- the order emitted by vtkSetWriter remains, but needs to revisited again.
- this provides easily sortable names.
The time information is available via the corresponding .series
file, which can also be loaded directly with ParaView 5.5 or later.
For further redundancy, time information is saved in the first XML
comment inside of the .vtp files. For example,
<!-- cloud=limestoneCloud1 time=0.005 index=200 -->
- now report as "min = XX max = YY average = ZZ"
instead of as "min/max/average = XX, YY, ZZ"
this makes it easier to parse any particular value
(eg, with foamLog)
- should use bitSet::set() and not bitSet::operator[] to auto-vivify
out-of-range entries
- use bitSet::test() instead of bitSet::operator[] when testing
non-const variables - circumvents any potential out-of-range issues.
- Since 'bool' and 'Switch' use the _identical_ input mechanism
(ie, both accept true/false, on/off, yes/no, none, 1/0), the main
reason to prefer one or the other is the output.
The output for Switch is as text (eg, "true"), whereas for bool
it is label (0 or 1). If the output is required for a dictionary,
Switch may be appropriate. If the output is not required, or is only
used for Pstream exchange, bool can be more appropriate.
- Always used for optional dictionary entries, since these are individual
values, and not meant to be embedded in a larger stream of tokens.
Methods:
- lookupOrDefault, lookupOrAddDefault, lookupOrDefaultCompat
- readIfPresent, readIfPresentCompat
- Handling mandatory dictionary entries is slightly more complex,
since these may be part of larger stream of tokens, and are often
used in a constructor context. For example,
word modelType(dict.lookup("type"));
Or they are used without a definite context. For example,
dict.lookup("format") >> outputFormat;
Newly introduced methods for mandatory dictionary entries:
- get, getCompat
- read, readCompat
In a constructor or assignment context:
word modelType(dict.get<word>("type"));
outputFormat = dict.lookup("format");
without copy/move (similar to readIfPresent):
dict.read("format", outputFormat);
- improves backward compatibility and more naming consistency.
Retain setMany(iter1, iter2) to avoid ambiguity with the
PackedList::set(index, value) method.
Basic directional refinement:
- only for coordinate aligned meshes
- only for refinementRegions
See the mesh/snappyHexMesh/aerofoilNACA0012_directionalRefinement
tutorial.
- the current working path with replacements for base-level
OpenFOAM env variables such as FOAM_RUN, WM_PROJECT_DIR,
WM_PROJECT_USER_DIR etc
Can be used directly from the command-line or embedded into a
command prompt. For example,
PS1='$(foamPwd)\n\u\$ '
- aliases for user solver/utilities located under "$WM_PROJECT_USER_DIR":
(ufoam, uapp, usol, uutil)
- using const reference to temporary was failing. Remedy by using a
direct copy, which is a reasonable solution since surfZone content
is quite minimal.
- downgrades some diagnostics about nonconformant code from errors to
warnings. Oddly enough, the errors actually arise from STL library
elements shipped with gcc itself. Affects kahip compilation with
gcc-6, gcc-7
The minimum number of particles per parcel can now be set in the
injection model input, e.g.:
model1
{
type ...;
massTotal ...;
parcelBasisType ...;
minParticlesPerParcel 1; <-- new optional entry
SOI ...;
...
Uses a value of 1 by default if the entry is not present. The value of
1 is generally recommended and beneficial for coupled cases where small
time steps can lead to the injection of too many parcels and subsequently
greatly over-predict the particle source contributions (momentum, heat,
mass transfer etc)
- problems when the cloud was not available on all processors.
- NB: ensight measured data only allows a single cloud, but
foamToEnsight writes all clouds.
- these were previously taken from region-local directories
(eg, constant/region/triSurface), but this becomes difficult to
manage when there are many files and regions.
- The central InfoSwitch "writeLagrangianPositions" allows writing an
additional Lagrangian "positions" file, but these were not being
written by reconstructPar. These are now also written in reconstructPar
if the central writeLagrangianPositions InfoSwitch is enabled.
NOTES
- "positions" are reconstructed from the processors "coordinates" file
- decomposePar will not attempt to create or redistribute any
"positions" files
switch
The new lowReCorrection entry can be used to ensure that the low-Re
mode is only applied when its value is on/true, e.g.
lowReCorrection on;
When active, the low-Re mode is active when the local y+ is less than
the calculated y+_laminar. When inactive, the high-Re form is employed
irrespectively of the local y+.
It has a defaulrt value of off/false for backwards compatibility with
OpenFOAM v1706
Computes the heat transfer coefficient [W/m2/K] using a run-time
selectable model:
- ReynoldsAnalogy
- fixedReferenceTemperature
- localReferenceTemperature
further investigation on the consequences on dynamic mesh for compressibleInterDyMFoam.
alphaSuSp.H has to be added in the solver folder in order to make it compatible with the alpha Eq.
NOTE: The radiative flux (qr) is positive when the heat flux is going into the wall,
this is oposite the the he flux which is positive going out of the wall.
The characteristics of the base scheme are recovered by applying an
explicit correction to the upwind scheme weights.
Usage
Example of the \c deferredCorrection scheme applied to the \c linear
scheme:
\verbatim
divSchemes
{
.
.
div(phi,U) Gauss deferredCorrection linear;
.
.
}
\endverbatim
Based on a generalised form of a deferred correction linear scheme
supplied by CFD Software E+F GmbH
Based on the reference:
Spalart, P. R. and Rumsey, C. L. (2007).
Effective Inflow Conditions for Turbulence Models in Aerodynamic
Calculations
AIAA Journal, 45(10), 2544 - 2553.
The decay control default is off for backwards compatibility. To enable
it, add the following to the coefficients dictionary
// Optional decay control
decayControl yes;
kInf \<far-field k value\>;
omegaInf \<far-field omega value\>;
- regression introduced by part of commit 2787a8664d.
Specifically the way that scalarRanges is written, it parses through
until it hits invalid input. This works fine with an IStringStream,
but the ITstream is pickier and reports this as being an error.
So revert to IStringStream and be less picky about argList parsing.
in the longer-term, should fix scalarRanges instead.
- required if there is no system openmp and libomp or libgomp are
only found in the clang hierarchy
STYLE: add some notes in the openmp rules.
- the _OPENMP macro is now used in low-level testing files
- The -rotate-angle option allows convenient specification of a
rotation about an arbitrary axis. Eg, -rotate-angle '((1 1 1) 45)'
- The -origin option can be used to temporarily shift the origin
for the rotation operations. For example,
-origin '(0 0 1)' -rotate-angle '((1 0 0) 180)'
for mirroring.
heat rejection
The new optional entry targetQdot can be used to specify a target heat
rejection. This is additionally controlled using the
targetQdotCalcInterval and targetQdotRelax entries which default to
values of 5 and 0.5, respectively.
- relocate WM_COMPILER_ARCH, WM_COMPILER_LIB_ARCH from
etc/{bashrc,cshrc} to etc/config.{csh,sh}/settings since these
should not be changed by the user anyhow.
- Use gcc/g++ as common base and specialize afterwards (to reduce
duplication)
- adjust format of WM_PROJECT_SITE fallback to allow for easier
automated edits
- any code placed here should provide Allwmake and Allwclean scripts
and normally have compilation targets into FOAM_APPBIN, FOAM_LIBBIN
Since there is no standardize places for sources or applications,
a simultaneous build of a module's doxygen documentation requires
a minor bit of manual effort. Add (via symlink) the sources into
the modules/doc/ directory to have them included in the normal
OpenFOAM doxygen documentation generation.
A makelink.example file is provided there as an example.
This forms part of what is termed 'automatic wall treatment' in the
reference:
Menter, F., Carregal Ferreira, J., Esch, T., Konno, B. (2003).
The SST Turbulence Model with Improved Wall Treatment
for Heat Transfer Predictions in Gas Turbines.
Proceedings of the International Gas Turbine Congress 2003 Tokyo
Note
The full 'automatic wall treatment' description also requires use of
the Foam::omegaWallFunction with the \c blended flag set to 'on'
omegaWallFunction
- re-instated behaviour when not using 'blended'
- turbulence generation always included when using 'blended'
- 'blended' now true by default
epsilonWallFunction
- re-instated low-Re switching
- disallow insert() of raw pointers, since a failed insertion
(ie, entry already existed) results in an unmanaged pointer.
Either insert using an autoPtr, or set() with raw pointers or autoPtr.
- IOobjectList::add() now takes an autoPtr instead of an object reference
- IOobjectList::remove() now returns an autoPtr instead of a raw pointer
- use normal instead of volumeType to decide on the sign.
This provides a continuous field and eliminates special handling of
GREAT in iso-surface routines.
- fix regression in isoSurfaceCell cutting that was introduced by the
previous adjustments for distanceSurface
- input or output scaling of values to manage dissimilar unit systems
in the structures model
- logging of communicated force, moments and updated positions.
This allows tracking of the information exchange throughout the
duration of the simulation and may assist in post-simulation diagnosis.
- default is now without polyhedral decomposition, since this produces
compacter files and VTK mananges this in most instances.
However, provide function object flag to reinstate the old behaviour.
Calculates and outputs a field whose values are offset to a reference
value obtained by sampling the field at a user-specified location.
The field values are calculated using:
\f[
f_c = s(f_{c,t} - f_p + f_{off})
\f]
where
\vartable
f_c | field values at cell
s | optional scale factor (default = 1)
f_{c,t} | current field values at cell at this time
f_p | field value at position
f_{off} | offset field value (default = 0)
\endvartable
Usage
Example of function object specification to calculate the reference
field:
\verbatim
pRef
{
type reference;
libs ("libfieldFunctionObjects.so");
...
field p;
result pRef;
position (0 0 0);
scale 1.2;
offset 100000;
}
\endverbatim
- the problem arises since the various surface writers are stateless.
The collated output format hacks around this limitation by adding in
its own fieldDict caching (to disk).
Now include an updateMesh() method to hook into geometry changes.
This is considered a stop-gap measure until the surface output
handling is improved.
- improvement documentation for surface sampling.
- can now specify alternative sampling scheme for obtaining the
face values instead of just using the "cell" value. For example,
sampleScheme cellPoint;
This can be useful for cases when the surface is close to a boundary
cell and there are large gradients in the sampled field.
- distanceSurface now handles non-closed surfaces more robustly.
Unknown regions (not inside or outside) are marked internally and
excluded from consideration. This allows use of 'signed' surfaces
where not previously possible.
- a -valgrind option for logging with valgrind
- determine number of processors from system/decomposeParDict
or -decomposeParDict if -np was not specified
- this should normally not be triggered, provided that setRefCell was
used. However, if getRefCellValue() was called without any previous
checking on refCelli, it is possible to provoke errors.
- The iterator for a HashSet dereferences directly to its key.
- Eg,
for (const label patchi : patchSet)
{
...
}
vs.
forAllConstIter(labelHashSet, patchSet, iter)
{
const label patchi = iter.key();
...
}
- the algorithm was last used in OpenFOAM-2.4, after which it was
replaced with a FaceCellWave version.
Whereas the original (2.4.x) version exhibited performance
degradation on very large meshes (with explicit constraints), the
FaceCellWave version exhibited performance issues with large numbers
of blocked faces.
With large numbers of blocked faces, the FaceCellWave regionSplit
could take between 10 to 100 times longer due to the slow
propagation speed through blocked faces.
The 2.4 regionSplit has been revamped to avoid local memory
allocations, which appears to have been the source of the original
performance issues on large meshes.
For additional performance, intermediate renumbering is also avoided
during the consolidation of regions over processor domains.
- controlled by the the 'printExecutionFormat' InfoSwitch in
etc/controlDict
// Style for "ExecutionTime = " output
// - 0 = seconds (with trailing 's')
// - 1 = day-hh:mm:ss
ExecutionTime = 112135.2 s ClockTime = 113017 s
ExecutionTime = 1-07:08:55.20 ClockTime = 1-07:23:37
- Callable via the new Time::printExecutionTime() method,
which also helps to reduce clutter in the applications.
Eg,
runTime.printExecutionTime(Info);
vs
Info<< "ExecutionTime = " << runTime.elapsedCpuTime() << " s"
<< " ClockTime = " << runTime.elapsedClockTime() << " s"
<< nl << endl;
--
ENH: return elapsedClockTime() and clockTimeIncrement as double
- previously returned as time_t, which is less portable.
For example, with some HashTable or Map container of models
{ model0 => 1, model1 => 4, model2 => 5, model3 => 12, model4 => 15, }
specify the remapping
Map<label> mapper({{1, 3}, {2, 6}, {3, 12}, {5, 8}});
inplaceMapValue(mapper, models) then yields
{ model0 => 3, model1 => 4, model2 => 8, model3 => 12, model4 => 15, }
--
ENH: extend bitSet::count() to optionally count unset bits instead.
--
ENH: BitOps compatibility methods for boolList.
- These ease coding that uses a boolList instead of bitSet and use
short-circuit logic when possible.
Eg, when 'bitset' and 'bools' contain the same information
bitset.count() <-> BitOps::count(bools)
bitset.all() <-> BitOps::all(bools)
bitset.any() <-> BitOps::any(bools)
bitset.none() <-> BitOps::none(bools)
These methods can then be used directly in parameters or in logic.
Eg,
returnReduce(bitset.any(), orOp<bool>());
returnReduce(BitOps::any(bools), orOp<bool>());
if (BitOps::any(bools)) ...
- since PackedBoolList is now a compatibility typedef for bitSet,
it is useful to have an additional means of distinction.
STYLE: simplify internal version tests and compiler defines.
- the API version is now conveyed via the OPENFOAM define directly.
The older OPENFOAM_PLUS define is provided for existing code.
- parsing error state only arises from a missing final newline
in the file (which the dnl macro does not capture).
Report with a warning instead of modifying the dnl macro since
we generally wish to know about this anyhow.
- add missing newline to YEqn.H file.
- flags the following type of problems:
* mismatches:
keyword mismatch ( set of { brackets ) in the } entry;
* underflow (too many closing brackets:
keyword too many ( set of ) brackets ) in ) entry;
- a missing semi-colon
dict
{
keyword entry with missing semi-colon
}
will be flagged as 'underflow', since it parses through the '}' but
did not open with it.
Max monitoring depth is 60 levels of nesting, to avoid incurring any
memory allocation.
- handling of dead links (find -L -delete unsupported)
- remove ignore case flag on 's/../../i' used in have_scotch script.
It is unneeded and not tolerated by Darwin's sed.
- avoid embedded comments in EXE_INC (Make/options files), which do
not work well with the OSX LLVM cpp.
It strips out the comments but also removes the continuation char.
STYLE: adjust notes about paraview library locations
- generalize some of the library extensions (.so vs .dylib).
Provide as wmake 'sysFunctions'
- added note about unsupported/incomplete system support
- centralize detection of ThirdParty packages into wmake/ subdirectory
by providing a series of scripts in the spirit of GNU autoconfig.
For example,
have_boost, have_readline, have_scotch, ...
Each of the `have_<package>` scripts will generally provide the
following type of functions:
have_<package> # detection
no_<package> # reset
echo_<package> # echoing
and the following type of variables:
HAVE_<package> # unset or 'true'
<package>_ARCH_PATH # root for <package>
<package>_INC_DIR # include directory for <package>
<package>_LIB_DIR # library directory for <package>
This simplifies the calling scripts:
if have_metis
then
wmake metisDecomp
fi
As well as reducing clutter in the corresponding Make/options:
EXE_INC = \
-I$(METIS_INC_DIR) \
-I../decompositionMethods/lnInclude
LIB_LIBS = \
-L$(METIS_LIB_DIR) -lmetis
Any additional modifications (platform-specific or for an external build
system) can now be made centrally.
- also simplify parsing by accepting any case on keywords.
This implies that something like "sOlId", "SoLiD" will also
be accepted. Although nobody should really count on this rather
generous behaviour, it does simplfy the state machine even further.
- in 2.4.x the general default for polyMesh::findCell was FACE_DIAG_TRIS,
but this was changed to CELL_TETS for better handling of concave
cells.
- in snappyHexMesh meshRefinement, findCell is used to define
locations in mesh and cells for closer refinement. Using CELL_TETS
causes an octree rebuild when the mesh has changed and this adds
considerable overhead. For this operation, the faster FACE_DIAG_TRIS
mode can be used instead.
- the previous grammar used
'/*' { fgoto comment; }
to start processing multi-line comments and
comment := any* :>> '*/' @{ fgoto main; };
as a finishing action to return to normal lexing, but seemed not to
have been triggered properly.
Now simply trap in a single rule:
'/*' any* :>> '*/'; # Multi-line comment
STYLE: use more compact dnl (delete to newline)
OLD: [^\n]* '\n'
NEW: (any* -- '\n') '\n'
eliminates the intermediate state
- the API-versioned calls (eg, tecini142, teczne142, tecpoly142, tecend142),
the limited availability of the SDK and lack of adequate testing make
proper maintenance very difficult.
- these errors are mostly rounding related (when a point is located on
the edge of a bounding box instead of being fully inside it).
For debug > 1, continue to treat as fatal.
- IOstreamOption class to encapsulate format, compression, version.
This is ordered to avoid internal padding in the structure, which
reduces several bytes of memory overhead for stream objects
and other things using this combination of data.
Byte-sizes:
old IOstream:48 PstreamBuffers:88 Time:928
new IOstream:24 PstreamBuffers:72 Time:904
====
STYLE: remove support for deprecated uncompressed/compressed selectors
In older versions, the system/controlDict used these types of
specifications:
writeCompression uncompressed;
writeCompression compressed;
As of DEC-2009, these were deprecated in favour of using normal switch
names:
writeCompression true;
writeCompression false;
writeCompression on;
writeCompression off;
Now removed these deprecated names and treat like any other unknown
input and issue a warning. Eg,
Unknown compression specifier 'compressed', assuming no compression
====
STYLE: provide Enum of stream format names (ascii, binary)
====
COMP: fixed incorrect IFstream construct in FIREMeshReader
- spurious bool argument (presumably meant as uncompressed) was being
implicitly converted to a versionNumber. Now caught by making
IOstreamOption::versionNumber constructor explicit.
- bad version specifier in changeDictionary
- In addition to the traditional Flex-based parser, added a Ragel-based
parser and a handwritten one.
Some representative timings for reading 5874387 points (1958129 tris):
Flex Ragel Manual
5.2s 4.8s 6.7s total reading time
3.8s 3.4s 5.3s without point merging
- However, the new ragel-based parser is much faster
than the others, and does not cause 'too many open files' error
that the flex-based parser does (issue #784).
The timings (using src/sampling as being somewhat representative)
$ wclean; wmakeLnInclude -u .; time wmake -s dep
3.4s wmkdepend (ragel) [now default]
5.7s wmkdep (flex)
6.1s cpp -M
- The makeDepend script is for testing purposes only, but could used as
a hook for other dependency generation systems (eg, ninja).
It simply wraps 'cpp -M' in a form that is calling compatible with
wmkdepend.
BUG: wmkdepend parser was missing optional leading space on #include match
STYLE: use -G2 (goto-based) option for wmkdepend state machine
- the machine is compact with few states and lends itself to this
- the expansions were previously required as slash to follow, but
now either are possible.
"<case>", "<case>/" both yield the same as "$FOAM_CASE" and
will not have a trailing slash in the result. The expansion of
"$FOAM_CASE/" will however have a trailing slash.
- adjust additional files using these expansions
- a partial selection from https://github.com/mrklein/openfoam-os-x
with adjustments. The primary purpose is to reduce header-level
incompatibilities and to provide a common set of make rules to allow
easier patching (or re-integration).
This is similar to efforts (Feb 2010) but using ragel
(https://en.wikipedia.org/wiki/Ragel) instead of the now defunct
coco/r. The modified commit message from 2010:
ENH: add C++-based wmkdepend parser (uses ragel grammar).
- This avoids dependency on lex/flex and provides better encapsulation
for buffer switching. As a result, the maximum number of open files
only corresponds to the include depth.
--
Note that the flex source and rules are still available, but are not
deactivate (see wmake/rules/General/transform)
Support the following expansions when they occur at the start of a
string:
Short-form Equivalent
========= ===========
<etc>/ ~OpenFOAM/ (as per foamEtcFile)
<case>/ $FOAM_CASE/
<constant>/ $FOAM_CASE/constant/
<system>/ $FOAM_CASE/system/
These can be used in fileName expansions to improve clarity and reduce
some typing
"<constant>/reactions" vs "$FOAM_CASE/constant/reactions"
ParaView 5.4 and older:
- requires lib/paraview-X.X only
ParaView 5.5:
- requires lib/
- does not appear to require lib/paraview-X.X, but retained for simplicity
- Change default version to paraview-5.5.0 for testing purposes
- this removes an OS-specific dependency (eg, drand48_r is not POSIX)
and allows easier use of other random number generators.
The Rand48 generator has identical behaviour and period as the
lrand48() library routine, but holds its own seed and state
(which makes it re-entrant) and can be combined with other
random distributions.
However, when using the modified form to obtain scalar values
they will not be identical to what drand48() yields.
This is because drand48() uses the raw 48-bit values to directly
set the mantissa of an IEEE double where as the newer distribution
normalizes based on the 32-bit value.
STYLE: simplify code in Random::shuffle and use Swap
keeping chocked conditions of Mach number.
This BC can work in two modes, chocked or non-chocked. In the
chocked mode the Ma is an input. In the non-chocked mode
the Ma is calculated from model inputs.
- in many cases can just use lookupOrDefault("key", bool) instead of
lookupOrDefault<bool> or lookupOrDefault<Switch> since reading a
bool from an Istream uses the Switch(Istream&) anyhow
STYLE: relocated Switch string names into file-local scope
- improve internal handling to permit deriving resizable containers
(eg, PtrDynList).
- include '->' iterator dereferencing
- Only append/set non-const autoPtr references. This doesn't break
existing code, but makes the intention more transparent.
- both autoPtr and tmp are defined with an implicit construct from
nullptr (but with explicit construct from a pointer to null).
Thus is it safe to use 'nullptr' when returning an empty autoPtr or tmp.
The set of injectionMethods has been extended to include a new option:
injectionMethod movingPoint;
The position is then read as a TimeFunction1 entry, e.g. for a 'table'
type:
position table
(
(0 (-0.009 0.0995 0))
(1e-3 (0.009 0.0995 0))
);
where the list corresponds to the tuples (time (position)), and the time
is relative to the start of injection (SOI)
- when constructing dimensioned fields that are to be zero-initialized,
it is preferrable to use a form such as
dimensionedScalar(dims, Zero)
dimensionedVector(dims, Zero)
rather than
dimensionedScalar("0", dims, 0)
dimensionedVector("zero", dims, vector::zero)
This reduces clutter and also avoids any suggestion that the name of
the dimensioned quantity has any influence on the field's name.
An even shorter version is possible. Eg,
dimensionedScalar(dims)
but reduces the clarity of meaning.
- NB: UniformDimensionedField is an exception to these style changes
since it does use the name of the dimensioned type (instead of the
regIOobject).
- also ensure fewer side-effects from inplaceReorder
- provide ListOps::reorder especially for PackedList and PackedBoolList
since they behave differently from regular lists.
- eliminate iterators from PackedList since they were unused, had
lower performance than direct access and added unneeded complexity.
- eliminate auto-vivify for the PackedList '[] operator.
The set() method provides any required auto-vivification and
removing this ability from the '[]' operator allows for a lower
when accessing the values. Replaced the previous cascade of iterators
with simpler reference class.
PackedBoolList:
- (temporarily) eliminate logic and addition operators since
these contained partially unclear semantics.
- the new test() method tests the value of a single bit position and
returns a bool without any ambiguity caused by the return type
(like the get() method), nor the const/non-const access (like
operator[] has). The name corresponds to what std::bitset uses.
- more consistent use of PackedBoolList test(), set(), unset() methods
for fewer operation and clearer code. Eg,
if (list.test(index)) ... | if (list[index]) ...
if (!list.test(index)) ... | if (list[index] == 0u) ...
list.set(index); | list[index] = 1u;
list.unset(index); | list[index] = 0u;
- deleted the operator=(const labelUList&) and replaced with a setMany()
method for more clarity about the intended operation and to avoid any
potential inadvertent behaviour.
- clockValue class for managing the clock values only, with a null
constructor that does not query the system clock (can defer to later).
Can also be used directly for +/- operations.
- refactor clockTime, cpuTime, clock to reduce storage.
- The bitSet class replaces the old PackedBoolList class.
The redesign provides better block-wise access and reduced method
calls. This helps both in cases where the bitSet may be relatively
sparse, and in cases where advantage of contiguous operations can be
made. This makes it easier to work with a bitSet as top-level object.
In addition to the previously available count() method to determine
if a bitSet is being used, now have simpler queries:
- all() - true if all bits in the addressable range are empty
- any() - true if any bits are set at all.
- none() - true if no bits are set.
These are faster than count() and allow early termination.
The new test() method tests the value of a single bit position and
returns a bool without any ambiguity caused by the return type
(like the get() method), nor the const/non-const access (like
operator[] has). The name corresponds to what std::bitset uses.
The new find_first(), find_last(), find_next() methods provide a faster
means of searching for bits that are set.
This can be especially useful when using a bitSet to control an
conditional:
OLD (with macro):
forAll(selected, celli)
{
if (selected[celli])
{
sumVol += mesh_.cellVolumes()[celli];
}
}
NEW (with const_iterator):
for (const label celli : selected)
{
sumVol += mesh_.cellVolumes()[celli];
}
or manually
for
(
label celli = selected.find_first();
celli != -1;
celli = selected.find_next()
)
{
sumVol += mesh_.cellVolumes()[celli];
}
- When marking up contiguous parts of a bitset, an interval can be
represented more efficiently as a labelRange of start/size.
For example,
OLD:
if (isA<processorPolyPatch>(pp))
{
forAll(pp, i)
{
ignoreFaces.set(i);
}
}
NEW:
if (isA<processorPolyPatch>(pp))
{
ignoreFaces.set(pp.range());
}
- primary points for an external user are the polyMesh constructor
- add config info for gcc-7.3.0
COMP: intel-2017. Ignore unknown pragmas. Disambiguate method resolution.
This class is largely a pre-C++11 holdover. It is now possible to
simply use move construct/assignment directly.
In a few rare cases (eg, polyMesh::resetPrimitives) it has been
replaced by an autoPtr.
- rvalue() is a (transitional) means of converting Xfer content to a
reference for move construct, move assign semantics.
- valid() method for consistency with autoPtr and tmp classes
Improve alignment of its behaviour with std::shared_ptr
- element_type typedef
- swap, reset methods
* additional reference access methods:
cref()
returns a const reference, synonymous with operator().
This provides a more verbose alternative to using the '()' operator
when that is desired.
Mnemonic: a const form of 'ref()'
constCast()
returns a non-const reference, regardless if the underlying object
itself is a managed pointer or a const object.
This is similar to ref(), but more permissive.
Mnemonic: const_cast<>
Using the constCast() method greatly reduces the amount of typing
and reading. And since the data type is already defined via the tmp
template parameter, the type deduction is automatically known.
Previously,
const tmp<volScalarField>& tfld;
const_cast<volScalarField&>(tfld()).rename("name");
volScalarField& fld = const_cast<volScalarField&>(tfld());
Now,
tfld.constCast().rename("name");
auto& fld = tfld.constCast();
--
BUG: attempts to move tmp value that may still be shared.
- old code simply checked isTmp() to decide if the contents could be
transfered. However, this means that the content of a shared tmp
would be removed, leaving other instances without content.
* movable() method checks that for a non-null temporary that is
unique (not shared).
Improve alignment of its behaviour with std::unique_ptr
- element_type typedef
- release() method - identical to ptr() method
- get() method to get the pointer without checking and without releasing it.
- operator*() for dereferencing
Method name changes
- renamed rawPtr() to get()
- renamed rawRef() to ref(), removed unused const version.
Removed methods/operators
- assignment from a raw pointer was deleted (was rarely used).
Can be convenient, but uncontrolled and potentially unsafe.
Do allow assignment from a literal nullptr though, since this
can never leak (and also corresponds to the unique_ptr API).
Additional methods
- clone() method: forwards to the clone() method of the underlying
data object with argument forwarding.
- reset(autoPtr&&) as an alternative to operator=(autoPtr&&)
STYLE: avoid implicit conversion from autoPtr to object type in many places
- existing implementation has the following:
operator const T&() const { return operator*(); }
which means that the following code works:
autoPtr<mapPolyMesh> map = ...;
updateMesh(*map); // OK: explicit dereferencing
updateMesh(map()); // OK: explicit dereferencing
updateMesh(map); // OK: implicit dereferencing
for clarity it may preferable to avoid the implicit dereferencing
- prefer operator* to operator() when deferenced a return value
so it is clearer that a pointer is involve and not a function call
etc Eg, return *meshPtr_; vs. return meshPtr_();
- constexpr, noexcept.
Added an 'at()' method for returning an iterator within the range
and changed operator()(label) to have behaviour as per found().
This makes the labelRange usable as a unary predicate.
- added templated conversion class 'toLabelRange'
- add range() method to polyPatch and surfZone classes, and corresponding
templated conversion functors.
For example,
auto patchDims = ListOps::create<labelRange>
(
mesh.boundaryMesh(),
toLabelRange<polyPatch>()
);
to create a List<labelRange> representing the patch extents.
- relocated HashSetPlusEqOp and HashTablePlusEqOp to
HashSetOps::plusEqOp and HashTableOps::plusEqOp, respectively
- additional functions for converting between a labelHashSet
and a PackedBoolList or List<bool>:
From lists selections to labelHashSet indices:
HashSetOps::used(const PackedBoolList&);
HashSetOps::used(const UList<bool>&);
From labelHashSet to list forms:
PackedBoolList bitset(const labelHashSet&);
List<bool> bools(const labelHashSet&);
- relocated ListAppendEqOp and ListUniqueEqOp to ListOps::appendEqOp
and ListOps::UniqueEqOp, respectively for better code isolation and
documentation of purpose.
- relocated setValues to ListOps::setValue() with many more
alternative selectors possible
- relocated createWithValues to ListOps::createWithValue
for better code isolation. The default initialization value is itself
now a default parameter, which allow for less typing.
Negative indices in the locations to set are now silently ignored,
which makes it possible to use an oldToNew mapping that includes
negative indices.
- additional ListOps::createWithValue taking a single position to set,
available both in copy assign and move assign versions.
Since a negative index is ignored, it is possible to combine with
the output of List::find() etc.
STYLE: changes for PackedList
- code simplication in the PackedList iterators, including dropping
the unused operator() on iterators, which is not available in plain
list versions either.
- improved sizing for PackedBoolList creation from a labelUList.
ENH: additional List constructors, for handling single element list.
- can assist in reducing constructor ambiguity, but can also helps
memory optimization when creating a single element list.
For example,
labelListList labels(one(), identity(mesh.nFaces()));
- constexpr, noexcept on various bits
- addition of a 'one::minus' class that returns '-1' instead of '1'.
There are no additional operations defined for this class,
but it can be used in various places to signal alternative behaviour
such as "initialize to a negative or other invalid value"
- This class is largely a pre-C++11 holdover, prior to having movable
references.
- align internals with autoPtr instead of always unconditionally
allocating memory. The valid() method can be used to check for a null
pointer.
- Consolidate into a single file, in anticipation of future removal.
- deprecated MAR-2017
subset(const UList<T>& select, const T& value, const ListType&);
inplaceSubset(const UList<T>& select, const T& value, ListType&);
The subsetList/inplaceSubsetList variants with a unary predicate
provide more flexible and robuster solutions.
- deprecated MAR-2017
initList(const T[mRows]);
initListList(const T[mRows][nColumns]);
Required prior to the addition of constructors with
std::initializer_list
* For most cases, this conversion would be largely unintentional
and also less efficient. If the regex is desirable, the caller
should invoke it explicitly.
For example,
findStrings(regExp(str), listOfStrings);
Or use one of the keyType, wordRe, wordRes variants instead.
If string is to be used as a plain (non-regex) matcher,
this can be directly invoked
findMatchingStrings(str, listOfStrings);
or using the ListOps instead:
findIndices(listOfStrings, str);
* provide function interfaces for keyType.
- subsetList, inplaceSubsetList with optional inverted logic.
- use moveable elements where possible.
- allow optional starting offset for the identity global function.
Eg, 'identity(10, start)' vs 'identity(10) + start'
- more consistent with STL practices for function classes.
- string::hash function class now operates on std::string rather
than Foam::string since we have now avoided inadvertent use of
string conversion from int in more places.
- Eg instead of using labelHashSet, used HashSet<label> which uses
the string::hash for hashing. Other places inadvertently using the
string::hash instead of Hash<label> for hashing.
STYLE: use Map<..> instead of HashTable<.., label, Hash<label>>
- reduces clutter
- add copy construct from UList
- remove copy construct from dissimilar types.
This templated constructor was too generous in what it accepted.
For the special cases where a copy constructor is required with
a change in the data type, now use the createList factory method,
which accepts a unary operator. Eg,
auto scalars = scalarList::createList
(
labels,
[](const label& val){ return 1.5*val; }
);
- now warn about the following:
* the bounding box does not overlap wih the global mesh
* plane does not intersect the (valid) bounding box
* plane does not intersect the global mesh
- add bounding to the "plane" variant of a sampled plane.
- simplify structure, removed unused constuctors.
- transfer from base objects via '=' assignment removed as being too
non-transparent
- add New factory method with perfect forwarding.
- use std::reverse_iterator adaptors, avoid the array-bounds warning
- use pointer arithmetic instead of dereferencing the internal array
- adjust logic to use 'operator<' instead of 'operator>' in sorting.
This creates less work when making other classes sortable.
- the transfer method was previously a copy
- use std::reverse_iterator adaptors in FixedList
This greatly reduces the amount of code and now avoids the array-bounds
warning for FixedList::rend()
- use pointer arithmetic instead of dereferencing the internal array
- without these will use the normal move construct + move assign.
This is similarly efficient, but avoids the inadvertently having the
incorrect Swap being used for derived classes.
STYLE: remove unused xfer methods for HashTable, HashSet
- unneeded since move construct and move assignment are possible
- can stop producing content when the target number of entries has
been reached.
- change return type to labelList instead an Xfer container.
This allows return-value-optimization and avoids a surrounding
allocation. This potentially breaks existing code.
- make PackedList and PackedBoolList moveable. Drop xfer wrappers.
- forward command-line arguments for paraview, where they may also be
evaluated (cshrc, POSIX shell)
Eg,
. etc/bashrc ParaView_VERSION=5.4.1-mpipy
source etc/cshrc ParaView_VERSION=5.4.1-mpipy
- this currently just strips off the leading parent directory name
"/this/path/and/subdirs/name"
relative("/this/path") -> "and/subdirs/name"
relative("/this") -> "path/and/subdirs/name"
'delta'
The scheme should now be specified using, e.g.
div(phi,U) Gauss DEShybrid
linear // scheme 1
linearUpwind grad(U) // scheme 2
hmax // LES delta name, e.g. 'delta', 'hmax'
0.65 // DES coefficient, typically = 0.65
30 // Reference velocity scale
2 // Reference length scale
0 // Minimum sigma limit (0-1)
1 // Maximum sigma limit (0-1)
1.0e-03; // Limiter of B function, typically 1e-03
- simplify structure.
- protect against nullptr when resetting memory streams
- make UIListStream swappable
- add uiliststream as an example of using a plain std::istream
- define regExp::results_type using SubStrings container for handling
groups. This makes a later shift to std::smatch easier, but changes
the regExp API for matching with groups. Previously had list element
0 for regex group 1, now list element 0 is the entire match and list
element 1 is regex group 1.
Old:
List<std::string> mat;
if (re.match(text, mat)) Info<< "group 1: " << mat[0] << nl;
New:
regExp::results_type mat;
if (re.match(text, mat)) Info<< "group 1: " << mat.str(1) << nl;
- problems were introduced by the change ee252307d3 (issue #686).
Affected reading of OBJ files.
The fallback zone (used to catch unnamed groups/zones), which was
previously filtered away when not needed. Now handle more explicitly.
ENH: use stringOps::split and low-level read{Label,Scalar} for parsing OBJ file
- export library path for gmp/mpfr from CGAL config files.
This is required when non-system gmp/mpfr libraries are being
used, but not using a ThirdParty compiler installation.
- automatically handle lib/ vs lib64/ (eg, for central installations)
for packages such as boost, CGAL, etc. While the ThirdParty
compilation of these will normally land in lib64/, this may not be
the case when they are supplied by another means.
- reworked the handling of foamEtcFile and foamCleanPath for less
clutter in the configuration files.
Added the bin/tools/lib-dir script to handle logic that is
too complex to easily manage in csh.
The total number of escaped|stick particles in patches can now be sorted by the injectorID from
which the particle originated. It uses outputByInjectorId keyword in the localInteractionCoeffs
dictionary
- for tutorials that are known to run poorly, can provide a
placeholder Allrun-optional instead of the usual Allrun script.
If this is detected, the case will be skipped.
- can be used to handle when options become redundant, but it is
undesirable to treat its presence as an error. Can now tag it as
being ignored.
argList::ignoreOptionCompat({"oldOption", 1706}, true);
argList::ignoreOptionCompat({"oldBoolOpttion", 1706}, false);
command -oldOption xyz -oldBoolOpttion
- use succincter method names that more closely resemble dictionary
and HashTable method names. This improves method name consistency
between classes and also requires less typing effort:
args.found(optName) vs. args.optionFound(optName)
args.readIfPresent(..) vs. args.optionReadIfPresent(..)
...
args.opt<scalar>(optName) vs. args.optionRead<scalar>(optName)
args.read<scalar>(index) vs. args.argRead<scalar>(index)
- the older method names forms have been retained for code compatibility,
but are now deprecated
- now avoid Istream and token mechanism in favour of a simpler string
parser. This makes the code clearer, smaller, robuster.
- provide convenience ge/gt/le/lt static constructors for scalarRange
for using bounds directly with specifying via a string parameter.
- scalarRange, scalarRanges now follow the unary predicate pattern
(using an operator() for testing). This allows their reuse in
other contexts. Eg, for filtering operations:
myHash.filterValues(scalarRange::ge(100));
- remove unused scalarRanges methods that were specific to handling
lists of time values. These were superseded by timeSelector methods
several versions ago.
- list all regions from constant/regionProperties:
* foamListRegions
- list specific region type from constant/regionProperties:
* foamListRegions fluid
* foamListRegions solid
- this is a provision for defining execute actions that can be called
largely independently of the normal time-loop constraints. This can
be useful to provide hooks for sub-cycling, or to define an action
that can be triggered manually or on some other event.
- support move construct/assignment for linked-lists themselves
and when moving into a 'normal' list
- better consistency with begin/end signatures and the various
iterators.
- for indirect linked-lists, provide iterator access to the underlying
data element address: iter.get() vs &(iter())
- add standard '->' indirection for iterators (as per normal STL
definitions)
- label-size 64 build, compiler warnings, unused template argument,
faMatrix::clone() method
STYLE: faScalarMatrix - moved info message to within a debug scope
- allows changing the format of the sending OPstream at an arbitrary
point in the transmission. The information is passed through the
buffer and the receiving IPstream changes its format accordingly.
This allows a temporary toggling of ASCII/BINARY mid-stream.
- the return value signals if this method handled this particular type
of token. This minor change allows this method to be used as a succinct
prefilter an output token stream. It also provides better encapsulation
of what the particular output stream handles.
Eg,
bool ok = os.write(tok);
if (!ok) // or if (!ok && os.good())
{
os << tok;
}
instead of
if (tok.type() == typeA || tok.type() == typeB || ...)
{
os.write(tok);
}
else
{
os << tok;
}
- when dictionary keywords change between versions, the programmer
can use these compatibility methods to help with migration.
* csearchCompat, foundCompat, lookupEntryPtrCompat, lookupEntryCompat,
lookupCompat, lookupOrDefaultCompat, readIfPresentCompat, ...
They behave like their similarly named base versions, but accept an
additional list of older keyword names augmented by a version number.
For example,
dict.readIfPresentCompat
(
"key", {{"olderName", 1612}, {"veryOld", 240}},
myscalar
);
where 1612=OpenFOAM-v1612, 240=OpenFOAM-v2.4.x, etc.
- If the entry could be directly inserted: a pointer to the inserted entry.
- If a dictionary merge was required: a pointer to the dictionary that
received the entry.
- Return nullptr on any type of insertion failure.
This change is code compatible with existing code since it only alters
a bool return value to be a pointer return value.
- improved memory alignment reduces overhead for Int32 compilation
- added move/swap semantics
- made the type() readonly in favour of setVariant() to allow change
of variant within a particular storage representation.
Eg, STRING -> VERBATIMSTRING.
- comments
- avoid egrep for getting processor count.
- wcleanBuild, wcleanPlatform with shorter form '-curr' instead of '-c'
to avoid any potential user confusion with '-comp'
- this avoids a situation when an aborted sourcing of the etc/bashrc
file can leave WM_SHELL_FUNCTIONS defined, which causes all
subsequent sourcing to fail.
- can be used to test the behaviour of the decomposion and its
characteristics without writing any decomposition to disk.
Combine with -cellDist to visualize the expected decomposition
result.
- aids with detection of excess tokens (issue #762)
- deprecated dictionary::operator[] in favour of the lookup() method
which offers more flexibilty and clarity of purpose.
Additionally, the read<> and get<> forms should generally be used
instead anyhow.
- FOAM_CONFIG_NOUSER
Suppress use of user/group configuration files.
This is useful when packaging for a central installation.
- allow additional user tuning of compiler settings.
Per-compiler overrides in "compiler-$WM_COMPILER" files
- the vector normalise() method modifies the object inplace,
the normalised function returns a copy.
vector vec1(1,2,3);
vec1.normalise();
vs
vector vec1(1,2,3);
vec1 /= mag(vec1) + VSMALL;
For const usage, can use either of these
const vector vec2a(normalised(vector(1,2,3)));
const vector vec2b(vector(1,2,3).normalise());
DOC: document topo sources inputs in doxygen format
ENH: check for excess tokens in dictionary input (issue #762)
- various bits of code cleanup (modernization) in meshTool/sets.
- improve doxygen entries for searchable surfaces.
- support selection of searchable surfaces with shorter names.
Eg,
type box | cylinder | ...;
vs type searchableBox | searchableCylinder | ...;
- relocate some standard functionality to TimePaths to allow a lighter
means of managing time directories without using the entire Time
mechanism.
- optional enableLibs for Time construction (default is on)
and a corresponding argList::noLibs() and "-no-libs" option
STYLE:
- mark Time::outputTime() as deprecated MAY-2016
- use pre-increment for runTime, although there is no difference in
behaviour or performance.
so the write thread does not have to do any parallel communication. This avoids
the bugs in the threading support in OpenMPI.
Patch contributed by Mattijs Janssens
Resolves bug-report https://bugs.openfoam.org/view.php?id=2669
- include amount of free system memory in profiling, which can give an
indication of when swapping is about to start
- profilingSummary utility to collect profiling from parallel
calculations. Collects profiling information from processor
directories and summarize the time spent and number of calls as (max
avg min) values.
- waitForSlave now return a Time::stopAtControls enumeration:
unknown: when lockfile has no specially recognized content.
endTime: when lockfile contains "status=done"
writeNow: when lockfile contains "action=writeNow"
nextWrite: when lockfile contains "action=nextWrite"
noWriteNow: when lockfile contains "action=noWriteNow"
These values can be used by the caller to terminate the master
(OpenFOAM) as desired in response to information placed there by the
slave process.
- expose the names of write and stopAt controls for reuse elsewhere and
provide a stopAtControls enum for 'unknown'
- track the requested number of sub-cycles (was previously a bool)
- the readList<T>(Istream&) function was introduced to handle command
-options with either a single or a list value, but was also used for
the #remove dictionary directive. However, the parsing was fragile
if the list did not start with a '('.
Now handle command-line arg/option list directly (via ITstream)
and #remove with special-purpose reading of a string or word list.
This removes ambiguity and reduces potential future problems.
STYLE: use ITstream instead of IStringStream for command-line lookups
- parses directly to a tokenList without a string copy.
- unknown options or missing option values now emit a shorter message
without the entire usage. This makes it easier to identify the errors
and is better aligned with the behaviour of GNU system tools.
====
$ simpleFoam -case
Using: OpenFOAM-plus (see www.OpenFOAM.com)
Build: plus-01234
Error: option '-case' requires an argument
See 'simpleFoam -help' for usage
====
- provide for reduced (-help) and full (-help-full) usage information.
In many cases the reduced usage provided sufficient and easier
to find the information.
- make -srcDoc an alias for -doc-source
- no warnings about option aliases for future dates.
- split now optionally retains empty substrings.
Added split on fixed field width.
- Foam::name() now formats directly into string buffer, which a
removes one layer of copying and also avoids using a non-constexpr
in the temporary.
STYLE: explicit type narrowing on zero-padded output for ensight
- allows (for example) splitting a user string on whitespace and
passing this to system as a list of arguments, thus bypassing any
implicit use of 'sh'.
- system() with optional background, for spawning processes.
- this makes them applicable to Foam::string, Foam::word etc
ENH: improvements to CStringList
- add strings() sublist variant which can be useful when handling
command arguments separately
- add construct from SubStrings.
- in rare cases we may wish to have command-line arguments that are
non-mandatory. This can now be reflected in the usage output, provided
that the argList::nonMandatoryArgs() has been used.
- added setRootCaseNonMandatoryArgs.H that applies the
argList::nonMandatoryArgs() settings and otherwise performs largely
as per setRootCase.H, except that the check for mandatory arguments
is deferred to later user code.
- constructor for empty cell/face/point Zones, with contents to be
transferred in later.
- ZoneMesh::operator(const word&) to return existing zone or a new empty one.
- this provides a better typesafe means of locating predefined cell
models than relying on strings. The lookup is now ptr() or ref()
directly. The lookup functions behave like on-demand singletons when
loading "etc/cellModels".
Functionality is now located entirely in cellModel but a forwarding
version of cellModeller is provided for API (but not ABI) compatibility
with older existing user code.
STYLE: use constexpr for cellMatcher constants
- warn or fatal if Pstream::init or Pstream::exit are called multiple
times.
- additional Pstream::initNull method as failsafe to initialize MPI
when the underlying OpenFOAM process is not running in parallel but
the application still needs MPI.
- Pstream::exit() can now also be called without having used MPI::init(),
which means it can be used to cleanup serial process or for
applications that used the special purpose Pstream::initNull()
mechanism.
- the dictionary-driven variant of stitchMesh allows sequential
application of 'stitch' operation with requiring intermediate
writing to disk.
- Without arguments:
* stitchMesh uses a system/stitchMeshDict or -dict dict
- With arguments:
* master/slave patches specified on the command-line as in previous
versions.
Within decomposeParDict, it is now possible to specify a different
decomposition method, methods coefficients or number of subdomains
for each region individually.
The top-level numberOfSubdomains remains mandatory, since this
specifies the number of domains for the entire simulation.
The individual regions may use the same number or fewer domains.
Any optional method coefficients can be specified in a general
"coeffs" entry or a method-specific one, eg "metisCoeffs".
For multiLevel, only the method-specific "multiLevelCoeffs" dictionary
is used, and is also mandatory.
----
ENH: shortcut specification for multiLevel.
In addition to the longer dictionary form, it is also possible to
use a shorter notation for multiLevel decomposition when the same
decomposition method applies to each level.
- only warn about missing cells/points if the mesh is also missing
boundary patches.
- reduce verbosity when decomposing to an empty mesh
- skip face matching when either mesh has no faces
- this compact form shows the subscription per host in the unsorted
mpi order
nProcs : 18
Hosts :
(
(node1 6)
(node2 8)
(node3 4)
)
This provides a succinct overview of which hosts have been
subscribed or oversubscribed.
- The longer list of "slave.pid" ... remains available on the
InfoSwitch 'writeHosts'
- the -dir option was added in commit c1c6243c3e to allow quick
testing of documentation for a set of classes.
This was largely replicated in commit 843d83117, but accepting
multiple directories.
Apply some of the same ideas here and avoid creation of a tmp file.
Correcting thermoSingleLayer.C mask field alpha to avoid heat sources where there is no film.
Tunning fvSolution for alpha for twoPhasePachuka tutorial
Previously:
- bad command-line input such as -label 1234xyz would parse as a
label (with value 1234) and the trailing junk would be silently
ignored. This may or may not be appropriate. If the trailing junk
looked like this '100E' or '1000E-' (ie, forgot to type the
exponent), the incorrectly parsed values can be quite bad:
label = 32684
scalar = 6.93556e-310
Now:
- use the updated readLabel/readScalar routines that trigger a
FatalIOError on bad input:
--> FOAM FATAL IO ERROR:
Trailing content found parsing '1234xyz'
--> FOAM FATAL IO ERROR:
Trailing content found parsing '100E'
This traps erroneous command-line input immediately.
- Any trailing whitespace when parsing from strings or character buffers
is ignored rather than being treated as an error. This is consistent
with behaviour when reading from an Istream and with leading whitespace
being ignored in the underlying atof/atod, strtof/strtod... functions.
- Allow parsing directly from a std::string instead of just from a 'char*'.
This reflects the C++11 addition of std::stod to complement the C
functions strtod. This also makes it easier to parse string directly
without using an IStringStream.
- Two-parameter parsing methods return success/failure.
Eg,
if (readInt32(str, &int32Val)) ...
- One-parameter parsing methods return the value on success or
emit a FatalIOError.
Eg,
const char* buf;
int32Val = readInt32(buf, &);
- Improved consistency when parsing unsigned ints.
Use strtoimax and strtoumax throughout.
- Rename readDoubleScalar -> readDouble, readFloatScalar -> readFloat.
Using the primitive name directly instead of the Foam typedef for
better consistency with readInt32 etc.
- Clean/improve parseNasScalar.
Handle normal numbers directly, reduce some operations.
- previous only checked for clouds at the last instance and only
detected lagrangian fields from the first cloud.
Now check for clouds at all instances and detect all of their fields
as well.
- affects surfaceFieldValue, volFieldValue.
Use 'none' (if desired) to explicitly suppress the weightField, but
generally better to use a different operation.
There are a few issues:
- error would only throw exceptions if not parallel
- if we change this we also need to make sure the functionObjectList
construction is synchronised
- bounding box overlap was not returning the correct status so the code
to avoid the issue of 'badly formed bounding box' was not triggered.
- support VTP input in functionObjectCloud scene element
- additional fallback lookup of cloud information from state properties
instead of cloud OutputProperties
version on a switch. See #867
By default the code will use the same form as previous versions
To use the experimental version integrated from openfoam.org commit
da787200 set the info switch in the controlDict:
InfoSwitches
{
experimentalDdtCorr 1;
}
- when the iso-surface (eg, a cut plane, or distanceSurface) passes
exactly through the cell centre, zero-sized triangles can occur.
These should be merged away.
- link CGAL (clang version) without reference to mpfr,gmp libraries
- use offset address in printStack for Darwin as well
- alternative handling of feexcept on Darwin
- Reimplemented treatment of alpha1, phi and U in case of
nOuterCorrectors > 1 based on storePrevIter() to avoid cluttering the
solver with unnecessary fields in case of nOuterCorrectors = 1.
- Updated tutorial headers
- Added copyright note to isoAdvector src
- Removed outcommented code lines in interIsoFoam solver
- Removed all LTS from interIsoFoam since this is not currently supported
- Confirmed that discInConstantFlow gives identical results with N subCylces and time step N*dt
- Confirmed that this also holds when nOuterCorrectors > 1.
- start/end values were underrepresented due to rounding.
Now extend the range to include -0.5 and +0.5 beyond the usual
range to ensure the same number density.
Residual fields can be written using the new 'writeFields' entry, e.g.
functions
{
residual
{
type residuals;
libs ("libutilityFunctionObjects.so");
fields (".*");
writeControl writeTime;
writeFields true;
}
}
Fields currently correspond to the initial residual for the last solver
iteration.
-dry-run : perform check only and no writing
-dry-run-write: perform check and write to the next time step. This
also triggers function objects that fire on the call to write()
Improvements to existing functionality
--------------------------------------
- MPI is initialised without thread support if it is not needed e.g. uncollated
- Use native c++11 threading; avoids problem with static destruction order.
- etc/cellModels now only read if needed.
- etc/controlDict can now be read from the environment variable FOAM_CONTROLDICT
- Uniform files (e.g. '0/uniform/time') are now read only once on the master only
(with the masterUncollated or collated file handlers)
- collated format writes to 'processorsNNN' instead of 'processors'. The file
format is unchanged.
- Thread buffer and file buffer size are no longer limited to 2Gb.
The global controlDict file contains parameters for file handling. Under some
circumstances, e.g. running in parallel on a system without NFS, the user may
need to set some parameters, e.g. fileHandler, before the global controlDict
file is read from file. To support this, OpenFOAM now allows the global
controlDict to be read as a string set to the FOAM_CONTROLDICT environment
variable.
The FOAM_CONTROLDICT environment variable can be set to the content the global
controlDict file, e.g. from a sh/bash shell:
export FOAM_CONTROLDICT=$(foamDictionary $FOAM_ETC/controlDict)
FOAM_CONTROLDICT can then be passed to mpirun using the -x option, e.g.:
mpirun -np 2 -x FOAM_CONTROLDICT simpleFoam -parallel
Note that while this avoids the need for NFS to read the OpenFOAM configuration
the executable still needs to load shared libraries which must either be copied
locally or available via NFS or equivalent.
New: Multiple IO ranks
----------------------
The masterUncollated and collated fileHandlers can now use multiple ranks for
writing e.g.:
mpirun -np 6 simpleFoam -parallel -ioRanks '(0 3)'
In this example ranks 0 ('processor0') and 3 ('processor3') now handle all the
I/O. Rank 0 handles 0,1,2 and rank 3 handles 3,4,5. The set of IO ranks should always
include 0 as first element and be sorted in increasing order.
The collated fileHandler uses the directory naming processorsNNN_XXX-YYY where
NNN is the total number of processors and XXX and YYY are first and last
processor in the rank, e.g. in above example the directories would be
processors6_0-2
processors6_3-5
and each of the collated files in these contains data of the local ranks
only. The same naming also applies when e.g. running decomposePar:
decomposePar -fileHandler collated -ioRanks '(0 3)'
New: Distributed data
---------------------
The individual root directories can be placed on different hosts with different
paths if necessary. In the current framework it is necessary to specify the
root per slave process but this has been simplified with the option of specifying
the root per host with the -hostRoots command line option:
mpirun -np 6 simpleFoam -parallel -ioRanks '(0 3)' \
-hostRoots '("machineA" "/tmp/" "machineB" "/tmp")'
The hostRoots option is followed by a list of machine name + root directory, the
machine name can contain regular expressions.
New: hostCollated
-----------------
The new hostCollated fileHandler automatically sets the 'ioRanks' according to
the host name with the lowest rank e.g. to run simpleFoam on 6 processors with
ranks 0-2 on machineA and ranks 3-5 on machineB with the machines specified in
the hostfile:
mpirun -np 6 --hostfile hostfile simpleFoam -parallel -fileHandler hostCollated
This is equivalent to
mpirun -np 6 --hostfile hostfile simpleFoam -parallel -fileHandler collated -ioRanks '(0 3)'
This example will write directories:
processors6_0-2/
processors6_3-5/
A typical example would use distributed data e.g. no two nodes, machineA and
machineB, each with three processes:
decomposePar -fileHandler collated -case cavity
# Copy case (constant/*, system/*, processors6/) to master:
rsync -a cavity machineA:/tmp/
# Create root on slave:
ssh machineB mkdir -p /tmp/cavity
# Run
mpirun --hostfile hostfile icoFoam \
-case /tmp/cavity -parallel -fileHandler hostCollated \
-hostRoots '("machineA" "/tmp" "machineB" "/tmp")'
Contributed by Mattijs Janssens
Specialized variants of the power law porosity and k epsilon turbulence models
developed to simulate atmospheric flow over forested and non-forested complex
terrain.
Class
Foam::powerLawLopesdaCosta
Description
Variant of the power law porosity model with spatially varying
drag coefficient
given by:
\f[
S = -\rho C_d \Sigma |U|^{(C_1 - 1)} U
\f]
where
\vartable
\Sigma | Porosity surface area per unit volume
C_d | Model linear coefficient
C_1 | Model exponent coefficient
\endvartable
Reference:
\verbatim
Costa, J. C. P. L. D. (2007).
Atmospheric flow over forested and non-forested complex terrain.
\endverbatim
Class
Foam::RASModels::kEpsilonLopesdaCosta
Description
Variant of the standard k-epsilon turbulence model with additional source
terms to handle the changes in turbulence in porous regions represented by
the powerLawLopesdaCosta porosity model.
Reference:
\verbatim
Costa, J. C. P. L. D. (2007).
Atmospheric flow over forested and non-forested complex terrain.
\endverbatim
The default model coefficients are
\verbatim
kEpsilonLopesdaCostaCoeffs
{
Cmu 0.09;
C1 1.44;
C2 1.92;
sigmak 1.0;
sigmaEps 1.3;
}
\endverbatim
Tutorial case to follow.
Minmod is the default limiter function and specified with an explicit name e.g.:
gradSchemes
{
default Gauss linear;
limited cellLimited Gauss linear 1;
}
Venkatakrishnan and cubic limiter functions are also provided and may be
specified explicitly e.g.:
gradSchemes
{
default Gauss linear;
limited cellLimited<Venkatakrishnan> Gauss linear 1;
}
or
gradSchemes
{
default Gauss linear;
limited cellLimited<cubic> 1.5 Gauss linear 1;
}
The standard minmod function is recommended for most applications but if
convergence or stability problems arise it may be beneficial to use one of the
alternatives which smooth the gradient limiting. The Venkatakrishnan is not
well formulated and allows the limiter to exceed 1 whereas the cubic limiter is
designed to obey all the value and gradient constraints on the limiter function,
see
Michalak, K., & Ollivier-Gooch, C. (2008).
Limiters for unstructured higher-order accurate solutions
of the Euler equations.
In 46th AIAA Aerospace Sciences Meeting and Exhibit (p. 776).
The cubic limiter function requires the transition point at which the limiter
function reaches 1 is an input parameter which should be set to a value between
1 and 2 although values larger than 2 are physical but likely to significantly
reduce the accuracy of the scheme.
VenkatakrishnanGradientLimiter: Updated documentation
cubicGradientLimiter: Documented private data
The tutorial demonstrates generation of a C-grid mesh using blockMesh
The geometry is provided by a surface mesh (OBJ file) of the NACA0012 aerofoil
The case is setup with a freestream flow speed of Ma=0.72
Thanks to Kai Bastos at Duke University for the geometry and helpful input.
Description
This boundary condition extrapolates field to the patch using the near-cell
values and adjusts the distribution to match the specified, optionally
time-varying, mean value. This extrapolated field is applied as a
fixedValue for outflow faces but zeroGradient is applied to inflow faces.
This boundary condition can be applied to pressure when inletOutlet is
applied to the velocity so that a zeroGradient condition is applied to the
pressure at inflow faces where the velocity is specified to avoid an
unphysical over-specification of the set of boundary conditions.
Usage
\table
Property | Description | Required | Default value
meanValue | mean value Function1 | yes |
phi | Flux field name | no | phi
\endtable
Example of the boundary condition specification:
\verbatim
<patchName>
{
type fixedMeanOutletInlet;
meanValue 1.0;
}
\endverbatim
See also
Foam::fixedMeanFvPatchField
Foam::outletInletFvPatchField
Foam::Function1Types
These BCs blend between typical inflow and outflow conditions based on the
velocity orientation.
airFoil2D tutorial updated to demonstrate these new BCs.
In constant/chemistryProperties in addition to the specification of the initial
ODE integration time-step used at the start of the run:
initialChemicalTimeStep 1e-12;
this time step may now also be specified for every chemistry integration by
setting the optional entry maxChemicalTimeStep, e.g.
maxChemicalTimeStep 1e-12;
The number of characters needed to print a double in scientific format
is 8 plus the number of decimal places; e.g., -6.453452e-231 (6 decimal
places, 14 characters). This has been set in writeFile.C, replacing a
value of 7. Presumably, the case of three digits in the exponent was not
considered when this was first implemented. This change ensures at least
one character of whitespace between tabulated numbers.
This resolves bug report https://bugs.openfoam.org/view.php?id=2801
chtMultiRegionFoam now supports reaction/combustion modelling in fluid
regions in the same way as reactingFoam.
TUT: chtMultiRegionFoam: Added reverseBurner tutorial
This tutorial demonstrates chtMultiRegionFoam's combustion capability
Thermo and reaction thermo macros have been renamed and refactored. If
the name is plural (make???Thermos) then it adds the model to all
selection tables. If not (make???Thermo) then it only adds to the
requested psi or rho table.
This mixture allows a reacting solver to be used with a single component
fluid without the additional case files usually required for reacting
thermodynamics.
reactionThermo: Instantiated more single component mixtures
ENH: reactionThermo: Select singleComponentMixture as pureMixture
A pureMixture can now be specified in a reacting solver. This further
enhances compatibility between non-reacting and reacting solvers.
To achieve this, mixtures now have a typeName function of the same form
as the lower thermodyanmic models. In addition, to avoid name clashes,
the reacting thermo make macros have been split into those that create
entries on multiple selection tables, and those that just add to the
reaction thermo table.
This function object will write a paraview-viewable field showing the
area-density of parcel collisions on every patch face. It also outputs
the rate of collisions hitting each patch face, calculated over an
interval equal to the time elapsed since the last output. It has an
optional entry to specify a minimum incident speed below which a
collision is not counted.
It can be enabled in the cloud properties file as follows:
cloudFunctions
{
patchCollisionDensity1
{
type patchCollisionDensity;
minSpeed 1e-3; // (optional)
}
}
This work was supported by Anton Kidess, at Hilti
The combustion and chemistry models no longer select and own the
thermodynamic model; they hold a reference instead. The construction of
the combustion and chemistry models has been changed to require a
reference to the thermodyanmics, rather than the mesh and a phase name.
At the solver-level the thermo, turbulence and combustion models are now
selected in sequence. The cyclic dependency between the three models has
been resolved, and the raw-pointer based post-construction step for the
combustion model has been removed.
The old solver-level construction sequence (typically in createFields.H)
was as follows:
autoPtr<combustionModels::psiCombustionModel> combustion
(
combustionModels::psiCombustionModel::New(mesh)
);
psiReactionThermo& thermo = combustion->thermo();
// Create rho, U, phi, etc...
autoPtr<compressible::turbulenceModel> turbulence
(
compressible::turbulenceModel::New(rho, U, phi, thermo)
);
combustion->setTurbulence(*turbulence);
The new sequence is:
autoPtr<psiReactionThermo> thermo(psiReactionThermo::New(mesh));
// Create rho, U, phi, etc...
autoPtr<compressible::turbulenceModel> turbulence
(
compressible::turbulenceModel::New(rho, U, phi, *thermo)
);
autoPtr<combustionModels::psiCombustionModel> combustion
(
combustionModels::psiCombustionModel::New(*thermo, *turbulence)
);
ENH: combustionModel, chemistryModel: Simplified model selection
The combustion and chemistry model selection has been simplified so
that the user does not have to specify the form of the thermodynamics.
Examples of new combustion and chemistry entries are as follows:
In constant/combustionProperties:
combustionModel PaSR;
combustionModel FSD;
In constant/chemistryProperties:
chemistryType
{
solver ode;
method TDAC;
}
All the angle bracket parts of the model names (e.g.,
<psiThermoCombustion,gasHThermoPhysics>) have been removed as well as
the chemistryThermo entry.
The changes are mostly backward compatible. Only support for the
angle bracket form of chemistry solver names has been removed. Warnings
will print if some of the old entries are used, as the parts relating to
thermodynamics are now ignored.
ENH: combustionModel, chemistryModel: Simplified model selection
Updated all tutorials to the new format
STYLE: combustionModel: Namespace changes
Wrapped combustion model make macros in the Foam namespace and removed
combustion model namespace from the base classes. This fixes a namespace
specialisation bug in gcc 4.8. It is also somewhat less verbose in the
solvers.
This resolves bug report https://bugs.openfoam.org/view.php?id=2787
ENH: combustionModels: Default to the "none" model
When the constant/combustionProperties dictionary is missing, the solver
will now default to the "none" model. This is consistent with how
radiation models are selected.
and replaced multiphaseInterDyMFoam with a script which reports this change.
The multiphaseInterDyMFoam tutorials have been moved into the multiphaseInterFoam directory.
This change is one of a set of developments to merge dynamic mesh functionality
into the standard solvers to improve consistency, usability, flexibility and
maintainability of these solvers.
Henry G. Weller
CFD Direct Ltd.
and replaced interDyMFoam with a script which reports this change.
The interDyMFoam tutorials have been moved into the interFoam directory.
This change is one of a set of developments to merge dynamic mesh functionality
into the standard solvers to improve consistency, usability, flexibility and
maintainability of these solvers.
Henry G. Weller
CFD Direct Ltd.
interMixingFoam, multiphaseInterFoam: Updated for changes to interFoam
and replaced rhoPimpleDyMFoam with a script which reports this change.
The rhoPimpleDyMFoam tutorials have been moved into the rhoPimpleFoam directory.
This change is the first of a set of developments to merge dynamic mesh
functionality into the standard solvers to improve consistency, usability,
flexibility and maintainability of these solvers.
Henry G. Weller
CFD Direct Ltd.
rhoReactingFoam: Updated for changes to rhoPimpleFoam files
Now pimpleDyMFoam is exactly equivalent to pimpleFoam when running on a
staticFvMesh. Also when the constant/dynamicMeshDict is not present a
staticFvMesh is automatically constructed so that the pimpleDyMFoam solver can
run any pimpleFoam case without change.
pimpleDyMFoam: Store Uf as an autoPtr for better error handling
pimpleFoam: Set initial deltaT from the Courant number
for improved stability on start-up and compatibility with pimpleDyMFoam
ENH: pimpleFoam: Merged dynamic mesh functionality of pimpleDyMFoam into pimpleFoam
and replaced pimpleDyMFoam with a script which reports this change.
The pimpleDyMFoam tutorials have been moved into the pimpleFoam directory.
This change is the first of a set of developments to merge dynamic mesh
functionality into the standard solvers to improve consistency, usability,
flexibility and maintainability of these solvers.
Henry G. Weller
CFD Direct Ltd.
tutorials/incompressible/pimpleFoam: Updated pimpleDyMFoam tutorials to run pimpleFoam
Renamed tutorials/incompressible/pimpleFoam/RAS/wingMotion/wingMotion2D_pimpleDyMFoam
-> tutorials/incompressible/pimpleFoam/RAS/wingMotion/wingMotion2D_pimpleFoam
XiEngineFoam is a premixed/partially-premixed combustion engine solver which
exclusively uses the Xi flamelet combustion model.
engineFoam is a general engine solver for inhomogeneous combustion with or
without spray supporting run-time selection of the chemistry-based combustion
model.
Standard crank-connecting rod and the new free-piston kinematics motion options
are provides, others can easily be added.
Contributed by Francesco Contino and Nicolas Bourgeois, BURN Research Group.
The patch magSf calculation has been changed so that it uses the same
triangulation as the overlap algorithm. This improves consistency and
means that for exactly conforming patches (typically before any mesh
motion) the weights do not require normalisation.
Resolves bug-report https://bugs.openfoam.org/view.php?id=2785
ENH: compressibleInterFoam family: merged two-phase momentum stress modelling from compressibleInterPhaseTransportFoam
The new momentum stress model selector class
compressibleInterPhaseTransportModel is now used to select between the options:
Description
Transport model selection class for the compressibleInterFoam family of
solvers.
By default the standard mixture transport modelling approach is used in
which a single momentum stress model (laminar, non-Newtonian, LES or RAS) is
constructed for the mixture. However if the \c simulationType in
constant/turbulenceProperties is set to \c twoPhaseTransport the alternative
Euler-Euler two-phase transport modelling approach is used in which separate
stress models (laminar, non-Newtonian, LES or RAS) are instantiated for each
of the two phases allowing for different modeling for the phases.
Mixture and two-phase momentum stress modelling is now supported in
compressibleInterFoam, compressibleInterDyMFoam and compressibleInterFilmFoam.
The prototype compressibleInterPhaseTransportFoam solver is no longer needed and
has been removed.
Another exception has been added to globalIndexAndTransform to prevent
transformations being generated from coupled patch pairs marked with
coincident-full-match transformations. Foamy generates such patches, and
the faces on them at intermediate stages of meshing can be degenerate,
making the calculation of transformations unreliable. This change
enforces the definition that coincident-full-match patch pairs are not
transformed.
To unsure fvOptions are instantiated for post-processing createFvOptions.H must
be included in createFields.H rather than in the solver directly.
Resolves bug-report https://bugs.openfoam.org/view.php?id=2733
BUG: porousSimpleFoam: moved createFvOptions.H into createFields.H for -postProcess option
Resolves bug-report https://bugs.openfoam.org/view.php?id=2733
BUG: solvers: Moved fvOption construction into createFields.H for post-processing
This ensures that the fvOptions are constructed for the -postProcessing option
so that functionObjects which process fvOption data operate correctly in this
mode.
- actually prevent this type of thing:
Switch sw;
sw = "none";
without relinquishing automatic conversion to/from bool.
Nonetheless, make construct from string explicit.
- Added some minor optimization for the lookup of the switch names.
- can be useful either for flow-rate weighting where backflow
is to be ignored in the average, or for flow-rate weighting
on surfaces with inconsistent orientation.
Reworked to code to make better use of Enum (the NamedEnum
replacement). Enum doesn't require contiguous enumeration values,
which lets us use bitmasking of similar operations to reduce
duplicate code.
- the tokenType was being send via write(char), which includes
isspace filtering. If the tokenType enumeration coincides
with a whitespace character, it would be suppressed.
Now add character directly to the buffer.
STYLE: some additional minor private methods to help refactoring
- readStringFromBuffer, writeStringToBuffer for common string
operation.
When specifying the averaging data, a new `windowType` option is
available, taking the values:
- none: no windowing
- approximate: past functionality (v1706 and earlier)
- exact: exact moving average - will store and write (for restart) all
fields in the window
- the zero::null and one::null sub-classes add an additional null
output adapter.
The function of the nil class (special-purpose class only used for
HashSet) is now taken by zero::null.
- add -compiler=NAME option to remove a build or platforms directory
corresponding to any specified compiler on the current arch.
- when -compiler or -compiler=NAME is specified, also clean related
sub-directories as well. This will cleanup mpi-related directory.
- consistent with C++ STL conventions, the reverse iterators should
use operator++ to transit the list from rbegin() to rend().
The previous implementation used raw pointers, which meant that they
had the opposite behaviour: operator-- to transit from rbegin() to
rend().
The updated version only has operator++ defined, thus the compiler
should catch any possible instances where people were using the old
(incorrect) versions.
- updated forAllReverseIters() and forAllConstReverseIters() macros to
be consistent with new implementation and with C++ STL conventions.
- this increases the flexibility of the interface
- Add stringOps 'natural' string sorting comparison.
Digits are sorted in their natural order, which means that
(file10.txt file05.txt file2.txt)
are sorted as
(file2.txt file05.txt file10.txt)
STYLE: consistent naming of template parameters for comparators
- Compare for normal binary predicates
- ListComparePredicate for list compare binary predicates
- similar to word::validate to allow stripping of invalid characters
without triggering a FatalError.
- use this validated fileName in Foam::readDir to avoid problems when
a directory contains files with invalid characters in their names
- adjust rmDir to handle filenames with invalid characters
- fileName::equals() static method to compare strings while ignoring
any differences that are solely due to duplicate slashes
- more consistent naming:
* Versions that hold and manage their own memory:
IListStream, OListStream
* Versions that reference a fixed size external memory:
UIListStream, UOListStream
- use List storage instead of DynamicList within OListStream.
Avoids duplicate bookkeeping, more direct handling of resizing.
- The problem occurs when using atof to parse values such as "1e-39"
since this is out of range for a float and _can_ set errno to
ERANGE.
Similar to parsing of integers, now parse with the longest floating
point representation "long double" via strtold (guaranteed to be
part of C++11) and verify against the respective VGREAT values for
overflow. Treat anything smaller than VSMALL to be zero.
- makes it accessible for containers that manage their own storage
and derive directly from UList.
- DynamicList::min_size() method to access the corresponding
SizeMin template parameter.
- ensure consistency in the reserve size for the constructor
DynamicList<..> lst(N);
now has identical sizing as
DynamicList<..> lst();
reserve(N);
- Arrhenius viscocity model for incompressible viscocity.
- energyTransport FO for incompressible single and multiple phase
flows and viscousDissipation fvOption source.
- Tutorial to show the use of energyTransport:
multiphase/multiphaseInterFoam/laminar/mixerVessel2D
- Tutorial to show viscousDissipation:
compressible/rhoPimpleFoam/RAS/TJunction
- reduce coding clutter, avoiding allocated pointers when possible.
IFstream and OFstream continue to use pointers since they handle
compressed files, other streams can do without them.
- these provide a similar functionality to string-streams, but operate
on a externally provided memory buffer which can be used to reduce
the amount of copying.
- classes were previously staged as part of the ADIOS community
repository.
- for convenience and symmetry with OStringStream
STYLE: void return value for stream rewind() methods
- this makes it easier to design bidirectional streams
- low-level beginRaw(), writeRaw(), endRaw() methods.
These can be used to directly add '()' decorators for serial output
or prepare/cleanup parallel buffers.
Used, for example, when outputting indirect lists in binary to avoid.
- used in various places to test if the input can be parsed as a
label/scalar, so warnings tend to flood the output.
- be more explicit when encountering range errors
- avoid meshModifier contents from being read immediately upon
construction, since this recreates an existing modifier instead of
allowing us to specify our own.
- improve functional compatibility with DynList (remove methods)
* eg, remove an element from any position in a DynamicList
* reduce the number of template parameters
* remove/subset regions of DynamicList
- propagate Swap template specializations for lists, hashtables
- move construct/assignment to various containers.
- add find/found methods for FixedList and UList for a more succinct
(and clearer?) usage than the equivalent global findIndex() function.
- simplify List_FOR_ALL loops
- this reduces the number of functions and allows lazy loading of
completion options, which makes it easy to quickly add any other
OpenFOAM application in completion.
The generic '_of_complete_' function handles (bash) completion for
any OpenFOAM application. On the first call for any particular
application, it retrieves the available options from the application
help output and adds this information to its environmental cache for
subsequent use.
- Tcsh completion uses the same function via a bash wrapper.
But since its wrapper is transient, the on-the-fly generation would
be less efficient. For this case, a pre-generated completion_cache
can be used, which is generated with
bin/tools/foamCreateCompletionCache
- handles the case where we are currently completing something that
does not appear to be an option. For example,
foamDictionary -expanded someD[TAB]
should complete the filename, not present more options.
- The logic for switching input-mode was previously completely
encapsulated within the #inputMode directive, but without any
programming equivalent. Furthermore, the encapsulation in inputMode
made the logic less clear in other places.
Exposing the inputMode as an enum with direct access from entry
simplifies things a fair bit.
- eliminate one level of else/if nesting in entryIO.C for clearer logic
- for dictionary function entries, simply use
addNamedToMemberFunctionSelectionTable() and avoid defining a type()
as a static. For most function entries the information is only used
to get a name for the selection table lookup anyhow.
- although this has been supported for many years, the tutorials
continued to use "convertToMeters" entry, which is specific to blockMesh.
The "scale" is more consistent with other dictionaries.
ENH:
- ignore "scale 0;" (treat as no scaling) for blockMeshDict,
consistent with use elsewhere.
- currently no cleanup of completions when deactivating an OpenFOAM
tcsh environment
- tab completion with directories adds a space after the slash, which
makes navigation a bit annoying.
- useful operations for other string representations of fileName types.
The return type is in general a std::string with any narrowing
being done by the caller on the return value.
- consolidate word::validated() into word::validate() and also allow
as short form for string::validate<word>(). Also less confusing than
having similarly named methods that essentially do the same thing.
- more consistent const access when iterating over strings
- add valid(char) for keyType and wordRe
- use complete -o filenames, dropped -o nospace to make it more responsive.
- restructure completion code to use a unified backend, which makes it easier
understand, maintain and re-use.
- foamCreateBashCompletions now simply outputs to a stdout, and allows
quick generation of completion of single applications.
- add -fileHandler completion in anticipation of future changes there.
- relocated as etc/config.s/bash_completion to prevent inadvertently
having two versions (.com, .org) installed at the same time.
- Instead of relying on #inputMode to effect a global change it is now
possible (and recommended) to a temporary change in the inputMode
for the following entry.
#default : provide default value if entry is not already defined
#overwrite : silently remove a previously existing entry
#warn : warn about duplicate entries
#error : error if any duplicate entries occur
#merge : merge sub-dictionaries when possible (the default mode)
This is generally less cumbersome than the switching the global
inputMode. For example to provide a set of fallback values.
#includeIfPresent "user-files"
...
#default value uniform 10;
vs.
#includeIfPresent "user-files"
#inputMode protect
...
value uniform 10;
#inputMode merge // _Assuming_ we actually had this before
These directives can also be used to suppress the normal dictionary
merge semantics:
#overwrite dict { entry val; ... }
- With special-purpose templating it is possible to have file contents
that almost look like an OpenFOAM file, but which are not.
The contents do not need to be deliberately tricky, even the simplest
README:
FoamFile is the first word parsed in OpenFOAM files
will trigger problems.
We now trap any IOerror on these and reject this type of file as invalid.
- error::throwExceptions(bool) returning the previous state makes it
easier to set and restore states.
- throwing() method to query the current handling (if required).
- the normal error::throwExceptions() and error::dontThrowExceptions()
also return the previous state, to make it easier to restore later.
- installed under /usr/include/scotch/scotch.h
ENH: obtain fallback value for SCOTCH_VERSION from the header
COMP: add support for metis, scotch static libraries (eg, EasyBuild)
- patterns only supported for the final element.
To create an element as a pattern instead of a word, an embedded
string quote (single or double) is used for that element.
Any of the following examples:
"/top/sub/dict/'(p|U).*" 100;
"/top/sub/dict/'(p|U).*'" 100;
"/top/sub/dict/\"(p|U).*" 100;
"/top/sub/dict/\"(p|U).*\"" 100;
are equivalent to the longer form:
top
{
sub
{
dict
{
"(p|U).*" 100;
}
}
}
It is not currently possible to auto-vivify intermediate
dictionaries with patterns.
NOK "/nonexistent.*/value" 100;
OK "/existing.*/value" 100;
- full scoping also works for the #remove directive
#remove "/dict1/subdict2/entry1"
- Resolve ambiguity by using the following rules:
1) starts with '/' => absolute file-system path
2) starts with './' or '../' => file-system path relative to CWD
3) otherwise treat as relative to the case
STYLE: allow write access to headerClassName
- resets the output buffer completely - implementing what rewind was
likely meant to have accomplished for many use cases.
STYLE: OSHA1stream reset() for symmetry. Deprecate rewind().
- use allocator class to wrap the stream pointers instead of passing
them into ISstream, OSstream and using a dynamic cast to delete
then. This is especially important if we will have a bidirectional
stream (can't delete twice!).
STYLE:
- file stream constructors with std::string (C++11)
- for rewind, explicit about in|out direction. This is not currently
important, but avoids surprises with any future bidirectional access.
- combined string streams in StringStream.H header.
Similar to <sstream> include that has both input and output string
streams.
The 4.x tracking enforces reduced dimensionality on the parcels by
moving them to the centre of the mesh at the start of each track,
without considering the topology. This can leave the parcel outside it's
associated tetrahedron.
The barycentric algorithm isn't tolerant to incorrect topology, so
instead of changing position, it was written to track to the mesh
centre. This worked, but effectively doubled the number of tracking
calls. This additional cost has now been removed by absorbing the
constraint displacement into the existing motion track, so that the same
number of tracking steps are performed as before.
Partially resolves bug report https://bugs.openfoam.org/view.php?id=2688
Note: performs its own tracking and does not rely on the base
particle::trackXXX functions, and uses a local particle position.
Look to update to barycentric tracking in the future.
old "positions" file form
The change to barycentric-based tracking changed the contents of the
cloud "positions" file to a new format comprising the barycentric
co-ordinates and other cell position-based info. This broke
backwards compatibility, providing no option to restart old cases
(v1706 and earlier), and caused difficulties for dependent code, e.g.
for post-processing utilities that could only infer the contents only
after reading.
The barycentric position info is now written to a file called
"coordinates" with provision to restart old cases for which only the
"positions" file is available. Related utilities, e.g. for parallel
running and data conversion have been updated to be able to support both
file types.
To write the "positions" file by default, use set the following option
in the InfoSwitches section of the controlDict:
writeLagrangianPositions 1;
The splash kinetic energy has been changed to depend upon the velocity
of the parcel normal to the wall, rather than the absolute velocity, in
accordance with the original reference.
This patch was contributed by Stefan Hildenbrand at Pfinder
Resolves bug report https://bugs.openfoam.org/view.php?id=2682
Interpolated continuous phase data is only needed during a track and
therefore shouldn't be stored on the parcel. The continuous velocity,
density and viscosity have been moved from the kinematic parcel to the
kinematic parcel tracking data. This reduces the memory usage of the
kinematic layer by about one third. The thermo and reacting layers still
require the same treatment.
A lot of methods were taking argument data which could be referenced or
generated from the parcel class at little or no additional cost. This
was confusing and generated the possibility of inconsistent data states.
Tracking data classes are no longer templated on the derived cloud type.
The advantage of this is that they can now be passed to sub models. This
should allow continuous phase data to be removed from the parcel
classes. The disadvantage is that every function which once took a
templated TrackData argument now needs an additional TrackCloudType
argument in order to perform the necessary down-casting.
The combined solver includes the most advanced and general functionality from
each solver including:
Continuous phase
Lagrangian multiphase parcels
Optional film
Continuous and Lagrangian phase reactions
Radiation
Strong buoyancy force support by solving for p_rgh
The reactingParcelFoam and reactingParcelFilmFoam tutorials have been combined
and updated.
The absolute value of the the time has been added to the rigid body
model state. This value is not directly necessary for calculating the
evolution of the rigid body system, it just facilitates the
implementation of sub-models which are in some way time-dependent.
Mixture molecular weight is now evaluated in heThermo like everything
else, relying on the low level specie mixing rules. Units have also been
corrected.
SpecieMixture: Pure virtual definition for W to prevent Clang warning
to support the evaporation of the solvent from the wax film and the changes in
viscosity caused by the reduction in solvent content.
BUG: filmViscosityModel::thixotropicViscosity: Corrected sign of impingement rate
to compensate for rhoSp having the wrong sign
BUG: surfaceFilmModels::waxSolventEvaporation: Corrected handling of impingement
ENH: surfaceFilmModels::waxSolventViscosity: Changed mixing to mole-fraction based
ENH: surfaceFilmModels::thermoSingleLayer: Added call to solveContinuity before updateSubmodels
to allow sub-models to solve transport equations for conserved properties
In the event that matching centroids across a coupled patch pair fails,
we fall back to matching the face point average. The latter can be
obtained more reliably on degenerate faces as the calculation does not
involve division by the face area.
This fallback was already implemented as part of processorPolyPatch.
This change also applies it to the faceCoupleInfo class used by
reconstructParMesh.
In this version of compressibleInterFoam separate stress models (laminar,
non-Newtonian, LES or RAS) are instantiated for each of the two phases allowing
for completely different modeling for the phases.
e.g. in the climbingRod tutorial case provided a Newtonian laminar model is
instantiated for the air and a Maxwell non-Newtonian model is instantiated for
the viscoelastic liquid. To stabilize the Maxwell model in regions where the
liquid phase-fraction is 0 the new symmTensorPhaseLimitStabilization fvOption is
applied.
Other phase stress modeling combinations are also possible, e.g. the air may be
turbulent but the liquid laminar and an RAS or LES model applied to the air
only. However, to stabilize this combination a suitable fvOption would need to
be applied to the turbulence properties where the air phase-fraction is 0.
Henry G. Weller, Chris Greenshields
CFD Direct Ltd.
The restraints generate either joint-local (tau) or global (fx) forces.
At the moment they all generate the latter. This change corrects three
of the four restraints so that the forces are in the gobal coordinate
system and not the local coordinate system of the body.
The problem with this is that the forward dynamics code then transforms
most of the forces back to the body local coordinate system. A better
solution would be to associate restraints which are more sensibly
defined in a local frame with the joints instead of the bodies, and
return the forces as part of the tau variable.
Two boundary conditions for the modelling of semi-permeable baffles have
been added. These baffles are permeable to a number of species within
the flow, and are impermeable to others. The flux of a given species is
calculated as a constant multipled by the drop in mass fraction across
the baffle.
The species mass-fraction condition requires the transfer constant and
the name of the patch on the other side of the baffle:
boundaryField
{
// ...
membraneA
{
type semiPermeableBaffleMassFraction;
samplePatch membranePipe;
c 0.1;
value uniform 0;
}
membraneB
{
type semiPermeableBaffleMassFraction;
samplePatch membraneSleeve;
c 0.1;
value uniform 1;
}
}
If the value of c is omitted, or set to zero, then the patch is
considered impermeable to the species in question. The samplePatch entry
can also be omitted in this case.
The velocity condition does not require any special input:
boundaryField
{
// ...
membraneA
{
type semiPermeableBaffleVelocity;
value uniform (0 0 0);
}
membraneB
{
type semiPermeableBaffleVelocity;
value uniform (0 0 0);
}
}
These two boundary conditions must be used in conjunction, and the
mass-fraction condition must be applied to all species in the
simulation. The calculation will fail with an error message if either is
used in isolation.
A tutorial, combustion/reactingFoam/RAS/membrane, has been added which
demonstrates this transfer process.
This work was done with support from Stefan Lipp, at BASF.
To disable face correspondence checking set
checkFaceCorrespondence off;
in blockMeshDict. This is necessary in the rare cases where adjacent block
faces do not need to correspond because they are geometrically collapsed,
e.g. to form a pole/axis.
Resolves bug-report https://bugs.openfoam.org/view.php?id=2711
ENH: foamyHexMesh: Made default region volume type that of it's parent
Foamy surface conformation entries have a "meshableSide" entry which
controls which side of the surface is to be meshed. Typically this is
set "inside" for boundaries and "both" for baffles. A sub-region's
default entry is now taken from it's parent, rather than a specific
value (it was "inside"). This is consistent with how other entries are
handled.
surfaceConformation
{
locationInMesh (0 0 0);
geometryToConformTo
{
baffle
{
featureMethod extractFeatures;
includedAngle 120;
meshableSide both; // <-- per-surface setting
regions
{
disk
{
meshableSide both; // <-- per-region setting*
// *in this example, this entry is not needed, as it
// is taken from the per-surface setting above
}
}
}
// ...
}
}
ENH: foamyHexMesh: Added (reinstated) baffle patches
A patch can now be assigned to a baffle surface. This assignment will
take precedence over any face-zones.
surfaceConformation
{
locationInMesh (0 0 0);
geometryToConformTo
{
disk
{
featureMethod extractFeatures;
includedAngle 120;
meshableSide both; // <-- baffle
patchInfo
{
type wall;
inGroups (walls);
}
}
// ...
}
}
STYLE: foamyHexMesh: Switched off output of all the secondary meshes
The integration of force and heat transfer onto the particle is
facilitated by a run-time-selectable integration scheme. These schemes
were written to generate the value at the end of an intregration step
and also an average value over the step from which the total transfer
was computed.
The average value in the Euler scheme was implemented incorrectly, which
resulted in the momentum and heat transfer processes being
non-conservative. Implementing the average correctly, however, would
have inteoduced a number of trancendental functions which would have
negated the purpose of the Euler scheme as the cheap and stable option.
The schemes have been rewritten to generate changes over the step,
rather than the final value. This change is then used to calculate the
transfers. Regardless of the scheme, this formulation is guaranteed to
be conservative, and the Euler scheme remains computationally
inexpensive.
This change was made with help from Timo Niemi, VTT
This resolves bug report https://bugs.openfoam.org/view.php?id=2666
ENH: integrationSchemes: Further simplification and optimisation
Removed templating from integration schemes, improved the name
convention, and optimised the utilisation so that the virtual call is
only made once per integration in the KinematicParcel and the
ThermoParcel.
BUG: integrationSchemes: Corrections to coupled/non-coupled force splitting
The integration splitting implemented in commit a5806207 has been shown
to be incorrect in some cases. A new procedure has been implemented
which can correctly split the implicit-explicit integral into a number
of pieces, in order to calculate the contribution of each. This is
intended for integrating coupled and non-coupled particle momentum and
heat transfers.
However, currently there is only ever one implicit coefficient used in
these transfers (there is no implicit non-coupled contribution). The
evaluation has therefore been short-cutted to only do the integration
with respect to the coupled contributions. The splitting functionality
has been retained in case additional separate implicit coefficients are
required in the future.
This change was made with help from Timo Niemi, VTT
This resolves bug report https://bugs.openfoam.org/view.php?id=2666
XiEngineFoam is a premixed/partially-premixed combustion engine solver which
exclusively uses the Xi flamelet combustion model.
engineFoam is a general engine solver for inhomogeneous combustion with or
without spray supporting run-time selection of the chemistry-based combustion
model.
Standard crank-connecting rod and the new free-piston kinematics motion options
are provides, others can easily be added.
Contributed by Francesco Contino and Nicolas Bourgeois, BURN Research Group.
- added an explicit print, but only report profiling to the log
file from master process.
We don't wish to overwrite any profiling that was conducted during
the simulation. Besides which, we don't have a proper Time object
for handling the write nicely either.
- add note in BuildIssues about the I_MPI_CC variable, which is needed
when building with Intel-MPI and gcc/clang.
This additional setting is needed since the changes needed to solve
the issue of building scotch with Intel-MPI and icc (issue #434)
means that mpiicc is now being used as the wrapper when compiling
scotch.
- have the FOAM_MPI short name for INTELMPI start with 'impi-' instead
of just the version number.
Intel-MPI is often installed as /opt/intel/impi/4.1.3.049, which
results in 'FOAM_MPI=4.1.3.049' and the mpi flavour is lost.
Prefix these cases with 'impi-'
- csearch(), search(), csearchScoped(), searchScoped() methods
can be used to find an entry and also retain the enclosing
dictionary context.
- To avoid ambiguity between a dot (.) as a scoping character and
legal part of a keyword, entries can now be accessed directly using
slash-scoping semantics similar to file-names:
* cfindScopedDictPtr, findScopedDictPtr
- To get or create a sub-dictionary entry:
* makeScopedDictPtr, which behaves similarly to mkdirp in that it
will create any intermediate dictionaries as required.
- allows configuration without an environment variable.
For compatibility still respect FOAM_SIGFPE and FOAM_SETNAN
env-variables
- The env-variables are now treated as true/false switch values.
Previously there was just a check for env exists or not, but this
can be fairly fragile for a user's environment.
- erroneous double logic for subset meshes.
The underlying vtk::vtuCells uses a cellMap to map into a global
field, which also allows handling of decomposed polyhedral cells.
If a mesh subset is involved (eg, cellSet, cellZone), then the
set/zone cellMap can be used to ensure that the original number is
properly adjusted. For foamToVTK, the meshSubsetHelper already
does the subsetting and is used when loading fields.
Does not affect ParaView reader module since there we work on the
full field and do the subsetting manually (using the cellMap).
slip
The old behaviour assumed that the no-slip value was zero. This has
been extended to enable the user to supply a refValue - the value at
zero slip.
This was similar to the mixedFixedValueSlipFvPatchField behaviour in the
rhoCentralFoam library - now deprecated in favour of the templated
partialSlip version.
for consistency with reactingTwoPhaseEulerFoam and to ensure correct operation
of models requiring formal boundedness of phase-fractions.
Resolves bug-report https://bugs.openfoam.org/view.php?id=2589
- STLpoint.H
- isoAdvection.C
- checkMesh/writeFields.C
STYLE: drop construct STLpoint(Istream&), since it doesn't make much sense
- No use case for reading via an OpenFOAM stream and tokenizer.
Should always be parsing ASCII or reading binary directly.
Calculates the acoustic pressure based on Curle's analogy.
Curle's analogy is implemented as:
\f[
p' = 4 \frac{\pi}{c_0}\frac{\vec d}{|\vec d|^2}\frac{d(F)}{d(t)}
\f]
where
p' | Curle's acoustic pressure [Pa] or [Pa (m3/rho)]
c_0 | Reference speed of sound [m/s]
\vec d | Distance vector to observer locations [m]
F | Force [N] or [N (m3/rho)]
- disable automatically upgrading copyrights in files since changes to
not automatically imply a change in copyright. Eg, fixing a typo in
comments, or changing a variable from 'loopI' to 'loopi' etc.
- This provides a mechanism for moving mesh patches based on external
input (eg, from an external structures solver). The patch points are
influenced by the position and rotation of the lumped points.
BC: lumpedPointDisplacementPointPatchVectorField
Controlling mechanisms:
- externalCoupler
for coordinating the master/slave
- lumpedPointMovement
manages the patch-points motion, but also for extracting forces/moments
- lumpedPointState
represents the positions/rotations of the controlling points
Utils:
- lumpedPointZones
diagnostic for visualizing the correspondence between controlling
points and patch faces
- lumpedPointMovement
Test that the patch motion is as desired without invoking moveMesh.
With the -slave option, return items from a precalculated table
for the lumpedPointDisplacementPointPatchVectorField BC.
- simply removing the lock file on termination provides insufficient
information for the external application to know if it should take
over again or if OpenFOAM has terminated. Instead the "status=done"
content is now used by default.
Community contribution from Johan Roenby, DHI
IsoAdvector is a geometric Volume-of-Fluid method for advection of a
sharp interface between two incompressible fluids. It works on both
structured and unstructured meshes with no requirements on cell shapes.
IsoAdvector is as an alternative choice for the interface compression
treatment with the MULES limiter implemented in the interFoam family
of solvers.
The isoAdvector concept and code was developed at DHI and was funded
by a Sapere Aude postdoc grant to Johan Roenby from The Danish Council
for Independent Research | Technology and Production Sciences (Grant-ID:
DFF - 1337-00118B - FTP).
Co-funding is also provided by the GTS grant to DHI from the Danish
Agency for Science, Technology and Innovation.
The ideas behind and performance of the isoAdvector scheme is
documented in:
Roenby J, Bredmose H, Jasak H. 2016 A computational method for sharp
interface advection. R. Soc. open sci. 3: 160405.
[http://dx.doi.org/10.1098/rsos.160405](http://dx.doi.org/10.1098/rsos.160405)
Videos showing isoAdvector's performance with a number of standard
test cases can be found in this youtube channel:
https://www.youtube.com/channel/UCt6Idpv4C8TTgz1iUX0prAA
Project contributors:
* Johan Roenby <jro@dhigroup.com> (Inventor and main developer)
* Hrvoje Jasak <hrvoje.jasak@fsb.hr> (Consistent treatment of
boundary faces including processor boundaries, parallelisation,
code clean up
* Henrik Bredmose <hbre@dtu.dk> (Assisted in the conceptual
development)
* Vuko Vukcevic <vuko.vukcevic@fsb.hr> (Code review, profiling,
porting to foam-extend, bug fixing, testing)
* Tomislav Maric <tomislav@sourceflux.de> (Source file
rearrangement)
* Andy Heather <a.heather@opencfd.co.uk> (Integration into OpenFOAM
for v1706 release)
See the integration repository below to see the full set of changes
implemented for release into OpenFOAM v1706
https://develop.openfoam.com/Community/Integration-isoAdvector
- provide single parameter constructor for which the rotation direction
is determined based on the size/sign of the axis components.
The direction is aligned with one of the global axes.
- expose setTransform as a public method to allow the user to reset
the axesRotation if desired.
Adding special alphaCourantNo for overlaping
Adding bounded term to UEq.H for overInterDyMFoam
Changing to NO_WRITE for the cellMask field
Changing twoSimpleRotors tutorial to open domain
Adds overset discretisation to selected physics:
- diffusion : overLaplacianDyMFoam
- incompressible steady : overSimpleFoam
- incompressible transient : overPimpleDyMFoam
- compressible transient: overRhoPimpleDyMFoam
- two-phase VOF: overInterDyMFoam
The overset method chosen is a parallel, fully implicit implementation
whereby the interpolation (from donor to acceptor) is inserted as an
adapted discretisation on the donor cells, such that the resulting matrix
can be solved using the standard linear solvers.
Above solvers come with a set of tutorials, showing how to create and set-up
simple simulations from scratch.
- eliminates the PtrList requirement (more flexible)
COMP: use tmp intermediate for volPointInterpolation return value
- gcc 4.8.5 had some weird issue of otherwise not binding a const-ref.
(in foamVtkInternalWriterTemplates.C)
Temporal variation of Ta is generally more useful than spatial variation but
a run-time switch between the two modes of operation could be implemented in
needed.
- Use on/off vs longer compressed/uncompressed.
For consistency, replaced yes/no with on/off.
- Avoid the combination of binary/compressed,
which is disallowed and provokes a warning anyhow
- By definition, binary STL uses float (not double) when reading.
The ascii STL should be the same. This reduces memory overhead when
loading files. The older triSurface reader had float, the surfMesh
reader had double, but now has float.
- Inconsistency in the STL merge-tolerances between triSurface reader,
surfMesh reader and WM_SP vs WM_DP. Now use consistent tolerances
conrresponding to 10,100 * doubleSMALL.
- Similar float/double code adjustments for TRI format since this is
very similar to the STL reader and had a similar inconsistency between
the triSurface and surfMesh version. The AC3D reader still uses
double when reading, but this can be revisited in the future (and can
then remove the stichTriangles method too).
- only treat text as an option if it is preceded by 0-4 spaces.
This prevents the description of an option from being accidentally
detected as an option.
Solver for low Mach no. flows with adiabatic thermodynamics and updated
pressure-velocity coupling given by the RCM interpolation procedure
described in
\verbatim
Knacke, T. (2013).
Potential effects of Rhie & Chow type interpolations in airframe
noise simulations. In: Schram, C., Dénos, R., Lecomte E. (ed):
Accurate and efficient aeroacoustic prediction approaches for
airframe noise, VKI LS 2013-03.
\endverbatim
Original code supplied by Thilo Knacke, CFD E+F GmbH
contact: info@cfd-berlin.com
Integrated into OpenFOAM by OpenCFD Ltd.
2)Adapting divU in TEqn.H for compressibleInterDyMFoam and compressibleInterFoam
3)Re-instated sixDoFRigidBodyDisplacement as patch for pointFields. It allows to use a different fvDynamincMesh type
independently of the BC's
This is important when LTS stepping or large Co number is used.
Updating rhoBuoyantPimpleFoam to handle closed domain for rho thermo and incompressible Eos.
Consolidating chtMultiRegionSimpleFoam and chtMultiRegionFoam pEqs to use the same formulation as rhoBuoyantPimpleFoam and
rhoBuoyantSimpleFoam
- with the xml append format it is possible to write raw binary
(instead of base64), but the writer becomes more complicated.
Either needs two passes to create, or need to allocate a block
of space for the header information (like VTK itself does) and
write later.
* internalWriter
* patchWriter
* surfaceMeshWriter
* lagrangianWriter
Also these special purpose ones:
* foamVtkWriteSurfFields
- this shifts responsibility away from caller to the individual writers
for knowing which file formats are supported and which file ending is
appropriate. When the writer receives the output format request,
it can elect to downgrade or otherwise adjust it to what it can
actually manage (eg, legacy vs xml vs xml-append).
But currently still just with legacy format backends.
- was generally somewhat fragile. The main problem stems from the fact
that several interfaces may be attached to a boundary. No trivial
means of solving this without too much work for a feature that is only
"nice-to-have".
- "single" = One region for all files
- "file" = One region for each file
- "offset" = Offset regions per file
- "merge" = Merge regions by name
These specifications provide finer control when loading multiple
surfaces.
- the NamedEnum wrapper is somewhate too rigid.
* All enumerated values are contiguous, starting as zero.
* The implicit one-to-one mapping precludes using it for aliases.
* For example, perhaps we want to support alternative lookup names for an
enumeration, or manage an enumeration lookup for a sub-range.
- Remove the unused enums() method since it delivers wholly unreliable
results. It is not guaranteed to cover the full enumeration range,
but only the listed names.
- Remove the unused strings() method.
Duplicated functionality of the words(), but was never used.
- Change access of words() method from static to object.
Better code isolation. Permits the constructor to take over
as the single point of failure for bad input.
- Add values() method
- do not expose internal (HashTable) lookup since it makes it more
difficult to enforce constness and the implementation detail should
not be exposed. However leave toc() and sortedToc() for the interface.
STYLE: relocated NamedEnum under primitives (was containers)
- internal typedef as 'value_type' for some consistency with STL conventions
- The unset() method never auto-vivifies, whereas the set() method
always auto-vivifies. In the case where set() is called with a zero
for its argument - eg, set(index, 0) - this should behave
identically to an unset() and not auto-vivify out-of-range entries.
NOTE: in Reaction.C constructors bool initReactionThermo is used by solidReaction where there is no
need of setting a lhs - rhs thermo type for each reaction. This is needed for mechanism with reversible reactions
- This follows the same idea as cbegin/cend and is helpful when using
C++11 auto to ensure we have unambiguous const-safe access.
Previously:
====
typename someLongClass::const_iterator iter = someTable.find(key);
... later on:
*iter = value; // Oops, but caught by compiler.
We can save some typing with auto, but it is uncertain what we get:
====
auto iter = someTable.find(key);
// iterator or const_iterator?
// depends on someTable having const or non-const access.
... later on:
*iter = value; // Oops, but not caught by compiler.
Using cfind instead, auto will deduce const_iterator as the type:
====
auto iter = someTable.cfind(key); // definitely const_iterator
... later on:
*iter = value; // Oops, but caught by compiler.
Some versions of lsof print the mount point (if remote) after the
script path:
/hosts/mymachine/OpenFOAM/OpenFOAM-plus.develop/etc/cshrc (mymachine:/home)
This now gets filtered out.
- The reader module allows two levels of caching.
The OpenFOAM fvMesh can be cached in memory, for faster loading of
fields. Additionally, the translated VTK geometries are held in a
local cache. The cached VTK geometries should incur no additional
overhead since they use the VTK reference counting for their storage
management.
"pos" now returns 1 if the argument is greater than 0, otherwise it returns 0.
This is consistent with the common mathematical definition of the "pos" function:
https://en.wikipedia.org/wiki/Sign_(mathematics)
However the previous implementation in which 1 was also returned for a 0
argument is useful in many situations so the "pos0" has been added which returns
1 if the argument is greater or equal to 0. Additionally the "neg0" has been
added which returns 1 if if the argument is less than or equal to 0.
Now the "localEuler" ddt scheme does not apply any corrections due to
mesh-motion; the old-time volumes are not used and the mesh-motion flux is set
to zero. A consequence of these changes is that boundedness of transported
scalars is ensured but mesh-motion causes a conservation error which will
reduces to zero as steady-state is approached and the mesh becomes stationary.
Original commit message:
------------------------
Parallel IO: New collated file format
When an OpenFOAM simulation runs in parallel, the data for decomposed fields and
mesh(es) has historically been stored in multiple files within separate
directories for each processor. Processor directories are named 'processorN',
where N is the processor number.
This commit introduces an alternative "collated" file format where the data for
each decomposed field (and mesh) is collated into a single file, which is
written and read on the master processor. The files are stored in a single
directory named 'processors'.
The new format produces significantly fewer files - one per field, instead of N
per field. For large parallel cases, this avoids the restriction on the number
of open files imposed by the operating system limits.
The file writing can be threaded allowing the simulation to continue running
while the data is being written to file. NFS (Network File System) is not
needed when using the the collated format and additionally, there is an option
to run without NFS with the original uncollated approach, known as
"masterUncollated".
The controls for the file handling are in the OptimisationSwitches of
etc/controlDict:
OptimisationSwitches
{
...
//- Parallel IO file handler
// uncollated (default), collated or masterUncollated
fileHandler uncollated;
//- collated: thread buffer size for queued file writes.
// If set to 0 or not sufficient for the file size threading is not used.
// Default: 2e9
maxThreadFileBufferSize 2e9;
//- masterUncollated: non-blocking buffer size.
// If the file exceeds this buffer size scheduled transfer is used.
// Default: 2e9
maxMasterFileBufferSize 2e9;
}
When using the collated file handling, memory is allocated for the data in the
thread. maxThreadFileBufferSize sets the maximum size of memory in bytes that
is allocated. If the data exceeds this size, the write does not use threading.
When using the masterUncollated file handling, non-blocking MPI communication
requires a sufficiently large memory buffer on the master node.
maxMasterFileBufferSize sets the maximum size in bytes of the buffer. If the
data exceeds this size, the system uses scheduled communication.
The installation defaults for the fileHandler choice, maxThreadFileBufferSize
and maxMasterFileBufferSize (set in etc/controlDict) can be over-ridden within
the case controlDict file, like other parameters. Additionally the fileHandler
can be set by:
- the "-fileHandler" command line argument;
- a FOAM_FILEHANDLER environment variable.
A foamFormatConvert utility allows users to convert files between the collated
and uncollated formats, e.g.
mpirun -np 2 foamFormatConvert -parallel -fileHandler uncollated
An example case demonstrating the file handling methods is provided in:
$FOAM_TUTORIALS/IO/fileHandling
The work was undertaken by Mattijs Janssens, in collaboration with Henry Weller.
Fixed reaction source terms in the energy and species fraction equations
by multiplying by the phase fraction.
Resolves bug report https://bugs.openfoam.org/view.php?id=2591
Added a grow time and better allocate the CPU time to either add or grow. This
gives much more information to the user and helps changing the settings
accordingly.
Patch contributed by Francesco Contino
vectorField or vector2DField from scalarField components. To do this
properly and have it work for field-type combinations would require some
new field function macros.
Initially the listSwitches functions depended directly on argList functionality
but this has now been factored out so that the listSwitches functions are more
general and require only debug functionality.
Provides better context for the available boundary conditions, fvOptions,
functionObjects etc. and thus returns only those available to and compatible
with the particular application.
e.g.
pimpleFoam -help
Usage: pimpleFoam [OPTIONS]
options:
-case <dir> specify alternate case directory, default is the cwd
-listFunctionObjects
List functionObjects
-listFvOptions List fvOptions
-listRegisteredSwitches
List switches registered for run-time modification
-listScalarBCs List scalar field boundary conditions (fvPatchField<scalar>)
-listSwitches List switches declared in libraries but not set in
etc/controlDict
-listTurbulenceModels
List turbulenceModels
-listUnsetSwitches
List switches declared in libraries but not set in
etc/controlDict
-listVectorBCs List vector field boundary conditions (fvPatchField<vector>)
-noFunctionObjects
do not execute functionObjects
-parallel run in parallel
-postProcess Execute functionObjects only
-roots <(dir1 .. dirN)>
slave root directories for distributed running
-srcDoc display source code in browser
-doc display application documentation in browser
-help print the usage
pimpleFoam listTurbulenceModels
pimpleFoam -listTurbulenceModels
/*---------------------------------------------------------------------------*\
| ========= | |
| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
| \\ / O peration | Version: dev |
| \\ / A nd | Web: www.OpenFOAM.org |
| \\/ M anipulation | |
\*---------------------------------------------------------------------------*/
Build : dev-39c46019e44f
Exec : pimpleFoam -listTurbulenceModels
Date : Jun 10 2017
Time : 21:37:49
Host : "dm"
PID : 675
Case : /home/dm2/henry/OpenFOAM/OpenFOAM-dev
nProcs : 1
sigFpe : Enabling floating point exception trapping (FOAM_SIGFPE).
SetNaN : Initialising allocated memory to NaN (FOAM_SETNAN).
fileModificationChecking : Monitoring run-time modified files using timeStampMaster (fileModificationSkew 10)
allowSystemOperations : Allowing user-supplied system call operations
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
Turbulence models
3
(
LES
RAS
laminar
)
RAS models
18
(
LRR
LamBremhorstKE
LaunderSharmaKE
LienCubicKE
LienLeschziner
RNGkEpsilon
SSG
ShihQuadraticKE
SpalartAllmaras
kEpsilon
kOmega
kOmegaSST
kOmegaSSTLM
kOmegaSSTSAS
kkLOmega
qZeta
realizableKE
v2f
)
LES models
10
(
DeardorffDiffStress
Smagorinsky
SpalartAllmarasDDES
SpalartAllmarasDES
SpalartAllmarasIDDES
WALE
dynamicKEqn
dynamicLagrangian
kEqn
kOmegaSSTDES
)
Further work will be needed to support the -listTurbulenceModels option in
multiphase solvers.
discontinuous fields, with the discontinuity defined by a level set. The
functions do a proper integration of the discontinuous fields by tet-
and tri-cutting along the plane of the level set.
- provides a summary hash of classes used and their associated object names.
The HashTable representation allows us to leverage various HashTable
methods. This hashed summary view can be useful when querying
particular aspects, but is most useful when reducing the objects in
consideration to a particular subset. For example,
const wordHashSet interestingTypes
{
volScalarField::typeName,
volVectorField::typeName
};
IOobjectList objects(runTime, runTime.timeName());
HashTable<wordHashSet> classes = objects.classes();
classes.retain(interestingTypes);
// Or do just the opposite:
classes.erase(unsupportedTypes);
Can also use the underlying HashTable filter methods
STYLE: use templated internals to avoid findString() when matching subsets
- Generalized means over filtering table entries based on their keys,
values, or both. Either filter (retain), or optionally prune elements
that satisfy the specified predicate.
filterKeys and filterValues:
- Take a unary predicate with the signature
bool operator()(const Key& k);
- filterEntries:
Takes a binary predicate with the signature
bool operator()(const Key& k, const T& v);
==
The predicates can be normal class methods, or provide on-the-fly
using a C++ lambda. For example,
wordRes goodFields = ...;
allFieldNames.filterKeys
(
[&goodFields](const word& k){ return goodFields.match(k); }
);
Note that all classes that can match a string (eg, regExp, keyType,
wordRe, wordRes) or that are derived from a Foam::string (eg, fileName,
word) are provided with a corresponding
bool operator()(const std::string&)
that either performs a regular expression or a literal match.
This allows such objects to be used directly as a unary predicate
when filtering any string hash keys.
Note that HashSet and hashedWordList both have the proper
operator() methods that also allow them to be used as a unary
predicate.
- Similar predicate selection with the following:
* tocKeys, tocValues, tocEntries
* countKeys, countValues, countEntries
except that instead of pruning, there is a simple logic inversion.
- predicates::always and predicates::never returning true and false,
respectively. These simple classes make it easier when writing
templated code.
As well as unary and binary predicate forms, they also contain a
match(std::string) method for compatibility with regex-based classes.
STYLE: write bool and direction as primitive 'int' not as 'label'.
- ensure that the string-related classes have consistently similar
matching methods. Use operator()(const std::string) as an entry
point for the match() method, which makes it easier to use for
filters and predicates. In some cases this will also permit using
a HashSet as a match predicate.
regExp
====
- the set method now returns a bool to signal that the requested
pattern was compiled.
wordRe
====
- have separate constructors with the compilation option (was previously
a default parameter). This leaves the single parameter constructor
explicit, but the two parameter version is now non-explicit, which
makes it easier to use when building lists.
- renamed compile-option from REGEX (to REGEXP) for consistency with
with the <regex.h>, <regex> header names etc.
wordRes
====
- renamed from wordReListMatcher -> wordRes. For reduced typing and
since it behaves as an entity only slightly related to its underlying
list nature.
- Provide old name as typedef and include for code transition.
- pass through some list methods into wordRes
hashedWordList
====
- hashedWordList[const word& name] now returns a -1 if the name is is
not found in the list of indices. That has been a pending change
ever since hashedWordList was generalized out of speciesTable
(Oct-2010).
- add operator()(const word& name) for easy use as a predicate
STYLE: adjust parameter names in stringListOps
- reflect if the parameter is being used as a primary matcher, or the
matcher will be derived from the parameter.
For example,
(const char* re), which first creates a regExp
versus (const regExp& matcher) which is used directly.
- can run doxygen with an alternative Doxyfile, which is useful
when verifying generated content for particular classes.
Eg,
PATH/doc/Allwmake -dir $PWD
- this allows filling in the VTK structures without intermediate data
and without sequencial insertion. Should be faster and smaller
than the previous cell-wise insertion methods.
Most importantly, it improves code reuse.
- Previously matched name against the object->name() method
but saved with iter.key(). Now use iter.key() more consistently.
STYLE: consistent parameter names (doxygen)
- has the selected values directly and use these lookup names to store
directly into a hash. This replaces several parallel lists of
decomp information etc and makes it easier.
- std::initializer_list has its own size() method, so no need to use
std::distance.
STYLE/BUG: use separate iterator de-reference and increment in List
- avoids unnecessary copying of iterators, and avoids any potentially
odd behaviour with the combination with incrementing.
ENH: support construct from iterator pair for DynamicList, SortableList
- inherit from std::iterator to obtain the full STL typedefs, meaning
that std::distance works and the following is now possible:
labelRange range(100, 1500);
scalarList list(range.begin(), range.end());
--
Note that this does not work (mismatched data-types):
scalarList list = identity(12345);
But this does, since the *iter promotes label to scalar:
labelList ident = identity(12345);
scalarList list(ident.begin(), ident.end());
It is however more than slightly wasteful to create a labelList
just for initializing a scalarList. An alternative could be a
a labelRange for the same purpose.
labelRange ident = labelRange::identity(12345);
scalarList list(ident.begin(), ident.end());
Or this
scalarList list
(
labelRange::null.begin(),
labelRange::identity(12345).end()
);
- relocated to dedicated foamVtkOutput namespace. Make it easier to
obtain a formatter directly without a foamVtkOutput::outputOptions.
Make the logic clear within outputOptions (avoid previous, cryptic
bit masking). foamVtkOutput::legacy also becomes a namespace instead
of a class. Relocate commonly used things into src/fileFormats, leave
volField-related parts in src/conversion.
- provides const/non-const access to the underlying list, but the
iterator access itself is const.
- provide linked-list iterator 'found()' method for symmetry with
hash-table iterators. Use nullptr for more clarity.
- lookup(): with a default value (const access)
For example,
Map<label> something;
value = something.lookup(key, -1);
being equivalent to the following:
Map<label> something;
value = -1; // bad value
if (something.found(key))
{
value = something[key];
}
except that lookup also makes it convenient to handle const references.
Eg,
const labelList& ids = someHash.lookup(key, labelList());
- For consistency, provide a two parameter HashTable '()' operator.
The lookup() method is, however, normally preferable when
const-only access is to be ensured.
- retain(): the counterpart to erase(), it only retains entries
corresponding to the listed keys.
For example,
HashTable<someType> largeCache;
wordHashSet preserve = ...;
largeCache.retain(preserve);
being roughly equivalent to the following two-stage process,
but with reduced overhead and typing, and fewer potential mistakes.
HashTable<someType> largeCache;
wordHashSet preserve = ...;
{
wordHashSet cull(largeCache.toc()); // all keys
cull.erase(preserve); // except those to preserve
largeCache.erase(cull); //
}
The HashSet &= operator and retain() are functionally equivalent,
but retain() also works with dissimilar value types.
- less clutter and typing to use the default template parameter when
the key is 'word' anyhow.
- use EdgeMap instead of the longhand HashTable version where
appropriate
Evolves an electrical potential equation
\f[
\grad \left( \sigma \grad V \right)
\f]
where \f$ V \f$ is electrical potential and \f$\sigma\f$ is the
electrical current
To provide a Joule heating contribution according to:
Differential form of Joule heating - power per unit volume:
\f[
\frac{d(P)}{d(V)} = J \cdot E
\f]
where \f$ J \f$ is the current density and \f$ E \f$ the electric
field.
If no magnetic field is present:
\f[
J = \sigma E
\f]
The electric field given by
\f[
E = \grad V
\f]
Therefore:
\f[
\frac{d(P)}{d(V)} = J \cdot E
= (sigma E) \cdot E
= (sigma \grad V) \cdot \grad V
\f]
Usage
Isotropic (scalar) electrical conductivity
\verbatim
jouleHeatingSourceCoeffs
{
anisotropicElectricalConductivity no;
// Optionally specify the conductivity as a function of
// temperature
// Note: if not supplied, this will be read from the time
// directory
sigma table
(
(273 1e5)
(1000 1e5)
);
}
\endverbatim
Anisotropic (vectorial) electrical conductivity
jouleHeatingSourceCoeffs
{
anisotropicElectricalConductivity yes;
coordinateSystem
{
type cartesian;
origin (0 0 0);
coordinateRotation
{
type axesRotation;
e1 (1 0 0);
e3 (0 0 1);
}
}
// Optionally specify sigma as a function of temperature
//sigma (31900 63800 127600);
//
//sigma table
//(
// (0 (0 0 0))
// (1000 (127600 127600 127600))
//);
}
Where:
\table
Property | Description | Required | Default
value
T | Name of temperature field | no | T
sigma | Electrical conductivity as a function of
temperature |no|
anisotropicElectricalConductivity | Anisotropic flag | yes |
\endtable
The electrical conductivity can be specified using either:
- If the \c sigma entry is present the electrical conductivity is
specified
as a function of temperature using a Function1 type
- If not present the sigma field will be read from file
- If the anisotropicElectricalConductivity flag is set to 'true',
sigma
should be specified as a vector quantity
- the heuristic for matching unresolved intersections is a relatively
simple matching scheme that seems to be more robust than attempting to walk
the geometry or the cuts.
- avoid false positives for self intersection
- ensure that each have found() and which() methods
- add faceTraits for handling compile-time differences between
'normal' and tri-faces
- provide line::unitVec method (complimentary to edge::unitVec)
- provide key_iterator/const_key_iterator for all hashes,
reuse directly for HashSet as iterator/const_iterator, respectively.
- additional keys() method for HashTable that returns a wrapped to
a pair of begin/end const_iterators with additional size/empty
information that allows these to be used directly by anything else
expecting things with begin/end/size. Unfortunately does not yet
work with std::distance().
Example,
for (auto& k : labelHashTable.keys())
{
...
}
- add increment/decrement, repositioning. Simplify const_iterator.
- this makes is much easier to use labelRange for constructing ranges of
sub-lists. For symmetry with setSize() it has a setStart() instead of
simply assigning to start() directly. This would also provide the
future possibility to imbue the labelRange with a particular policy
(eg, no negative starts, max size etc) and ensure that they are
enforced.
A simple use case:
// initialize each to zero...
List<labelRange> subListRanges = ...;
// scan and categorize
if (condition)
subListRanges[categoryI]++; // increment size for that category
// finally, set the starting points
start = 0;
for (labelRange& range : subListRanges)
{
range.setStart(start);
start += range.size();
}
- previously had a mismash of const/non-const attributes on iterators
that were confused with the attributes of the object being accessed.
- use the iterator keys() and object() methods consistently for all
internal access of the HashTable iterators. This makes the intention
clearer, the code easier to maintain, and protects against any
possible changes in the definition of the operators.
- 'operator*': The standard form expected by STL libraries.
However, for the std::map, this dereferences to a <key,value> pair,
whereas OpenFOAM dereferences simply to <value>.
- 'operator()': OpenFOAM treats this like the 'operator*'
- adjusted the values of end() and cend() to reinterpret from nullObject
instead of returning a static iteratorEnd() object.
This means that C++ templates can now correctly deduce and match
the return types from begin() and end() consistently.
So that range-based now works.
Eg,
HashTable<label> table1 = ...;
for (auto i : table1)
{
Info<< i << endl;
}
Since the 'operator*' returns hash table values, this prints all the
values in the table.
This uses a concept similar to what std::valarray and std::slice do.
A labelRange provides a convenient container for holding start/size
and lends itself to addressing 'sliced' views of lists.
For safety, the operations and constructors restricts the given input range
to a valid addressible region of the underlying list, while the labelRange
itself precludes negative sizes.
The SubList version is useful for patches or other things that have a
SubList as its parameter. Otherwise the UList [] operator will be the
more natural solution. The slices can be done with a labelRange, or
a {start,size} pair.
Examples,
labelList list1 = identity(20);
list1[labelRange(18,10)] = -1;
list1[{-20,25}] = -2;
list1[{1000,5}] = -3;
const labelList list2 = identity(20);
list2[{5,10}] = -3; // ERROR: cannot assign to const!
Provides the additional compression necessary to ensure interface integrity
adjacent to a boundary at a low angle of incidence to the interface. This is
particularly important when simulating planing hulls.
Updated the tetrahedron and triangle classes to use the barycentric
primitives. Removed duplicate code for generating random positions in
tets and tris, and fixed bug in tri random position.
- optimize erasure using different HashTable based on its size.
Eg, hashtable.erase(other);
If 'other' is smaller than the hashtable, it is more efficient to
use the keys from other to remove from the hashtable.
Otherwise simply iterate over the hashtable and remove it if
that key was found in other.
- some functionality similar to what the standary library <iterator>
provides.
* stdFoam::begin() and stdFoam::end() do type deduction,
which means that many cases it is possible to manage these types
of changes.
For example, when managing a number of indices:
Map<labelHashSet> lookup;
1) Longhand:
for
(
Map<labelHashSet>::const_iterator iter = lookup.begin();
iter != lookup.end();
++iter
)
{ .... }
1b) The same, but wrapped via a macro:
forAllConstIter(Map<labelHashSet>, lookup, iter)
{ .... }
2) Using stdFoam begin/end templates directly
for
(
auto iter = stdFoam::begin(lookup);
iter != stdFoam::end(lookup);
++iter
)
{ .... }
2b) The same, but wrapped via a macro:
forAllConstIters(lookup, iter)
{ .... }
Note that in many cases it is possible to simply use a range-based for.
Eg,
labelList myList;
for (auto val : myList)
{ ... }
for (const auto& val : myList)
{ ... }
These however will not work with any of the OpenFOAM hash-tables,
since the standard C++ concept of an iterator would return a key,value
pair when deferencing the *iter.
The deduction methods also exhibits some slightly odd behaviour with
some PtrLists (needs some more investigation).
- make construct from UList explicit and provide corresponding
assignment operator.
- add construct,insert,set,assignment from FixedList.
This is convenient when dealing with things like edges or triFaces.
- explicitly mention the value-initialized status for the operator().
This means that the following code will properly use an initialized
zero.
HashTable<label> regionCount;
if (...)
regionCount("region1")++;
... and also this;
if (regionCount("something") > 0)
{
...
}
Note that the OpenFOAM HashTable uses operator[] to provide read and
write access to *existing* entries and will provoke a FatalError if
the entry does not exist.
The operator() provides write access to *existing* entries or will
create the new entry as required.
The STL hashes use operator[] for this purpose.
- more hash-like methods.
Eg, insert/erase via lists, clear(), empty(),...
- minVertex(), maxVertex() to return the smallest/largest label used
- improved documentation, more clarification about where/how negative
point labels are treated.
This tutorial demonstrates moving mesh and AMI with a Lagrangian cloud.
It is very slow, as interaction lists (required to compute collisions)
are not optimised for moving meshes. The simulation time has therefore
been made very short, so that it finishes in a reasonable time. The
mixer only completes a small fraction of a rotation in this time. This
is still sufficient to test tracking and collisions in the presence of
AMI and mesh motion.
In order to generate a convincing animation, however, the end time must
be increased and the simulation run for a number of days.
and the continuous-phase simulation type
For LTS and steady-state simulations the transient option does not need to be
provided as only steady-state tracking is appropriate. For transient running
the Lagrangian tracking may be steady or transient.
The evolution of a KinematicParcel happens in three stages; (1) tracking
across the cell, (2) interaction with the face or patch that has been
hit, and (3) clculation and and update of parcel and cell properties.
The KinematicParcel used to evolve in this order, as steps 1 and 2 were
part of the same lower level method. This meant that the update stage
was done after interacting with the face, meaning the parcel was not in
the cell that had just been tracked through, or, by means of a patch
interaction, had been modified such that it was no longer representative
of the track through the cell.
With the separation of stages 1 and 2 in the base class, it is now
possible to do the update stage before interacting with the face (i.e.,
proceeding in the order 1, 3, 2). This makes the state consistent for
the updates, and avoids the issues described.
Patch contributed by Timo Niemi, VTT.
This resolves bug report https://bugs.openfoam.org/view.php?id=2282
Particle collisions with ACMI patches are now handled. The hit detects
whether the location is within the overlap or the coupled region and
recurses, calling the hit routine appropriate for the region.
The low level tracking methods are now more consistently named. There is
now a distinction between tracking to a face and hitting it. Function
object side effects have been moved out of the base layer and into the
parcels on which they are meaningful.
The TrackData::switchProcessor flag was not being set for some of the
tracking steps made by the more complicated parcels. In the case that a
parcel starts the step already on a processor boundary, this sometimes
lead to the particle being transferred back and forth indefinitely. The
flag is now explicitly set in all cases.
Tracking through an inverted region of the mesh happens in a reversed
direction relative to a non-inverted region. Usually, this allows the
tracking to propagate normally, regardless of the sign of the space.
However, in rare cases, it is possible for a straight trajectory to form
a closed loop through both positive and negative regions. This causes
the tracking to loop indefinitely.
To fix this, the displacement through inverted regions has been
artifically increased by a small amount (1% at the moment). This has the
effect that the change in track fraction over the negative part of the
loop no longer exactly cancels the change over the positive part, and
the track therefore terminates.
The KinematicCloud::patchData method has been made consistent on moving
meshes and/or when the time-step is being sub-cycled.
It has also been altered to calculate the normal component of a moving
patch's velocity directly from the point motions. This prevents an
infinite loop occuring due to inconsistency between the velocity used to
calculate a rebound and that used when tracking.
Some minor style improvements to the particle class have also been made.
The particle collector was collecting some particles twice due to a
tolerance extending the tracked path. This has been removed. The new
tracking algorithm does not generate the same sorts of spurious
tolerance-scale motions that the old one did, so this extension of the
tracking path is unnecessary.
Some particles were also not being collected at all as they were hitting
a diagonal of the collection polygon and registering as not having hit
either of the adjacent triangles. The hit criteria has been rewritten. A
hit now occurs when the normals of the triangles created by joining the
intersection point with the polygon edges are all in the same direction
as the overall polygon normal. This calculation is not affected by the
polygon's diagonals.
The issue was raised by, and resolved with support from, Karl Meredith
at FM Global.
This resolves bug-report https://bugs.openfoam.org/view.php?id=2595
This change changes the point-tetIndices-face interpolation function
method to take barycentric-tetIndices-face arguments instead. This
function is, at present, only used for interpolating Eulerian data to
Lagrangian particles.
This change prevents an inefficiency in cellPointInterpolation whereby
the position of the particle is calculated from it's barycentric
coordinates, before immediately being converted back to barycentric
coordinates to perform the interpolation.
The averaging methods now take the particle barycentric coordinates as
inputs rather than global positions. This change significantly optimises
Dual averaging, which is the most commonly used method. The run time of
the lagrangian/MPPICFoam/Goldschmidt tutorial has been reduced by a
factor of about two.
now possible with level-sets as well as planes. Removed tetPoints class
as this wasn't really used anywhere except for the old tet-cutting
routines. Restored tetPointRef.H to be consistent with other primitive
shapes. Re-wrote tet-overlap mapping in terms of the new cutting.
terms of the local barycentric coordinates of the current tetrahedron,
rather than the global coordinate system.
Barycentric tracking works on any mesh, irrespective of mesh quality.
Particles do not get "lost", and tracking does not require ad-hoc
"corrections" or "rescues" to function robustly, because the calculation
of particle-face intersections is unambiguous and reproducible, even at
small angles of incidence.
Each particle position is defined by topology (i.e. the decomposed tet
cell it is in) and geometry (i.e. where it is in the cell). No search
operations are needed on restart or reconstruct, unlike when particle
positions are stored in the global coordinate system.
The particle positions file now contains particles' local coordinates
and topology, rather than the global coordinates and cell. This change
to the output format is not backwards compatible. Existing cases with
Lagrangian data will not restart, but they will still run from time
zero without any modification. This change was necessary in order to
guarantee that the loaded particle is valid, and therefore
fundamentally prevent "loss" and "search-failure" type bugs (e.g.,
2517, 2442, 2286, 1836, 1461, 1341, 1097).
The tracking functions have also been converted to function in terms
of displacement, rather than end position. This helps remove floating
point error issues, particularly towards the end of a tracking step.
Wall bounded streamlines have been removed. The implementation proved
incompatible with the new tracking algorithm. ParaView has a surface
LIC plugin which provides equivalent, or better, functionality.
Additionally, bug report <https://bugs.openfoam.org/view.php?id=2517>
is resolved by this change.
- adjust for updates in 'develop'
- change surfaceIntersection constructor to take a dictionary of
options.
tolerance | Edge-length tolerance | scalar | 1e-3
allowEdgeHits | Edge-end cuts another edge | bool | true
avoidDuplicates | Reduce the number of duplicate points | bool | true
warnDegenerate | Number of warnings about degenerate edges | label | 0
- cannot use comparison of list sizes. Okay for UList, but not here.
STYLE:
- don't need two iterators for the '<' comparison, can just access
internal storage directly
By specifying the optional outside surface emissivity radiative heat transfer to
the ambient conditions is enabled. The far-field is assumed to have an
emissivity of 1 but this could be made an optional input in the future if
needed.
Relaxation of the surface temperature is now provided via the optional
"relaxation" which aids stability of steady-state runs with strong radiative
coupling to the boundary.
- The existing ':' anchor works for rvalue substitutions
(Eg, ${:subdict.name}), but fails for lvalues, since it is
a punctuation token and parse stops there.
- support edge-ordering on construction, and additional methods:
- sort(), sorted(), unitVec(), collapse()
- null constructor initializes with -1, for consistency with face,
triFace and since it is generally much more useful that way.
- add some methods that allow edges to used somewhat more like hashes.
- count(), found(), insert(), erase()
Here is possible way to use that:
edge someEdge; // initializes with '-1' for both entries
if (someEdge.insert(pt1))
{
// added a new point label
}
... later
// unmark point on edge
someEdge.erase(pt2);
--
STYLE:
- use UList<point> instead of pointField for edge methods for flexibility.
The pointField include is retained, however, since many other routines
may be relying on it being included via edge.H
- suppress error messages that appear with zsh.
According to unset(1p), 'unset -f' unsets a function.
If the function was not previously defined, this is a no-op.
This is similar for zsh, but there it emits a warning if the
function was not previously defined.
- avoid 'local' in functions sources from etc/bashrc.
ksh does not support this.
- use 'command' shell builtin instead of 'type'.
Seems to be more consistent between shell flavours.
except turbulence and lagrangian which will also be updated shortly.
For example in the nonNewtonianIcoFoam offsetCylinder tutorial the viscosity
model coefficients may be specified in the corresponding "<type>Coeffs"
sub-dictionary:
transportModel CrossPowerLaw;
CrossPowerLawCoeffs
{
nu0 [0 2 -1 0 0 0 0] 0.01;
nuInf [0 2 -1 0 0 0 0] 10;
m [0 0 1 0 0 0 0] 0.4;
n [0 0 0 0 0 0 0] 3;
}
BirdCarreauCoeffs
{
nu0 [0 2 -1 0 0 0 0] 1e-06;
nuInf [0 2 -1 0 0 0 0] 1e-06;
k [0 0 1 0 0 0 0] 0;
n [0 0 0 0 0 0 0] 1;
}
which allows a quick change between models, or using the simpler
transportModel CrossPowerLaw;
nu0 [0 2 -1 0 0 0 0] 0.01;
nuInf [0 2 -1 0 0 0 0] 10;
m [0 0 1 0 0 0 0] 0.4;
n [0 0 0 0 0 0 0] 3;
if quick switching between models is not required.
To support this more convenient parameter specification the inconsistent
specification of seedSampleSet in the streamLine and wallBoundedStreamLine
functionObjects had to be corrected from
// Seeding method.
seedSampleSet uniform; //cloud; //triSurfaceMeshPointSet;
uniformCoeffs
{
type uniform;
axis x; //distance;
// Note: tracks slightly offset so as not to be on a face
start (-1.001 -0.05 0.0011);
end (-1.001 -0.05 1.0011);
nPoints 20;
}
to the simpler
// Seeding method.
seedSampleSet
{
type uniform;
axis x; //distance;
// Note: tracks slightly offset so as not to be on a face
start (-1.001 -0.05 0.0011);
end (-1.001 -0.05 1.0011);
nPoints 20;
}
which also support the "<type>Coeffs" form
// Seeding method.
seedSampleSet
{
type uniform;
uniformCoeffs
{
axis x; //distance;
// Note: tracks slightly offset so as not to be on a face
start (-1.001 -0.05 0.0011);
end (-1.001 -0.05 1.0011);
nPoints 20;
}
}
- if called from the top-level project directory ($WM_PROJECT_DIR)
default to using {applications,src} directories. This avoids
erroneous linking of etc/codeTemplates and avoids the lengthy
scanning of the tutorials directory
- use InfoSwitch to disable, or via static method.
- respect the state of the argList banner when deciding to emit
initialization information. Can otherwise end up with unwanted
output rubbish on things like foamDictionary and foamListTimes.
The typical topology is the one where boundary faces share non-consecutive
points (checkMesh reports this as 'Number of faces with non-consecutive shared points')
This is handled by no-extruding any of the vertices of both faces. Fixes#391.
Radiative heat transfer may now be added to any solver in which an energy
equation is solved at run-time rather than having to change the solver code.
For example, radiative heat transfer is now enabled in the SandiaD_LTS
reactingFoam tutorial by providing a constant/fvOptions file containing
radiation
{
type radiation;
libs ("libradiationModels.so");
}
and appropriate settings in the constant/radiationProperties file.
For example the porosity coefficients may now be specified thus:
porosity1
{
type DarcyForchheimer;
cellZone porosity;
d (5e7 -1000 -1000);
f (0 0 0);
coordinateSystem
{
type cartesian;
origin (0 0 0);
coordinateRotation
{
type axesRotation;
e1 (0.70710678 0.70710678 0);
e2 (0 0 1);
}
}
}
rather than
porosity1
{
type DarcyForchheimer;
active yes;
cellZone porosity;
DarcyForchheimerCoeffs
{
d (5e7 -1000 -1000);
f (0 0 0);
coordinateSystem
{
type cartesian;
origin (0 0 0);
coordinateRotation
{
type axesRotation;
e1 (0.70710678 0.70710678 0);
e2 (0 0 1);
}
}
}
}
support for which is maintained for backward compatibility.
For example the actuationDiskSource fvOption may now be specified
disk1
{
type actuationDiskSource;
fields (U);
selectionMode cellSet;
cellSet actuationDisk1;
diskDir (1 0 0); // Orientation of the disk
Cp 0.386;
Ct 0.58;
diskArea 40;
upstreamPoint (581849 4785810 1065);
}
rather than
disk1
{
type actuationDiskSource;
active on;
actuationDiskSourceCoeffs
{
fields (U);
selectionMode cellSet;
cellSet actuationDisk1;
diskDir (1 0 0); // Orientation of the disk
Cp 0.386;
Ct 0.58;
diskArea 40;
upstreamPoint (581849 4785810 1065);
}
}
but this form is supported for backward compatibility.
Main changes in the tutorial:
- General cleanup of the phaseProperties of unnecessary entries
- sensibleEnthalpy is used for both phases
- setTimeStep functionObject is used to set a sharp reduction in time step near the start of the injection
- Monitoring of pressure minimum and maximum
Patch contributed by Juho Peltola, VTT.
- If the dictionary is named 'surfaces', a 'surfaces' entry is mandatory.
This is a list of wordRe, which is used to load multiple surfaces from
constant/triSurface directory.
- Other dictionaries may contain a 'surfaces' entry.
In which case the behaviour is as above (loading multiple surfaces).
The dictionary name will *NOT* be taken as a surface name itself.
- Regardless of how the surfaces are loaded or features extracted,
an additional selfIntersection test may be used.
Eg,
surfaces
{
extractionMethod extractFromSurface;
surfaces (surface1.stl surface2.nas);
// Generate features from self-intersect
selfIntersection true;
// Base output name (optiona)
output surfaces;
// Tolerance for self-intersect
planarTolerance 1e-3;
extractFromSurfaceCoeffs
{
includedAngle 120;
// Do not mark region edges
geometricTestOnly yes;
}
}
- This can be used as a convenient alternative to comparing against end().
Eg,
dictionaryConstructorTable::iterator cstrIter =
dictionaryConstructorTablePtr_->find(methodType);
if (cstrIter.found())
{
...
}
vs.
if (cstrIter != dictionaryConstructorTablePtr_->end())
{
...
}
- 1st problem arises when there are edges, but edgeNormals is empty.
The UIndirectList fails (zero elements, non-zero addressing)
- further problem occurs if there is a mismatch in the number of edges
and edges normals (incorrect indexing on loop).
The standard naming convention for heat flux is "q" and this is used for the
conductive and convective heat fluxes is OpenFOAM. The use of "Qr" for
radiative heat flux is an anomaly which causes confusion, particularly for
boundary conditions in which "Q" is used to denote power in Watts. The name of
the radiative heat flux has now been corrected to "qr" and all models, boundary
conditions and tutorials updated.
by combining with and rationalizing functionality from
turbulentHeatFluxTemperatureFvPatchScalarField.
externalWallHeatFluxTemperatureFvPatchScalarField now replaces
turbulentHeatFluxTemperatureFvPatchScalarField which is no longer needed and has
been removed.
Description
This boundary condition applies a heat flux condition to temperature
on an external wall in one of three modes:
- fixed power: supply Q
- fixed heat flux: supply q
- fixed heat transfer coefficient: supply h and Ta
where:
\vartable
Q | Power [W]
q | Heat flux [W/m^2]
h | Heat transfer coefficient [W/m^2/K]
Ta | Ambient temperature [K]
\endvartable
For heat transfer coefficient mode optional thin thermal layer resistances
can be specified through thicknessLayers and kappaLayers entries.
The thermal conductivity \c kappa can either be retrieved from various
possible sources, as detailed in the class temperatureCoupledBase.
Usage
\table
Property | Description | Required | Default value
mode | 'power', 'flux' or 'coefficient' | yes |
Q | Power [W] | for mode 'power' |
q | Heat flux [W/m^2] | for mode 'flux' |
h | Heat transfer coefficient [W/m^2/K] | for mode 'coefficent' |
Ta | Ambient temperature [K] | for mode 'coefficient' |
thicknessLayers | Layer thicknesses [m] | no |
kappaLayers | Layer thermal conductivities [W/m/K] | no |
qr | Name of the radiative field | no | none
qrRelaxation | Relaxation factor for radiative field | no | 1
kappaMethod | Inherited from temperatureCoupledBase | inherited |
kappa | Inherited from temperatureCoupledBase | inherited |
\endtable
Example of the boundary condition specification:
\verbatim
<patchName>
{
type externalWallHeatFluxTemperature;
mode coefficient;
Ta uniform 300.0;
h uniform 10.0;
thicknessLayers (0.1 0.2 0.3 0.4);
kappaLayers (1 2 3 4);
kappaMethod fluidThermo;
value $internalField;
}
\endverbatim
- can be useful with compiling additional OpenFOAM programs
that use FOAM_USER_APPBIN, FOAM_USER_LIBBIN for their build,
to avoid conflicts with the normal user bin/lib files.
- or to force relocation of FOAM_SITE_APPBIN, FOAM_SITE_LIBBIN
during packaging of OpenFOAM
Description
Temperature-dependent surface tension model in which the surface tension
function provided by the phase Foam::liquidProperties class is used.
Usage
\table
Property | Description | Required | Default value
phase | Phase name | yes |
\endtable
Example of the surface tension specification:
\verbatim
sigma
{
type liquidProperties;
phase water;
}
\endverbatim
for use with e.g. compressibleInterFoam, see
tutorials/multiphase/compressibleInterFoam/laminar/depthCharge2D
- just check WM_PROJECT_DIR instead.
- provide a fallback value when FOAM_EXT_LIBBIN might actually be needed.
Only strictly need FOAM_EXT_LIBBIN for scotch/metis decomposition, and
when these are actually supplied by ThirdParty.
All other ThirdParty dependencies are referenced by BOOST_ARCH_PATH etc.
Can therefore drop the FOAM_EXT_LIBBIN dependency for VTK-related
things, which do not use scotch/metis anyhow.
snappyHexMesh produces a far better quality AMI interface using a cylindrical background mesh,
leading to much more robust performance, even on a relatively coarse mesh. The min/max AMI
weights remain close to 1 as the mesh moves, giving better conservation.
The rotating geometry template cases are configured with a blockMeshDict file for a cylindrical
background mesh aligned along the z-axis. The details of use are found in the README and
blockMeshDict files.
Uncommenting the patches provides a convenient way to use the patches in the background mesh
to define the external boundary of the final mesh. Replaces previous setup with a separate
blockMeshDict.extPatches file.
- this implies that jobControl is a user-resource for OpenFOAM.
It was previously located under $WM_PROJECT_INST_DIR/jobControl,
but few users will have write access there.
- an unset FOAM_JOB_DIR variable is treated as "~/.OpenFOAM/jobControl",
which can partially reduce environment clutter.
- provide argList::noJobInfo() to conveniently suppress job-info on an
individual basis for short-running utilities (eg, foamListTimes) to
avoid unneeded clutter.
These models have been particularly designed for use in the VoF solvers, both
incompressible and compressible. Currently constant and temperature dependent
surface tension models are provided but it easy to write models in which the
surface tension is evaluated from any fields held by the mesh database.
- ensure proper and sensible handling of empty names.
Eg, isDir(""), isFile("") are no-ops, and avoid file-stat
- rmDir:
* optional 'silent' option to suppress messages.
* removes all possible sub-entries, instead of just giving up on
the first problem encountered.
- reduced code duplication in etcFiles
ENH: provide WM_USER_RESOURCE_DIRNAME define (in foamVersion.H)
- this is still a hard-coded value, but at least centrally available
- permit SYSTEMMPI user adjustments via
etc/config.{csh,sh}/mpi-system
This can be a convenient place for setting up SYSTEMMPI for OpenFOAM
without adjusting bashrc, prefs.sh ...
- add a USERMPI type. This represents any generic mpi implementation.
The user is responsible for supplying an appropriate
wmake/rules/General/mplibUSERMPI file and managing all settings.
This type of setup can be useful in combination with specific build
systems (SPACK, EASYBUILD, etc) or module systems for which the MPI
variant is part of the installed configuration.
Created a base-class from contactAngleForce from which the
distributionContactAngleForce (for backward compatibility) and the new
temperatureDependentContactAngleForce are derived:
Description
Temperature dependent contact angle force
The contact angle in degrees is specified as a \c Function1 type, to
enable the use of, e.g. contant, polynomial, table values.
See also
Foam::regionModels::surfaceFilmModels::contactAngleForce
Foam::Function1Types
SourceFiles
temperatureDependentContactAngleForce.C
Demonstrates meshing a cylinder with hemispehrical ends using snappyHexMesh with
a polar background mesh that uses the point and edge projection feature of blockMesh.
The case prescribes a multiMotion on the cylinder, combining an oscillatingLinearMotion
and transverse rotatingMotion.
- lazier evaluation of project name and version based on the directory
name. Avoids heuristics based on directory names unless really needed.
- cope with alternative directory locations.
For example, OpenFOAM+VERSION etc.
The combination of the two above appears to be sufficient to open up
the directory naming possibilities.
- additional -list-test option (tests for existence of directory).
Off-centering is specified via the mandatory coefficient \c ocCoeff in the
range [0,1] following the scheme name e.g.
\verbatim
ddtSchemes
{
default CrankNicolson 0.9;
}
\endverbatim
or with an optional "ramp" function to transition from the Euler scheme to
Crank-Nicolson over a initial period to avoid start-up problems, e.g.
\verbatim
ddtSchemes
{
default CrankNicolson
ocCoeff
{
type scale;
scale linearRamp;
duration 0.01;
value 0.9;
};
}
\endverbatim
Note this functionality is experimental and the specification and implementation
may change if issues arise.
For example in the potentialFreeSurfaceFoam/oscillatingBox tutorial it is
cleaner to apply the "linearRamp" function to the "sine" function rather than
using an amplitude table:
floatingObject
{
type fixedNormalInletOutletVelocity;
fixTangentialInflow false;
normalVelocity
{
type uniformFixedValue;
uniformValue
{
type scale;
value
{
type sine;
frequency 1;
amplitude 0.025;
scale (0 1 0);
level (0 0 0);
}
scale
{
type linearRamp;
duration 10;
}
}
}
value uniform (0 0 0);
}
coupled patches, to prevent rebound/stick/etc... on these patches. Also
added "none" interaction type to LocalInteraction, which reverts the
patch interaction to the fundamental behaviour. This is primarily useful
for non-coupled constraint types.
Resolves https://bugs.openfoam.org/view.php?id=2458
The pitzDaily case uses a lot of mesh grading close to walls and the shear layer.
Prior to v2.4, blockMesh only permitted grading in one direction within a single block,
so the pitzDaily mesh comprised of 13 blocks to accommodate the complex grading pattern.
blockMesh has multi-grading that allows users to divide a block in a given direction and
apply different grading within each division. The mesh generated with blockMesh using
13 blocks has been replaced with a mesh of 5 blocks that use multi-grading. The new
blockMeshDict configuration produces a mesh very similar to the original 13-block mesh.
including support for TDAC and ISAT for efficient chemistry calculation.
Description
Eddy Dissipation Concept (EDC) turbulent combustion model.
This model considers that the reaction occurs in the regions of the flow
where the dissipation of turbulence kinetic energy takes place (fine
structures). The mass fraction of the fine structures and the mean residence
time are provided by an energy cascade model.
There are many versions and developments of the EDC model, 4 of which are
currently supported in this implementation: v1981, v1996, v2005 and
v2016. The model variant is selected using the optional \c version entry in
the \c EDCCoeffs dictionary, \eg
\verbatim
EDCCoeffs
{
version v2016;
}
\endverbatim
The default version is \c v2015 if the \c version entry is not specified.
Model versions and references:
\verbatim
Version v2005:
Cgamma = 2.1377
Ctau = 0.4083
kappa = gammaL^exp1 / (1 - gammaL^exp2),
where exp1 = 2, and exp2 = 2.
Magnussen, B. F. (2005, June).
The Eddy Dissipation Concept -
A Bridge Between Science and Technology.
In ECCOMAS thematic conference on computational combustion
(pp. 21-24).
Version v1981:
Changes coefficients exp1 = 3 and exp2 = 3
Magnussen, B. (1981, January).
On the structure of turbulence and a generalized
eddy dissipation concept for chemical reaction in turbulent flow.
In 19th Aerospace Sciences Meeting (p. 42).
Version v1996:
Changes coefficients exp1 = 2 and exp2 = 3
Gran, I. R., & Magnussen, B. F. (1996).
A numerical study of a bluff-body stabilized diffusion flame.
Part 2. Influence of combustion modeling and finite-rate chemistry.
Combustion Science and Technology, 119(1-6), 191-217.
Version v2016:
Use local constants computed from the turbulent Da and Re numbers.
Parente, A., Malik, M. R., Contino, F., Cuoci, A., & Dally, B. B.
(2016).
Extension of the Eddy Dissipation Concept for
turbulence/chemistry interactions to MILD combustion.
Fuel, 163, 98-111.
\endverbatim
Tutorials cases provided: reactingFoam/RAS/DLR_A_LTS, reactingFoam/RAS/SandiaD_LTS.
This codes was developed and contributed by
Zhiyi Li
Alessandro Parente
Francesco Contino
from BURN Research Group
and updated and tested for release by
Henry G. Weller
CFD Direct Ltd.
to provide smoother behavior on start-up when an acceleration impulse is
applied, e.g. if the body is suddenly released. e.g.
dynamicFvMesh dynamicMotionSolverFvMesh;
motionSolverLibs ("librigidBodyMeshMotion.so");
solver rigidBodyMotion;
rigidBodyMotionCoeffs
{
report on;
solver
{
type Newmark;
}
ramp
{
type quadratic;
start 0;
duration 10;
}
.
.
.
will quadratically ramp the forces from 0 to their full values over the first
10s of the run starting from 0. If the 'ramp' entry is omitted no force ramping
is applied.
Description
Ramp function base class for the set of scalar functions starting from 0 and
increasing monotonically to 1 from \c start over the \c duration and
remaining at 1 thereafter.
Usage:
\verbatim
<entryName> <rampFunction>;
<entryName>Coeffs
{
start 10;
duration 20;
}
\endverbatim
or
\verbatim
<entryName>
{
type <rampFunction>;
start 10;
duration 20;
}
\endverbatim
Where:
\table
Property | Description | Required | Default value
start | Start time | no | 0
duration | Duration | yes |
\endtable
The following common ramp functions are provided: linear, quadratic, halfCosine,
quarterCosine and quaterSine, others can easily be added and registered to the run-time
selection system.
e.g.
ramp
{
type quadratic;
start 200;
duration 1.6;
}
but the old format is supported for backward compatibility:
ramp linear;
rampCoeffs
{
start 200;
duration 1.6;
}
Formally this is equivalent to the previous formulation but more convenient to
use given that for compressible flow the mass flux rather than the volume flux
is available.
These legacy boundary conditions are no longer needed and have been superseded
by the more flexible sixDoFRigidBodyMotion and rigidBodyMotion solvers. See tutorials:
incompressible/pimpleDyMFoam/wingMotion/wingMotion2D_pimpleDyMFoam
multiphase/interDyMFoam/RAS/DTCHull
multiphase/interDyMFoam/RAS/floatingObject
Resolves bug-report https://bugs.openfoam.org/view.php?id=2487
Using
decomposePar -copyZero
The mesh is decomposed as usual but the '0' directory is recursively copied to
the 'processor.*' directories rather than decomposing the fields. This is a
convenient option to handle cases where the initial field files are generic and
can be used for serial or parallel running. See for example the
incompressible/simpleFoam/motorBike tutorial case.
- this makes it possible to perform additional operations
on surface values that have been previously sampled.
- support vectorField for weighting operations.
- reduce overhead by avoiding creation of weight fields, Sf fields
and combined surface geometries unless they are actually required.
- extend some similar concepts and operations to volFieldValue
Both stardard SIMPLE and the SIMPLEC (using the 'consistent' option in
fvSolution) are now supported for both subsonic and transonic flow of all
fluid types.
rhoPimpleFoam now instantiates the lower-level fluidThermo which instantiates
either a psiThermo or rhoThermo according to the 'type' specification in
thermophysicalProperties, see also commit a1c8cde310
Both stardard SIMPLE and the SIMPLEC (using the 'consistent' option in
fvSolution) are now supported for both subsonic and transonic flow of all
fluid types.
- handle sourcing bashrc with a relative path (issue #383)
- handle sourcing from bash and zsh.
Still need manual intervention when sourcing dash, sh, or ksh.
- replace grep in etc/cshrc with sed only
- logical instead of physical path for WM_PROJECT_DIR (issue #431).
Doesn't seem to be possible for csh/tcsh.
* Continue using physical locations when comparing directories,
but not for the top-level FOAM_INST_DIR, WM_PROJECT_DIR.
- relocate WM_CC, WM_CXX overrides from etc/config.*/compiler
to etc/config.*/settings to ensure that they are left untouched
when etc/config.sh/compiler is sourced while making third-party
packages (eg, gcc, llvm, CGAL).
- provide fallback FOAM_TUTORIALS setting in RunFunctions
STYLE: remove "~OpenFOAM" fallback as being too rare, non-obvious
Both point- and surfaceNoise utilities can operate on multiple input
files. However, if the files had the same name, the output would be
overwritten. To avoid this, the output files are now written to a
sub-directory including the path '/input<input-file-index>/', e.g.
postProcessing/noise/surfaceNoise/input0/nearWall/[fft|oneThirdOctave]
An optional 'outputPrefix' can be included (defaults to empty), e.g.
when set to 'test1':
postProcessing/noise/test1/surfaceNoise/input0/nearWall/[fft|oneThirdOctave]
- the purpose is more explicit, without needing to check documentation
about what the bool parameter means.
STYLE: improve formatting of fileName documentation
- Limit output to frequency range given by fLower and fUpper (if supplied)
- Enable noise models to be run outside of $FOAM_CASE directory
- if relative paths are used, $FOAM_CASE is prepended to the noise
dict and input file names
- Enable output to be customised, e.g.
// Optional write options dictionary (all default to 'yes')
writeOptions
{
writePrmsf no;
writeSPL yes;
writePSD yes;
writePSDf no;
writeOctaves yes;
}
- was previously only within string expansions, but cover dictionaries
as well for consistency
ENH: replace the never-used fileName::caseName() functionality
- stringOps::inplaceReplaceVar() is more general
stringOps::inplaceReplaceVar(myfile, "FOAM_CASE");
STYLE: relax parameter passing when calling some POSIX 'query' functions.
- A std::string is sufficient since the functions use a plain C-string.
Eg, getEnv("SOMETHING").
Retain more stringent Foam::word for things like setEnv, since this
could be useful.
- caused by the typo '@E' instead of '$E' (commit 997f1713cb)
ENH: minor improvements for wmake/src makefile
- 'make clean' now also tries to remove the parent platforms/
directory if possible.
- the flex intermediate build target is placed into the platforms/
directory to avoid touching the src/ directory at all.
- suppress warnings about unused functions (GCC only)
- these are suitable for use with lambda functions.
- Deprecate the unused 3-parameter version of subset/inplaceSubset.
- Deprecate initList and initListList in favour of initializer_list
STYLE: adjust some comments, remove dead code in regionSizeDistribution.C
- new behaviour is to do nothing if no platform was specified.
This helps avoid inadvertently removing files.
- support special platforms for compatibility with wmake/wclean targets.
Eg, "wcleanPlatform all"
- allow use from ThirdParty top-level as well, since the directory
structure is similar.
BUG: fix regression in wcleanLnIncludeAll introduced by 9e2e111518
rhoSimpleFoam now instantiates the lower-level fluidThermo which instantiates
either a psiThermo or rhoThermo according to the 'type' specification in
thermophysicalProperties, e.g.
thermoType
{
type hePsiThermo;
mixture pureMixture;
transport sutherland;
thermo janaf;
equationOfState perfectGas;
specie specie;
energy sensibleInternalEnergy;
}
instantiates a psiThermo for a perfect gas with JANAF thermodynamics, whereas
thermoType
{
type heRhoThermo;
mixture pureMixture;
properties liquid;
energy sensibleInternalEnergy;
}
mixture
{
H2O;
}
instantiates a rhoThermo for water, see new tutorial
compressible/rhoSimpleFoam/squareBendLiq.
In order to support complex equations of state the pressure can no longer be
unlimited and rhoSimpleFoam now limits the pressure rather than the density to
handle start-up more robustly.
For backward compatibility 'rhoMin' and 'rhoMax' can still be used in the SIMPLE
sub-dictionary of fvSolution which are converted into 'pMax' and 'pMin' but it
is better to set either 'pMax' and 'pMin' directly or use the more convenient
'pMinFactor' and 'pMinFactor' from which 'pMax' and 'pMin' are calculated using
the fixed boundary pressure or reference pressure e.g.
SIMPLE
{
nNonOrthogonalCorrectors 0;
pMinFactor 0.1;
pMaxFactor 1.5;
transonic yes;
consistent yes;
residualControl
{
p 1e-3;
U 1e-4;
e 1e-3;
"(k|epsilon|omega)" 1e-3;
}
}
Can now use this:
_foamSourceEtc config.sh/scotch
_foamSourceEtc config.csh/scotch
instead of this:
_foamSource $($WM_PROJECT_DIR/bin/foamEtcFile config.sh/scotch)
_foamSource `$WM_PROJECT_DIR/bin/foamEtcFile config.csh/scotch`
In the bash/sh version, leave the _foamSource function for now, since
ThirdParty is still relying on it.
STYLE: elminate while-loop for _foamAddPath etc since this type of
construct isn't readily possible for csh and isn't being used anywhere.
- Eg, instead
if file=$(foamEtcFile filename)
then
. $file
fi
can write
eval "$(foamEtcFile -sh filename)"
Also supports -verbose reporting, which is especially useful for csh,
since it allows simplification of aliases and allows the message to
land on stderr instead of stdout.
eval `foamEtcFile -csh -verbose filename`
- as per bashrc,cshrc delimit with
"# USER EDITABLE PART"
"# END OF (NORMAL) USER EDITABLE PART"
this can help simplify any patching for system-building scripts etc.
For certain combinations of rays and triangles the fast bb-triangle intersection
routine is not correct. For now revert to slow edge-by-edge intersection.
This allows single, multi-phase and VoF compressible simulations to be performed
with the accurate thermophysical property functions for liquids provided by the
liquidProperty classes. e.g. in the
multiphase/compressibleInterFoam/laminar/depthCharge2D tutorial water can now be
specified by
thermoType
{
type heRhoThermo;
mixture pureMixture;
properties liquid;
energy sensibleInternalEnergy;
}
mixture
{
H2O;
}
as an alternative to the previous less accurate representation defined by
thermoType
{
type heRhoThermo;
mixture pureMixture;
transport const;
thermo hConst;
equationOfState perfectFluid;
specie specie;
energy sensibleInternalEnergy;
}
mixture
{
specie
{
molWeight 18.0;
}
equationOfState
{
R 3000;
rho0 1027;
}
thermodynamics
{
Cp 4195;
Hf 0;
}
transport
{
mu 3.645e-4;
Pr 2.289;
}
}
However the increase in accuracy of the new simpler and more convenient
specification and representation comes at a cost: the NSRDS functions used by
the liquidProperties classes are relatively expensive to evaluate and the
depthCharge2D case takes ~14% longer to run.
Description
Base-class for thermophysical properties of solids, liquids and gases
providing an interface compatible with the templated thermodynamics
packages.
liquidProperties, solidProperties and thermophysicalFunction libraries have been
combined with the new thermophysicalProperties class into a single
thermophysicalProperties library to simplify compilation and linkage of models,
libraries and applications dependent on these classes.
The entries for liquid and solid species can now be simply be the name unless
property coefficients are overridden in which are specified in a dictionary as
before e.g. in the tutorials/lagrangian/coalChemistryFoam/simplifiedSiwek case
the water is simply specified
liquids
{
H2O;
}
and solid ash uses standard coefficients but the coefficients for carbon are
overridden thus
solids
{
C
{
rho 2010;
Cp 710;
kappa 0.04;
Hf 0;
emissivity 1.0;
}
ash;
}
The defaultCoeffs entry is now redundant and supported only for backward
compatibility. To specify a liquid with default coefficients simply leave the
coefficients dictionary empty:
liquids
{
H2O {}
}
Any or all of the coefficients may be overridden by specifying the properties in
the coefficients dictionary, e.g.
liquids
{
H2O
{
rho
{
a 1000;
b 0;
c 0;
d 0;
}
}
}
When liquids are constructed from dictionary the coefficients are now first
initialized to their standard values and overridden by the now optional entries
provided in the dictionary. For example to specify water with all the standard
temperature varying properties but override only the density with a constant
value of 1000 specify in thermophysicalProperties
liquids
{
H2O
{
defaultCoeffs no;
H2OCoeffs
{
rho
{
a 1000;
b 0;
c 0;
d 0;
}
}
}
}
The fundamental properties provided by the specie class hierarchy were
mole-based, i.e. provide the properties per mole whereas the fundamental
properties provided by the liquidProperties and solidProperties classes are
mass-based, i.e. per unit mass. This inconsistency made it impossible to
instantiate the thermodynamics packages (rhoThermo, psiThermo) used by the FV
transport solvers on liquidProperties. In order to combine VoF with film and/or
Lagrangian models it is essential that the physical propertied of the three
representations of the liquid are consistent which means that it is necessary to
instantiate the thermodynamics packages on liquidProperties. This requires
either liquidProperties to be rewritten mole-based or the specie classes to be
rewritten mass-based. Given that most of OpenFOAM solvers operate
mass-based (solve for mass-fractions and provide mass-fractions to sub-models it
is more consistent and efficient if the low-level thermodynamics is also
mass-based.
This commit includes all of the changes necessary for all of the thermodynamics
in OpenFOAM to operate mass-based and supports the instantiation of
thermodynamics packages on liquidProperties.
Note that most users, developers and contributors to OpenFOAM will not notice
any difference in the operation of the code except that the confusing
nMoles 1;
entries in the thermophysicalProperties files are no longer needed or used and
have been removed in this commet. The only substantial change to the internals
is that species thermodynamics are now "mixed" with mass rather than mole
fractions. This is more convenient except for defining reaction equilibrium
thermodynamics for which the molar rather than mass composition is usually know.
The consequence of this can be seen in the adiabaticFlameT, equilibriumCO and
equilibriumFlameT utilities in which the species thermodynamics are
pre-multiplied by their molecular mass to effectively convert them to mole-basis
to simplify the definition of the reaction equilibrium thermodynamics, e.g. in
equilibriumCO
// Reactants (mole-based)
thermo FUEL(thermoData.subDict(fuelName)); FUEL *= FUEL.W();
// Oxidant (mole-based)
thermo O2(thermoData.subDict("O2")); O2 *= O2.W();
thermo N2(thermoData.subDict("N2")); N2 *= N2.W();
// Intermediates (mole-based)
thermo H2(thermoData.subDict("H2")); H2 *= H2.W();
// Products (mole-based)
thermo CO2(thermoData.subDict("CO2")); CO2 *= CO2.W();
thermo H2O(thermoData.subDict("H2O")); H2O *= H2O.W();
thermo CO(thermoData.subDict("CO")); CO *= CO.W();
// Product dissociation reactions
thermo CO2BreakUp
(
CO2 == CO + 0.5*O2
);
thermo H2OBreakUp
(
H2O == H2 + 0.5*O2
);
Please report any problems with this substantial but necessary rewrite of the
thermodynamic at https://bugs.openfoam.org
Henry G. Weller
CFD Direct Ltd.
Description
Evolves a passive scalar transport equation.
- To specify the field name set the \c field entry
- To employ the same numerical schemes as another field set
the \c schemesField entry,
- A constant diffusivity may be specified with the \c D entry,
- Alternatively if a turbulence model is available a turbulent diffusivity
may be constructed from the laminar and turbulent viscosities using the
optional diffusivity coefficients \c alphaD and \c alphaDt (which default
to 1):
\verbatim
D = alphaD*nu + alphaDt*nut
\endverbatim
Resolves feature request https://bugs.openfoam.org/view.php?id=2453
boundaryRadiationProperties: updating to new format
dynamicMeshDict and snappyHexMeshDict in utorials/multiphase/interDyMFoam/RAS/motorBike to follow Mattijs Git lab id 381
- Introduce writeList(Ostream&, label) method in various List classes to
provide more flexibility and avoid hard-coded limits when deciding if a
list is too long and should be broken up into multiple lines (ASCII only).
- The old hard-code limit (10) is retained in the operator<< versions
- This functionality is wrapped in the FlatOutput output adapter class
and directly accessible via the 'flatOutput()' function.
Eg,
#include "ListOps.H"
Info<< "methods: " << flatOutput(myLongList) << endl;
// OR
Info<< "methods: ";
myLongList.writeList(os) << endl;
Now the interFoam and compressibleInterFoam families of solvers use the same
alphaEqn formulation and supporting all of the MULES options without
code-duplication.
The semi-implicit MULES support allows running with significantly larger
time-steps but this does reduce the interface sharpness.
- templated code that is not actually be used yet.
ENH: avoid combineFields for serial case
Note: a 'master-only' variant with combineList only on the master and
without scatter can be pursued later.
- collects the log information only, without running any cases.
This can be useful if the user has terminated the test prematurely
but nonetheless wishes to summarize the log output.
Description
Simple solidification porosity model
This is a simple approximation to solidification where the solid phase
is represented as a porous blockage with the drag-coefficient evaluated from
\f[
S = - \alpha \rho D(T) U
\f]
where
\vartable
\alpha | Optional phase-fraction of solidifying phase
D(T) | User-defined drag-coefficient as function of temperature
\endvartable
Note that the latent heat of solidification is not included and the
temperature is unchanged by the modelled change of phase.
Example of the solidification model specification:
\verbatim
type solidification;
solidificationCoeffs
{
// Solidify between 330K and 330.5K
D table
(
(330.0 10000) // Solid below 330K
(330.5 0) // Liquid above 330.5K
);
// Optional phase-fraction of solidifying phase
alpha alpha.liquid;
// Solidification porosity is isotropic
// use the global coordinate system
coordinateSystem
{
type cartesian;
origin (0 0 0);
coordinateRotation
{
type axesRotation;
e1 (1 0 0);
e2 (0 1 0);
}
}
}
\endverbatim
Description
Simple solidification porosity model
This is a simple approximation to solidification where the solid phase
is represented as a porous blockage with the drag-coefficient evaluated from
\f[
S = - \rho D(T) U
\f]
where
\vartable
D(T) | User-defined drag-coefficient as function of temperature
\endvartable
Note that the latent heat of solidification is not included and the
temperature is unchanged by the modelled change of phase.
Example of the solidification model specification:
\verbatim
type solidification;
solidificationCoeffs
{
// Solidify between 330K and 330.5K
D table
(
(330.0 10000) // Solid below 330K
(330.5 0) // Liquid above 330.5K
);
// Solidification porosity is isotropic
// use the global coordinate system
coordinateSystem
{
type cartesian;
origin (0 0 0);
coordinateRotation
{
type axesRotation;
e1 (1 0 0);
e2 (0 1 0);
}
}
}
\endverbatim
if convergence is not achieved within the maximum number of iterations.
Sometimes, particularly running in parallel, PBiCG fails to converge or diverges
without warning or obvious cause leaving a solution field containing significant
errors which can cause divergence of the application. PBiCGStab is more robust
and does not suffer from the problems encountered with PBiCG.
- Constructs a validated word, in which all invalid characters have
been stripped out and any leading digit is '_'-prefixed.
Words with leading digits cause parse issues when read back later.
- Replaces previous functionally identical code from src/conversion
--
COMP: test against nullObject instead of checking address for null pointer.
- The code create a box with a (0,0,0) point.
The new definition is more logical and makes it very easy to grow
the bounding box to include new points. It also simplifies much of
the logic in the constructors.
- Use ROOTVGREAT instead of VGREAT for sizing greatBox and invertedBox.
Avoids some overflow issues reported by Mattijs (thus GREAT has been
used in treeBoundBox), but might still need further revision.
- to the referenced object via a method name, which may be clearer
than deferencing the iterator
[key, value] => iter.key(), *iter
[key, value] => iter.key(), iter()
[key, value] => iter.key(), iter.object()
- Constructor for bounding box of a single point.
- add(boundBox), add(point) ...
-> Extend box to enclose the second box or point(s).
Eg,
bb.add(pt);
vs.
bb.min() = Foam::min(bb.min(), pt);
bb.max() = Foam::max(bb.max(), pt);
Also works with other bounding boxes.
Eg,
bb.add(bb2);
// OR
bb += bb2;
vs.
bb.min() = Foam::min(bb.min(), bb2.min());
bb.max() = Foam::max(bb.max(), bb2.max());
'+=' operator allows the reduction to be used in parallel
gather/scatter operations.
A global '+' operator is not currently needed.
Note: may be useful in the future to have a 'clear()' method
that resets to a zero-sized (inverted) box.
STYLE: make many bounding box constructors explicit
reduce()
- parallel reduction of min/max values.
Reduces coding for the callers.
Eg,
bb.reduce();
instead of the previous method:
reduce(bb.min(), minOp<point>());
reduce(bb.max(), maxOp<point>());
STYLE:
- use initializer list for creating static content
- use point::min/point::max when defining standard boxes
The previous time-step compression flux is not valid/accurate on the new mesh
and it is better to re-calculate it rather than map it from the previous mesh to
the new mesh.
By default snappyHexMesh writes files relating to the hex-splitting process into
the polyMesh directory: cellLevel level0Edge pointLevel surfaceIndex
but by setting the noRefinement flag:
writeFlags
(
noRefinement
.
.
.
);
these optional files which are generally not needed are not written.
If you run the three stages of snappyHexMesh separately or run a dynamic mesh
solver supporting refinement and unrefinement these files are needed
and "noRefinement" should not be set.
unless the blockMeshDict is in the polyMesh directory or the "-noClean" option
is specified.
This avoids problems running snappyHexMesh without first clearing files from
polyMesh which interfere with the operation of snappyHexMesh.
The files relating to the hex refinement are written out explicitly both by
snappyHexMesh and dynamicRefineFvMesh and hence should be set "NO_WRITE" rather
than "AUTO_WRITE" to avoid writing them twice. This change corrects the
handling of the "refinementHistory" file which should not be written by
snappyHexMesh.
Avoids slight phase-fraction unboundedness at entertainment BCs and improved
robustness.
Additionally the phase-fractions in the multi-phase (rather than two-phase)
solvers are adjusted to avoid the slow growth of inconsistency ("drift") caused
by solving for all of the phase-fractions rather than deriving one from the
others.
- no reason to use post-increment in forAll() macro.
- use C++11 cbegin()/cend() method names for forAll*Iter() macros.
These method names have been in OpenFOAM since 2009 and are also
used by C++11 containers.
STYLE: nullptr instead of 0 in UList
e.g.
fieldMinMax fieldMinMax write:
min(T) = 291 in cell 255535 at location (-0.262546 -0.538933 1.00574) on processor 9
max(T) = 336.298 in cell 419031 at location (1.7468 0.758405 8.10989) on processor 1
min(mag(U)) = 0 in cell 14990 at location (-0.0824383 1.68479 1.5349) on processor 0
max(mag(U)) = 652.341 in cell 218284 at location (0.609849 0.167247 1.00091) on processor 12
Examples,
wmakePrintBuild -plus
Check if value is known
(ie, everything configured and also OpenFOAM+):
if wmakePrintBuild -plus >/dev/null 2>&1
then
echo YES
else
echo NO
fi
Check if version is new enough
if ofver=$(wmakePrintBuild -plus 2>/dev/null) && [ "$ofver" -ge 1612 ]
then
echo YES
else
echo NO
fi
Conditionals
ofver=$(wmakePrintBuild -plus 2>/dev/null)
case "${ofver:=0}" in
1612)
echo "something for 1612
;;
1706)
echo "something for 1706
;;
esac
- as originally intended years ago, but never actually done.
- use 'foamPvCore' instead of 'vtkPVReaders' to avoid potential name
collisions with any 'vtk*' files and since we may reuse these
functions in other foam-paraview modules (not just readers).
STYLE: use same font size/colour for patch-names as for point-numbers
BUG: repair issue with single time-step
- paraview time-selector returns '0' as the requested time if there is
only one time step. However, if we have skipped the 0/ directory,
this single time step is likely a non-zero value.
- makes it easier to use as a wordHashSet replacement for situations
where we want to avoid duplicates but retain the input order.
- support construction from HashTable, which means it works like the
HashTable::sortedToc but with its own hashing for these keys.
- expose rehash() method for the user. There is normally no need for
using it directly, but also no reason to lock it away as private.
New reactingFoam tutorial counterFlowFlame2DLTS_GRI_TDAC demonstrates this new
functionality.
Additionally the ISAT table growth algorithm has been further optimized
providing an overall speedup of between 15% and 38% for the tests run so far.
Updates to TDAC and ISAT provided by Francesco Contino.
Implementation updated and integrated into OpenFOAM-dev by
Henry G. Weller, CFD Direct Ltd with the help of Francesco Contino.
Original code providing all algorithms for chemistry reduction and
tabulation contributed by Francesco Contino, Tommaso Lucchini, Gianluca
D’Errico, Hervé Jeanmart, Nicolas Bourgeois and Stéphane Backaert.
e.g. in tutorials/heatTransfer/buoyantSimpleFoam/externalCoupledCavity/0/T
hot
{
type externalCoupledTemperature;
commsDir "${FOAM_CASE}/comms";
file "data";
initByExternal yes;
log true;
value uniform 307.75; // 34.6 degC
}
Previously both 'file' and 'fileName' were used inconsistently in different
classes and given that there is no confusion or ambiguity introduced by using
the simpler 'file' rather than 'fileName' this change simplifies the use and
maintenance of OpenFOAM.
e.g.
motorBike
{
type triSurfaceMesh;
file "motorBike.obj";
}
Based on patch provided by Mattijs Janssens
Resolves part of bug-report https://bugs.openfoam.org/view.php?id=2396
- use "-pvMAJ.MIN" suffix for similarity with the paraview convention
- use sentinel file to ensure clean change of intermediate targets
- ensure all library files are being properly removed
- remove old (ParaView-3) files
- Works in 4.4.0, 5.0.1, 5.2.0 etc
STYLE:
- slots now use SM properties directly without a second lookup.
This reduces exposure of the QT elements and simplifies the coding.
- avoid focus borders on the Qt elements
- place the "use Polyhedron" checkbox into a column
- move "Cache Mesh" down in the GUI (an advanced feature and thus
should be less prominent)
- obtain button labels/tooltip directly from the XML content
- although this is not the final desired form, since it uses
individual pqPropertyWidget customizations (ie, ugly layout, too
many bits of code), but is an interesting intermediate solution
that may be useful in other contexts.
- provide headerType typedef in foamVtkFormatter, foamVtkOutput
- remove byteOrder and headerType constants from foamVtkFormatter
since the same strings can also be obtained from foamVtkPTraits
- additional convenience methods in foamVtkFormatter
- LD_LIBRARY_PATH was not being cleaned at all when switching between
paraview versions.
- PATH was cleaned against the third-party paraview-*, although 3rd
party paraview is installed as ParaView-*.
The additional cleanup for ParaView_DIR may not catch this (if it
was unset elsewhere).
e.g. in the reactingFoam/laminar/counterFlowFlame2DLTS tutorial:
PIMPLE
{
momentumPredictor no;
nOuterCorrectors 1;
nCorrectors 1;
nNonOrthogonalCorrectors 0;
maxDeltaT 1e-2;
maxCo 1;
alphaTemp 0.05;
alphaY 0.05;
Yref
{
O2 0.1;
".*" 1;
}
rDeltaTSmoothingCoeff 1;
rDeltaTDampingCoeff 1;
}
will limit the LTS time-step according to the rate of consumption of 'O2'
normalized by the reference mass-fraction of 0.1 and all other species
normalized by the reference mass-fraction of 1. Additionally the time-step
factor of 'alphaY' is applied to all species. Only the species specified in the
'Yref' sub-dictionary are included in the LTS limiter and if 'alphaY' is omitted
or set to 1 the reaction rates are not included in the LTS limiter.
Combined 'dQ()' and 'Sh()' into 'Qdot()' which returns the heat-release rate in
the normal units [kg/m/s3] and used as the heat release rate source term in
the energy equations, to set the field 'Qdot' in several combustion solvers
and for the evaluation of the local time-step when running LTS.
defined by functionObjects, e.g. wallHeatFlux, wallShearStress and yPlus.
Patch contributed by Bruno Santos
Resolves bug-report http://bugs.openfoam.org/view.php?id=2353
2016-12-09 21:54:13 +00:00
21483 changed files with 2277027 additions and 437562 deletions
OpenFOAM is a free, open source CFD software [released and developed primarily by OpenCFD Ltd](http://www.openfoam.com) since 2004released and developed primarily by. It has a large user base across most areas of engineering and science, from both commercial and academic organisations. OpenFOAM has an extensive range of features to solve anything from complex fluid flows involving chemical reactions, turbulence and heat transfer, to acoustics, solid mechanics and electromagnetics. [More...](http://www.openfoam.com/documentation)
OpenFOAM is a free, open source CFD software [released and developed by OpenCFD Ltd since 2004](http://www.openfoam.com/history/).
It has a large user base across most areas of engineering and science, from both commercial and academic organisations.
OpenFOAM has an extensive range of features to solve anything from complex fluid flows involving chemical reactions, turbulence and heat transfer, to acoustics, solid mechanics and electromagnetics.
OpenFOAM+ is professionally released every six months to include customer sponsored developments and contributions from the community, including the OpenFOAM Foundation. Releases designated OpenFOAM+ contain several man years of client-sponsored developments of which much has been transferred to, but not released in the OpenFOAM Foundation branch.
OpenFOAM is professionally released every six months to include
customer sponsored developments and contributions from the community -
individual and group contributors, integrations
(eg, from FOAM-extend and OpenFOAM Foundation Ltd) as well as
OpenFOAM is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. See the file COPYING in this directory or [http://www.gnu.org/licenses/](http://www.gnu.org/licenses), for a description of the GNU General Public License terms under which you can copy the files.
OpenFOAM is free software: you can redistribute it and/or modify it
under the terms of the GNU General Public License as published by the
Free Software Foundation, either version 3 of the License, or (at your
option) any later version. See the file COPYING in this directory or
[http://www.gnu.org/licenses/](http://www.gnu.org/licenses), for a
description of the GNU General Public License terms under which you
may redistribute files.
# OpenFOAM Trademark
OpenCFD Ltd grants use of the OpenFOAM trademark by Third Parties on a licence basis. ESI Group and the OpenFOAM Foundation Ltd are currently permitted to use the trademark. For information on trademark use, please refer to the [trademark policy guidelines](http://www.openfoam.com/legal/trademark-policy.php).
Please [contact OpenCFD](http://www.openfoam.com/contact) if you have any questions on the use of the OpenFOAM trademark.
OpenCFD Ltd grants use of its OpenFOAM trademark by Third Parties on a
licence basis. ESI Group and OpenFOAM Foundation Ltd are currently
permitted to use the Name and agreed Domain Name. For information on
trademark use, please refer to the [trademark policy guidelines](http://www.openfoam.com/legal/trademark-policy.php).
Violations of the Trademark are continuously monitored, and will be duly prosecuted.
Please [contact OpenCFD](http://www.openfoam.com/contact) if you have
any questions on the use of the OpenFOAM trademark.
Violations of the Trademark are monitored, and will be duly prosecuted.
# Using OpenFOAM
If OpenFOAM has already been compiled on your system, simply source
the appropriate `etc/bashrc` or `etc/cshrc` file and get started.
Some files were not shown because too many files have changed in this diff
Show More
Reference in New Issue
Block a user
Blocking a user prevents them from interacting with repositories, such as opening or commenting on pull requests or issues. Learn more about blocking a user.
