etc/bashrc
- improved robustness when sourcing
- source top-level prefs.sh first (for sysadmin changes)
etc/config.*/settings
- write job control information to the user directory
- site/ directory under the OpenFOAM project dir, not its parent dir
etc/config.*/mpi
- added USERMPI as place for spack mpi information
mgridgen, zoltan:
- make location configurable
metis, scotch:
- also check lib path (not just lib64)
- 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.
- 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).
boundaryRadiationProperties: updating to new format
dynamicMeshDict and snappyHexMeshDict in utorials/multiphase/interDyMFoam/RAS/motorBike to follow Mattijs Git lab id 381
- 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
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
- 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.
- 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).
- Could be related to interrupted builds.
So if there are any parts of the build that rely on an explicit
'wmakeLnInclude', make sure that the contents are properly updated.
--
ENH: improved feedback from top-level Allwmake
- Report which section (libraries, applications) is being built.
- Provide final summary of date, version, etc, which can be helpful
for later diagnosis or record keeping.
- The -log=XXX option for Allwmake now accepts a directory name
and automatically appends an appropriate log name.
Eg,
./Allwmake -log=logs/ ->> logs/log.linux64GccDPInt32Opt
The default name is built from the value of WM_OPTIONS.
--
BUG: shell not exiting properly in combination with -log option
- the use of 'tee' causes the shell to hang around.
Added an explicit exit to catch this.
--
- Detecting the '-k' (-non-stop) option at the top-level Allwmake, which
may improve robustness.
- Explicit continue-on-error for foamyMesh (as optional component)
- unify format of script messages for better readability
COMP: reduce warnings when building Pstream (old-style casts in openmpi)
- wm32/wm64 were for changing between -m32, -m64 builds on x86_64
architectures. This is seldom enough not to warrant a special alias.
Also ambiguous if these could refer to label sizes.
- Remove wm32,wm64 aliases.
- Add wmInt32, wmInt64 aliases for switching WM_LABEL_SIZE.
- As the names describe, check if the string starts or ends with a
particular value. Always true if the given text is empty or if the
string is identical to the given text.
- add an extension to the file name
- remove a file extension
- check if a file name has an extension
- check if a file name has a particular extension (as word),
or matches a particular grouping of extensions (as wordRe).
This slightly more convenient when working with char[] input:
fileName file1{ "path", "name", "to", "file.ext" };
vs. fileName file1 = fileName(path)/"name"/"to"/"file.ext";
But is a bit more efficient since it avoid most of the intermediate
copying and resizing incurred by the '/' operator.
Bounding thermo.rho in rhoPorousSimpleFoam.
Changing initial time step in externalSolarLoad tutorial.
Commenting out momemtun source term in steamInjection which causes problems
FoamFile
{
version 2.0;
format binary;
arch "LSB;label=32;scalar=64";
class vectorField;
object points;
}
There is otherwise no simple indication in any of the files as to the
sizes used (Int32 vs Int64, SP vs DP). This makes it difficult for the
end-user and also for any third-party consumers.
--
The architecture information contains three items in the following format:
(LSB|MSB);label=(32|64);scalar=(32|64)
- The endian value always appears first, without any leading space.
This make it trivial to check later. Either the first 3 letters (LSB
vs MSB) or even just the first letter ('L' vs 'M').
- Subsequent key=value pairs for 'label' and 'scalar' are separated
by semicolons. The ordering of label vs scalar is not specified.
Note that this 'arch' information is purely informational.
It is currently not used by the OpenFOAM input mechanism itself.
- polyMesh constructor from cell shapes invoked 'removeFiles'.
This may or may not be what the caller wants or expects.
With the ParaView blockMesh viewer, this behaviour causes deletion of
all mesh data (points, faces, etc) when the viewer is refreshed.
Triggered even when just building the blockMesh topology.
- only a few places that construct a polyMesh from cell shapes
(mostly mesh conversion utilities).
Ensure that the file removal (if any) occurs in the application
and *not* as a side-effect of calling the polyMesh constructor.
--
blockMesh (application)
- The placement of the removeFiles seems to also remove freshly
generated sets (Bug or feature to remove sets?)
+-----------------------+---------------+------------------+
| Application | Constructor | removeFiles |
| | (patch info) | new / existing |
+-----------------------+---------------+------------------+
| blockMesh | dictionary | existing |
| ansysToFoam | names | new |
| cfx4ToFoam | dictionary | new |
| fluentMeshToFoam | names | new |
| gambitToFoam | dictionary | new |
| gmshToFoam | names | new |
| ideasUnvToFoam | names | new |
| kivaToFoam | dictionary | new |
| mshToFoam | names | new |
| netgenNeutralToFoam | names | new |
| plot3dToFoam | names | new |
| tetgenToFoam | names | new |
| vtkUnstructuredToFoam | names | new |
+-----------------------+---------------+------------------+
ENH: runTimePostProcessing - added option to clear/remove objects after use
When specifying line and surface function-object-based visualisation, use the optional `clearObjects` flag to indicate that source objects should be removed/cleared after use.
Test case: [cavity.tgz](/uploads/62cc2761d132f42456f2af08f1499eba/cavity.tgz)
Syntax:
```
surfaces
{
cuttingPlane1
{
type functionObject;
functionObject cuttingPlane;
clearObjects yes; // new option
...
```
Note: only files that have been used will be removed, e.g. if a function object has created multiple surface files, unused files will remain at the end of the run - in the attached case the p surface remains...
See merge request !89
Integration of ihcantabria wave models
Integration of functionality produced by The Environmental Hydraulics Institute "IHCantabria" (http://www.ihcantabria.com/en/)
- Original code introduced in commit 95e9467e
- Restructured and updated by OpenCFD into a new `waveModels` library available to the interFoam family of solvers
Main source:
`$FOAM_SRC/waveModels`
Tutorials:
`$FOAM_TUTORIALS/multiphase/interFoam/waveExample*`
Capabilities include:
- Wave generation
- Solitary wave using Boussinesq theory
- Cnoidal wave theory
- StokesI, StokesII, StokesV wave theory
- Active wave absorption at the inflow/outflow boundaries based on shallow water theory
IHCantabria Authors:
- Javier Lopez Lara (jav.lopez@unican.es)
- Gabriel Barajas (barajasg@unican.es)
- Inigo Losada (losadai@unican.es)
See merge request !88
- extend the sampling concept to include surfMeshes and surfFields
for storage.
- Note the createOnRead switch in surfMeshSamplers can be desirable in
some situations to force creation of the surface faces within the
constructor.
- was using the ids coming from the zones instead of the sorted order
from ensightFaces, which led to a clash in the mesh point maps that
were manifest as a jumbled order.
BUG: missing newlines in foamToEnsight nfaced/nsided ASCII output
- was correct for foamToEnsightParts, but not for foamToEnsight
--
* Many thanks to Justin Graupman for all of his testing,
which has been a great help in isolating and fixing various issues.
ENH: reduce number of variables, simplify code
- Note: use boolList instead of scalarList for managing the face signs
since its lazy evaluation can be convenient when sign information is
not required.
New feature extract eulerian particles
New functionality to extract particle data from multiphase calculations and replay the data in lagrangian cases, using both the raw input particle data, and data processed into a (smaller) set of injection locations.
See merge request !82
Description
Replays an set of particle data based on an injectedParticleCloud,
using the assumption of one particle per parcel.
Usage
\verbatim
model1
{
type injectedParticleInjection;
SOI 0;
massTotal 0; // Place holder only
parcelBasisType fixed;
nParticle 1; // 1 particle per parcel
cloud eulerianParticleCloud;
positionOffset (-0.025 2 -0.025);
}
\endverbatim
Description
Interrogates an injectedParticleCloud to convert the raw particle
data into a set of 'binned' injectors.
The bins are set according to the particle \c tag property, from which:
- diameters are converted into \c general distributions with a
user-specified bin width
- raw velocity and diameter data are resampled and stored to provide
variations per injector
The mass to inject can be set according to the raw input data mass total
by using the \c applyDistributionMassTotal switch
Usage
\verbatim
model1
{
type injectedParticleDistributionInjection;
SOI 0;
parcelBasisType mass;
cloud eulerianParticleCloud;
positionOffset (-0.025 2 -0.025);
binWidth 0.1e-3;
parcelsPerInjector 500;
resampleSize 100; // optional
applyDistributionMassTotal yes;
// Placeholder only when using applyDistributionMassTotal
massTotal 0;
}
\endverbatim
Note
The each injector location is assumed to be operating under steady
conditions, i.e. using a constant flow rate profile
SourceFiles
InjectedParticleDistributionInjection.C
See also
Foam::injectedParticle
Foam::injectedParticleCloud
Foam::functionObjects::extractEulerianParticles
Foam::distributionModels::general
Pstream: added maxCommsSize setting to do (unstructured) parallel transfers in blocks.
Tested:
- with maxCommsSize 0 produces exactly same result as plus.develop
- compiles with label64
- with maxCommsSize e.g. 3 produces exactly same result as plus.develop
- with maxCommsSize=0 exactly the same messages (with Pstream::debug = 1) as plus.develop
See merge request !85
ENH: Usage of locationsInMesh for tutorial and other fix
- Example for Using multiple locations in mesh
- bugFix for rhoPimpleFoam case
See merge request !86
This is controlled by the setting maxCommsSize in etc/controlDict which
specifies the max number of bytes per exchange. If set to <= 0 it
is ignored. This max size of messages is important when doing e.g.
load balancing which can send over whole meshes.
which provided warning about backward-compatibility issue with setting div
schemes for steady-state. It caused confusion by generating incorrect warning
messages for compressible cases for which the 'bounded' should NOT be applied to
the 'div(phid,p)'.
- if set in a dictionary and later removed, the intermediate value is
retained rather than reverting to a normal default value.
- same applies for a few other function objects and their variables
1) Using divU instead of fvc::absolute(phi,U) in TEqn as the latter uses latest time meshPhi which is inconsistent
2) Adding fvc::interpolate(U) when topo changes
3) in pEq for compressible dgdt is updated using the latest rho1 and rho2 after compressible effects are considered
ENH: improve objectRegistry functionality (issue #322)
- Recursive searching for objects within a registry is now optional
(previous it was always done).
A recursive search effectively blocks the construction of sub-sub-registries
if their names are 'masked' by some parent level sub-registry with
the same name! (BUG)
- Recursive search is now turned OFF by default, which makes it consistent
with dictionary and probably causes the least number of surprises.
----
Various new convenience methods added:
lookupObjectRef()
- returns a non-const reference.
For example,
volScalarField& U = mesh().lookupObjectRef<volScalarField>("U");
Instead of
volScalarField& U = const_cast<volScalarField&>
(
mesh().lookupObject<volScalarField>("U")
);
--
lookupObjectPtr()
- returns a const pointer, and nullptr on failure.
For example,
const volScalarField* Uptr = mesh().lookupObjectPtr<volScalarField>("U");
if (Uptr)
{
const volScalarField& U = *Uptr;
...
}
Instead of
if (mesh().foundObject<volScalarField>("U"))
{
const volScalarField& U = mesh().lookupObject<volScalarField>("U");
...
}
--
lookupObjectRefPtr()
- returns a non-const pointer, and nullptr on failure.
For example,
volScalarField* Uptr = mesh().lookupObjectRefPtr<volScalarField>("U");
if (Uptr)
{
volScalarField& U = *Uptr; // use as reference
(*Uptr) = ...; // or use directly
}
Instead of
if (mesh().foundObject<volScalarField>("U"))
{
volScalarField& U = const_cast<volScalarField&>
(
mesh().lookupObject<volScalarField>("U")
);
}
--
sortedNames()
- now works with template parameters and with regular expression
matching as well.
For example,
wordList names = mesh().sortedNames();
wordList fields = mesh().sortedName<volScalarField>();
Instead of
wordList names = mesh().sortedNames();
wordList fields = mesh().names<volScalarField>();
Foam::sort(fields);
--
See merge request !83
runTimePostProcessing FO camera update
- Removed the camera 'mode'
- The (old) static camera was only appropriate when parallel
projection was inactive, and the view was centred at (0 0 0)
- Camera input now always requires 'position' and 'focalPoint'
- Clip box is now optional. Note that this is applied after the
camera
set-up and so will override the camera position
- View angle is only appropriate when not using parallel projection
- Zoom now required, applied after all other operations
- 1 = do nothing, >1 = zoom in, <1 = zoom out
Example input:
```
camera
{
// Total number of frames to generate
nFrameTotal 1;
// Parallel projection flag
parallelProjection no;
focalPoint (0 0 0);
up (0 1 0);
position (0 0 1);
// Optional entries
clipBox (-0.0206 -0.0254 -0.0005) (0.29 0.0254 0.0005);
viewAngle 20;
zoom 1.1;
}
```
See merge request !81
- provide additional filtering methods on names(), sortedNames()
For example,
IOobjectList objects = ...;
wordReList selection = ...;
objects.sortedNames(VolFieldType::typeName, selection);
e.g. the motion of two counter-rotating AMI regions could be defined:
dynamicFvMesh dynamicMotionSolverListFvMesh;
solvers
(
rotor1
{
solver solidBody;
cellZone rotor1;
solidBodyMotionFunction rotatingMotion;
rotatingMotionCoeffs
{
origin (0 0 0);
axis (0 0 1);
omega 6.2832; // rad/s
}
}
rotor2
{
solver solidBody;
cellZone rotor2;
solidBodyMotionFunction rotatingMotion;
rotatingMotionCoeffs
{
origin (0 0 0);
axis (0 0 1);
omega -6.2832; // rad/s
}
}
);
Any combination of motion solvers may be selected but there is no special
handling of motion interaction; the motions are applied sequentially and
potentially cumulatively.
To support this new general framework the solidBodyMotionFvMesh and
multiSolidBodyMotionFvMesh dynamicFvMeshes have been converted into the
corresponding motionSolvers solidBody and multiSolidBody and the tutorials
updated to reflect this change e.g. the motion in the mixerVesselAMI2D tutorial
is now defined thus:
dynamicFvMesh dynamicMotionSolverFvMesh;
solver solidBody;
solidBodyCoeffs
{
cellZone rotor;
solidBodyMotionFunction rotatingMotion;
rotatingMotionCoeffs
{
origin (0 0 0);
axis (0 0 1);
omega 6.2832; // rad/s
}
}
- Recursive searching for objects within a registry is now optional
(previous it was always done).
A recursive search effectively blocks the construction of sub-sub-registries
if their names are 'masked' by some parent level sub-registry with
the same name! (BUG)
- Recursive search is now turned OFF by default, which makes it consistent
with dictionary and probably causes the least number of surprises.
----
Various new convenience methods added:
lookupObjectRef()
- returns a non-const reference.
For example,
volScalarField& U = mesh().lookupObjectRef<volScalarField>("U");
Instead of
volScalarField& U = const_cast<volScalarField&>
(
mesh().lookupObject<volScalarField>("U")
);
--
lookupObjectPtr()
- returns a const pointer, and nullptr on failure.
For example,
const volScalarField* Uptr = mesh().lookupObjectPtr<volScalarField>("U");
if (Uptr)
{
const volScalarField& U = *Uptr;
...
}
Instead of
if (mesh().foundObject<volScalarField>("U"))
{
const volScalarField& U = mesh().lookupObject<volScalarField>("U");
...
}
--
lookupObjectRefPtr()
- returns a non-const pointer, and nullptr on failure.
For example,
volScalarField* Uptr = mesh().lookupObjectRefPtr<volScalarField>("U");
if (Uptr)
{
volScalarField& U = *Uptr; // use as reference
(*Uptr) = ...; // or use directly
}
Instead of
if (mesh().foundObject<volScalarField>("U"))
{
volScalarField& U = const_cast<volScalarField&>
(
mesh().lookupObject<volScalarField>("U")
);
}
--
sortedNames()
- now works with template parameters and with regular expression
matching as well.
For example,
wordList names = mesh().sortedNames();
wordList fields = mesh().sortedName<volScalarField>();
Instead of
wordList names = mesh().sortedNames();
wordList fields = mesh().names<volScalarField>();
Foam::sort(fields);
--
- all sampled surface types now consistently use the same storage,
which allows some more simplifications in the future.
- before/after comparison of the sampledTriSurfaceMesh tested with
motorbike passenger helmet (serial and parallel). Use the newly added
'keepIds' functionality to retain the original ids, and can also
compare them to the original obj file with "GenerateIds" in paraview.
- this makes it easier to reuse the code, and sampledSurface expect
a face (not a labelledFace), so this also eliminates a translation
level and simplifies memory management.
- before/after comparison of the sampled iso-surfaces tested with
iso-surfaces from interFoam/RAS/angledDuct tutorial (serial and
parallel)
For example,
surfaces
(
helmet
{
type sampledTriSurfaceMesh;
surface motorBike-passenger-helmet.obj;
source cells;
keepIds true; <<-- NEW
}
);
This will create an additional "Ids" field that can be used to sort
or as a faceMap to recover the original face order.
Generates discrete particle data from multiphase calculations by
interrogating the phase fraction field at a faceZone.
Data is written in raw form, i.e. per particle collected, with
as an optional binned distribution
STYLE: only use paraview settings when actually available
- this means executing makeParaView prior to building OpenFOAM itself,
but is consistent with the instructions given by makeParaView,
and elminates anticipating the source location from the paraview
config file, which increases the build flexibilty for ThirdParty
- Removed the camera 'mode'
- The (old) static camera was only appropriate when parallel
projection was inactive, and the view was centred at (0 0 0)
- Camera input now always requires 'position' and 'focalPoint'
- Clip box is now optional. Note that this is applied after the
camera
set-up and so will override the camera position
- View angle is only appropriate when not using parallel projection
- Zoom now required, applied after all other operations
- 1 = do nothing, >1 = zoom in, <1 = zoom out
Example input:
camera
{
// Total number of frames to generate
nFrameTotal 1;
// Parallel projection flag
parallelProjection no;
// Optional clippling box
clipBox (-0.0206 -0.0254 -0.0005) (0.29 0.0254 0.0005);
focalPoint (0 0 0);
up (0 1 0);
position (0 0 1);
viewAngle 20;
zoom 1.1;
}
Feature noise multiple files
Enabled pointNoise and surfaceNoise models to operate on multiple input files
- For each model, the files should be specified by the `inputFiles` keyword
- When applied to pointNoise, the file is no longer required when specifying the CSV input data
- the singular `inputFile` entry is still available to the surfaceNoise model for backwards compatibilty
See merge request !80
to avoid duplicate instantiation of the thermodynamics package.
The 'zoneCombustion' model is now selected in constant/combustionProperties by
either
combustionModel zoneCombustion<psiCombustionModel>;
or
combustionModel zoneCombustion<rhoCombustionModel>;
as appropriate.
Resolves bug-report http://bugs.openfoam.org/view.php?id=2354
- support gperftools-none, gperftools-system configurations
as per other third-party packages.
STYLE: clean up more environment variables
CONFIG: testing adios rule
- provides support for manipulating polyMesh/boundary
- changed behaviour of disableFunctionEntries option to preserve
#include
- dictionary: added reading of lists of dictionaries.
+ each list element may be accessed using the 'entryDDD' keyword
according to their list index.
Patch contributed by Mattijs Janssens
- these directories are sometimes used for a central, non-thirdparty, non-system
installation
- leave gmp and mpfr as is, since it is not clear how these would interact with system
versions
cellZones and pointZones can now be created in one action without the
need to first create a cellSet or pointSet and converting that to the
corresponding zone, e.g.
actions
(
// Example: create cellZone from a box region
{
name c0;
type cellZoneSet;
action new;
source boxToCell;
sourceInfo
{
box (0.04 0 0)(0.06 100 100);
}
}
);
postProcess -func MachNo
previously generated the warning
Executing functionObjects
--> FOAM Warning : functionObjects::MachNo MachNo cannot find required field U
which is incorrect; the field 'U' is available but the
thermophysicalProperties is not. Now 'postProcess' generates the
warning:
Executing functionObjects
--> FOAM Warning : functionObjects::MachNo MachNo cannot find required object thermophysicalProperties of type fluidThermo
--> FOAM Warning : functionObjects::MachNo MachNo failed to execute.
Resolves bug-report http://bugs.openfoam.org/view.php?id=2352
in which the reactions are enabled only in the specified list of
cellZones. e.g. in constant/combustionProperties
combustionModel zoneCombustion<psiChemistryCombustion>;
active true;
zoneCombustionCoeffs
{
zones (catalyst);
}
and in constant/zoneCombustionProperties
combustionModel laminar<psiChemistryCombustion>;
active true;
laminarCoeffs
{}
- identical code was present in surfaceCheck (original source),
and isoSurface, isoSurfaceCell (copies).
- add in a MeshedSurface<face> variant as well, since this will likely
be needed in the near future
- The null constructor already creates a dimensionless Zero,
but named "undefined".
Provide an constructor for a dimensioned Zero,
but named "0" for universal clarity to its value.
- only occurs in combination with distributedTriSurfaceMesh in snappy.
- workaround similar to that previously used for surfaceRedistributePar
(issue #60).
Minor adjustment of incompressible motorBike tutorial to detect use of
distributedTriSurfaceMesh.
- there was a slight mix of MUST_READ and MUST_READ_IF_MODIFIED
but with no obvious code to handle runtime modified values
of the decomposition, or how this works with alternative
dictionaries.
* boost 1_62_0 (Sept 2016)
* CGAL 4.9 (Sept 2016)
- now has headers-only mode that could be interesting
* FFTW 3.3.5 (Jul 2016)
* openmpi 1.10.4 (Sept 2016)
- the first openmpi 2.x release is also available, but too early to switch
* paraview 5.2.0 (Nov 2016)
- builds without additional patching
STYLE: removed unneeded CMake environment variables
Corrected form of the Rosin-Rammler distribution taking into account the
varying number of particels per parces for for fixed-mass parcels. This
distribution should be used when
\verbatim
parcelBasisType mass;
\endverbatim
See equation 10 in reference:
\verbatim
Yoon, S. S., Hewson, J. C., DesJardin, P. E., Glaze, D. J.,
Black, A. R., & Skaggs, R. R. (2004).
Numerical modeling and experimental measurements of a high speed
solid-cone water spray for use in fire suppression applications.
International Journal of Multiphase Flow, 30(11), 1369-1388.
\endverbatim
- in specific cases it can be useful to suppress searching the instances.
For example, if one only wishes to check if a "points" is available at
the given time instance, without searching backwards through all
times.
- Avoids possible discrepancy when the user selects non-coincidental
values for executeInterval and writeInterval.
- zeroGradient and ddt2 function objects
The operation can be applied to any volume or surface fields generating a
volume or surface scalar field.
Example of function object specification:
\verbatim
Ttot
{
type add;
libs ("libfieldFunctionObjects.so");
fields (T Tdelta);
result Ttot;
executeControl writeTime;
writeControl writeTime;
}
\endverbatim
Also refactored functionObjects::fieldsExpression to avoid code
duplication between the 'add' and 'subtract' functionObjects.
The operation can be applied to any volume or surface fields generating a
volume or surface scalar field.
Example of function object specification:
\verbatim
Tdiff
{
type subtract;
libs ("libfieldFunctionObjects.so");
fields (T Tmean);
result Tdiff;
executeControl writeTime;
writeControl writeTime;
}
\endverbatim
- Wave models significantly restructured and refactored into a hierarchy of run-time selecatable models
- Gravity no longer hard-coded
- Ability to use any direction as the gravity direction
- Boundary conditions simplified and take reference to the wave model
- removes a lot of code duplication and new code is ~30% faster
- Removed unused functions
Requires further testing
- Restart behaviour needs to be addressed
Capabilities include:
- Wave generation
- Solitary wave using Boussinesq theory
- Cnoidal wave theory
- StokesI, StokesII, StokesV wave theory
- Active wave absorption at the inflow/outflow boundaries based on
shallow water theory
Authors:
- Javier Lopez Lara (jav.lopez@unican.es)
- Gabriel Barajas (barajasg@unican.es)
- Inigo Losada (losadai@unican.es)
BUG: resolve some decomposeParDict problems (issues #60, #265).
- Cleanup/centralize handling of -decomposeParDict by relocating
common code into argList. Ensures that all processes receive
identical information about the -decomposeParDict opton.
- Only use alternative decomposeParDict for simpleFoam/motorBike
tutorial so that this will be included in the test loop for snappy.
- Added Mattijs' fix for surfaceRedistributePar.
See merge request !73
The spherical part of the Reynolds stress is included in the pressure so
that the wall boundary condition for the pressure is zeroGradient.
Resolves bug-report http://bugs.openfoam.org/view.php?id=2325
Surface declutter - issue #294
Removing various clutter from surfMesh and triSurface
- unused classes/files (backup copies on non-release repo)
- relocate some triSurface-related classes to where they make more sense, and where they can be reused.
- improve handling of various face types in MeshedSurface and UnsortedMeshedSurface (to bridge the gap to triSurface)
- improve transfer methods for reclaiming/reusing surface allocations
See merge request !77
- A special purpose MeshedSurface that exposes the stored values
for direct modification.
- Its usage should be restricted to special cases where the surface
needs modifications as an atomic operation.
- Now that the metisDecomp uses the metis definition for float/double,
do not need to verify the scalar sizes.
Note:
- could drop precision qualifier for metis, scotch installation
(include, lib) as being unneeded, but it is simpler to keep them
and continue to use the FOAM_EXT_LIBBIN path
(in case other ThirdParty software is compiled with different
precisions).
- the surfMesh classes where originally designed with limited
(protected) access to the underlying components. This is to
avoid unintentional direct changes, since these can quickly
lead to inconsistencies with the topology addressing etc.
However, if we wish to efficiently adjust surfaces, it is useful
to modify the components directly.
The compromise is to provide 'xfer' methods:
- xferFaces()
- xferPoints()
- xferZones()
These transfer the contents to an Xfer container for reuse, while
also resetting the topology addressing. To apply the changes,
the reset() method is used.
- ensure that MeshedSurface and UnsortedMeshedSurface can also work
with labelledTri faces.
- nTriangles() convenience method for meshed surfaces
- MeshedSurface::addZonesToFaces() method to copy zone information
into the labelledTri per-face region storage.
The goal is to replace the triSurface reading routines with
run-time selectable ones from surfMesh.
- triFace() now initialized with '-1', which makes it behave
equivalently to face(label).
- supply default region=0 for some labelledTri constructors.
This allows labelledTri to work more like a triFace and makes it
easier to use in templated methods and eases conversion from
triFace to a labelledTri.
- labelledTri(const labelUList&) can now be used when converting
from a face. It can have 3 values (use default region)
or 4 values (with region).
- face, triFace, labelledTri now all support construction with
initializer lists. This can be useful for certain types of code.
Eg,
triFace f1{a, b, c};
face f2{a, b, c};
labelledTri f3{a, b, c};
Work without ambiguity.
Also useful for templated methods:
FaceType f{remap[a], remap[b], remap[c]};
- Cannot pass through to underlying list constructor directly.
- As this constructor was broken, there seem to be a number of
workarounds scattered in the code. Could revisit them in the future
as part of code-style:
edgeMesh(const Xfer<pointField>&, const Xfer<edgeList>&);
CompactIOField(const IOobject&, const Xfer<Field<T>>&);
GlobalIOField(const IOobject&, const Xfer<Field<Type>>&);
IOField(const IOobject&, const Xfer<Field<Type>>&);
- Condition is there to catch cases where the vtkSurfaceFormat returns
no zones (which should never be the case), but assigns a fallback
value without first resizing.
- This format is fortunately little-used (or never used) since its
inception.
Using raw stream operators to write zones, points and faces in a
single file was not well thought out - the output content varies
with the Face template type (face, triFace, labelledFace), which
makes it not very robust at all.
The static read in OFSsurfaceFormat also has a bug - keeping
transcribed faces from being passed through.
Conclusion: removing it makes more sense that repairing and still
not having something good.
Do retain stream operators for MeshedSurface and UnsortedMeshedSurface,
since they are useful for passing around data
(eg, between processors), but they shouldn't be used for files.
- Cannot test if these older reader modules actually build,
owning largely to build issues since with paraview 3.14 (Feb 2012)
and paraview 3.98 (Dec 2012) themselves.
Improvements to the conversion utilities
Various changes associated with issue #204.
* Reduced code duplication for handling prostar conversion and IO
* Simple conversion to/from AVL/FIRE geometries
* New library basis for conversion to/from CCM geometries - handles multiple regions, conformal interfaces etc. No support for film or 2d shell geometries
* Improved infrastructure for writing VTK content. Will propagate usage through other parts of the code in the future.
See merge request !76
- relied on 'export' keyword, which was removed in commit b844867112
--
ENH: foamConfigurePaths support for additional items:
-label 32|64 specify label size
-system name specify 'system' compiler to be used
-thirdParty name specify 'ThirdParty' compiler to be used
-boost ver specify boost_version
-boostArchPath dir specify BOOST_ARCH_PATH
-cgal ver specify cgal_version
-cgalArchPath dir specify CGAL_ARCH_PATH
-clang ver specify clang_version for ThirdParty Clang
-cmake ver specify cmake_version
-fftw ver specify fffw_version
-fftwArchPath dir specify FFTW_ARCH_PATH
-metis ver specify METIS_VERSION
-metisArchPath dir specify METIS_ARCH_PATH
Added the interfacial pressure-work terms according to:
Ishii, M., Hibiki, T.,
Thermo-fluid dynamics of two-phase flow,
ISBN-10: 0-387-28321-8, 2006
While this is the most common approach to handling the interfacial
pressure-work it introduces numerical stability issues in regions of low
phase-fraction and rapid flow deformation. To alleviate this problem an
optional limiter may be applied to the pressure-work term in either of
the energy forms. This may specified in the
"thermophysicalProperties.<phase>" file, e.g.
pressureWorkAlphaLimit 1e-3;
which sets the pressure work term to 0 for phase-fractions below 1e-3.
For particularly unstable cases a limit of 1e-2 may be necessary.
The best of the current options is to use the latest version of
exuberant ctags (which has a new C++ parser) to generate both
declaration and definition tags.
gtags works to some extent and provides additional information about the
function signatures but the C++ parser is not accurate and misses scope
information. gtags can be used with the ctags parser which is effective
but looses the primary advantage of gtags being able to provide function
signatures so support has been switched-off by default.
ebrowse does not appear to be very useful for traversing the OpenFOAM
class tree and the support has been switched-off by default.
- Follow similar pattern as per boost/CGAL with the '*-none' to disable,
and '*-system' for system installations.
Also support central non-ThirdParty installations by specifying the
version as "*-system", but also providing the fully qualified
*_ARCH_PATH too.
--
ENH: Verify label and scalar sizes used in the metis header.
- ensure they match with expected values, which can be obtained via
the OpenFOAM definitions for WM_LABEL_SIZE and WM_PRECISION_OPTION
Added 'READ_IF_PRESENT' option to support overriding of the default BCs
for complex problems requiring special treatment of Udm at boundaries.
Resolves bug-report http://bugs.openfoam.org/view.php?id=2317
- Only reference the FOAM_EXT_LIBBIN locations when linking.
The respective SCOTCH_ARCH_PATH/lib, METIS_ARCH_PATH/lib locations
either do not exist, or are possibly inconsistent and won't be
seen at run-time anyhow.
- Incorporate decompose/metisDecomp/Allwmake into the top-level
decompose/Allwmake
In many publications and Euler-Euler codes the pressure-work term in the
total enthalpy is stated and implemented as -alpha*dp/dt rather than the
conservative form derived from the total internal energy equation
-d(alpha*p)/dt. In order for the enthalpy and internal energy equations
to be consistent this error/simplification propagates to the total
internal energy equation as a spurious additional term p*d(alpha)/dt
which is included in the OpenFOAM Euler-Euler solvers and causes
stability and conservation issues.
I have now re-derived the energy equations for multiphase flow from
first-principles and implemented in the reactingEulerFoam solvers the
correct conservative form of pressure-work in both the internal energy
and enthalpy equations.
Additionally an optional limiter may be applied to the pressure-work
term in either of the energy forms to avoid spurious fluctuations in the
phase temperature in regions where the phase-fraction -> 0. This may
specified in the "thermophysicalProperties.<phase>" file, e.g.
pressureWorkAlphaLimit 1e-3;
which sets the pressure work term to 0 for phase-fractions below 1e-3.
On 64-bit systems, the system installations of boost, cgal are under
lib64/. The behaviour for a ThirdParty build is mostly lib/ but this
can also be changing.
Boost 1_62_0 and older build into 'lib/'.
CGAL-4.9 builds into 'lib64/', older versions into 'lib/'.
Future-proof things by using lib$WM_COMPILER_LIB_ARCH for boost and
cgal build rules, and forcing these as build targets in the ThirdParty
makeCGAL as well.
--
STYLE: check for boost/version.hpp, CGAL/version.h instead their directories
- was incorrectly writing it as "startFace", which would be
immediately overwritten anyhow
STYLE: avoid noisy output when adding the boundary 'type' in mesh conversion.
Note: classes are prefixed with 'foamVtk' instead of 'vtk' to avoid potential
conflicts with VTK itself.
foamVtkCore
~~~~~~~~~~~
- General very low-level functionality.
foamVtkPTraits
~~~~~~~~~~~~~~
- Traits type of functionality for VTK
foamVtkOutputOptions
~~~~~~~~~~~~~~~~~~~~
- The various format output options as a class that can be passed to
formatters etc.
foamVtkCells
~~~~~~~~~~~~
- Intended for unifying vtkTopo and PV-Reader code in the future.
- Handles polyhedron decompose internally etc
foamVtkOutput, foamVtkFormatter
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- Output helpers.
- Selector for individual formatters.
Currently write all scalar data a 'float' (not 'double'). Can
revisit this in the future.
Provide common face area/normal support in PrimitivePatch
For polyPatch, both the faceAreas() and faceCentres() are masked by their subField equivalents.
Since there is no polyPatch method for magFaceAreas(), the PrimitivePatch method will be seen.
See merge request !74
- In the corner case with few faces or points, the normal List I/O
results in a compact list representation.
This is less than desirable for external programs with simple
line-based parsers.
- Write exactly the following
*Faces*
// Patch: <word-Region> <word-Patch>
<int-nFaces>
(
<int-faceSize>(<int> .. <int>)
...
)
*Points*
// Patch: <word-Region> <word-Patch>
<int-nPoints>
(
(<float-x> <float-y> <float-z>)
...
)
STYLE: only use serial form of createExternalCoupledPatchGeometry in tutorial
- less confusing for the user, who wonders why it is being done twice.
New functionality contributed by Mattijs Janssens:
- new edge projection: projectCurve for use with new geometry
'searchableCurve'
- new tutorial 'pipe'
- naming of vertices and blocks (see pipe tutorial). Including back
substitution for error messages.
- Can currently have a periodic restart, but for simulations with a
known run-up, it can be useful to have a specific time to restart
the averaging.
- Note that the restartTime acts as a 'single-shot'. If the
restartTime is already in the past when a simulation is started, it
is ignored. If, during a simulation, the restartTime is crossed, it
will be triggered and then set itself to be ignored in the future.
- On the first call, ParaView_DIR is unset and thus the clean-path
fails with the warning "ParaView_DIR: Undefined variable."
This looks messy, but is of no _major_ consequence since paraview
doesn't need to be removed anyhow. The only slight risk is that the
path to a third-party cmake might not be cleaned.
- Patch as per Bruno's suggestion.
- It is incorrect to prefix the assignment with an 'export' since this
automatically marks the overall command as successful and circumvents
the fallback.
There is no simple way to have proper behaviour when sourced with a
local directory path, but at least it now uses the fallback.
It is still easy to wreak the mechanism with valid but confusing input.
For example,
". /path/to/openfoam/etc/././bashrc"
The only real certainty is that "${BASH_SOURCE%/*}"
should point to the 'etc/' directory. In which case,
cd ${BASH_SOURCE%/*} # <- now in the etc/ directory
pwd=$(pwd -P) # <- fully-qualified path to etc/
pwd=${pwd%/*/*} # <- up two parent levels
- This works with ". ./bashrc", but fails with ". bashrc"
(probably not so common).
- Con: The construct requires an additional sub-shell.
- include cleanup of other postProcessing directories:
* Ensight, EnSight, ensightWrite
- don't need to remove files that cleanSnappyFiles already removed:
* 0/cellLevel 0/pointLevel
- bundle removal of constant/ items together:
* constant/cellDecomposition constant/polyMesh constant/tetDualMesh
Previously the inlet flow of phase 1 (the phase solved for) is corrected
to match the inlet specification for that phase. However, if the second
phase is also constrained at inlets the inlet flux must also be
corrected to match the inlet specification.
- manifest in some parallel operations.
STYLE: update foamToEnsight, foamToEnsightParts to use C++ initializer_list
- avoid warning message when removing a non-existent directory (ensight output).
- In the foundation version they introduced a construct to handle
the transition from 'wmRefresh' as an alias to 'wmRefresh' as
a shell function. This transition is unnecessary for OpenFOAM+
since 1606 used wmREFRESH (not wmRefresh) as an alias.
For portability it is important to avoid this non-POSIX
"type -t". It causes issues with dash and with zsh
(mentioned in issue #277).
type -t dash -> -t: not found
type -t zsh -> zsh: bad option: -t
Note: zsh users may still noticed other problems.
For example, the POSIX 'unset -f' normally has no output, but in zsh
it reports an error and has exit code 1 if the function was not
previously defined. Whereas in POSIX (including bash, dash) it only
returns non-zero if the name(s) could not be unset.
- Cleanup/centralize handling of -decomposeParDict by relocating
common code into argList. Ensures that all processes receive
identical information about the -decomposeParDict opton.
- Only use alternative decomposeParDict for simpleFoam/motorBike
tutorial so that this will be included in the test loop for snappy.
- Added Mattijs' fix for surfaceRedistributePar.
- Also fixed bug noted in issue #269
- Previous implementation had all faces together, which made
it difficult (impossible) for external applications to
figure out which geometry was being referred to.
- Provide separate region/patches as follows:
// Patch: <regionName> <patchName>
For example,
// Group: coupleGroup
// Patch: heater minY
8( ... )
The region-name is always present, even if there is only one region.
- This change is a partial reversion to the behaviour in 2.4.x, except
that we can now also handle multi-region geometries.
Changing the leading comment from "# " to "// " facilitates parsing
of the files with OpenFOAM itself if necessary.
- make top-level Sf(), magSf(), Cf() pure virtual since the
sub-classes will always be providing the face/point storage,
with either triSurface or MeshedSurface in the background
* MeshedSurface / surfMesh / triSurface
- use shorter method names similar to those from volume meshes:
Sf(), magSf(), Cf()
instead of the longer ones from PrimitivePatch:
faceAreas(), magFaceAreas(), faceCentres()
- similar names throughout to ease switching between triSurface and
MeshedSurface storage.
Loop over the edges of each block rather than the edgeList of the
topological mesh due to problems with calcEdges for blocks with repeated
point labels
ENH: Support more C++11 initializer lists (issue #261)
DynamicList
-----------
- construction, assignment and append
HashSet
-------
- construction, insert, set.
- assignment will use the implicit List constructor
hashedWordList
--------------
- construction, assignment
- additional sort() and uniq() methods.
- Readonly access to HashTable information via lookup() method.
- NB: could avoid 'const char**' constructors in the future
Some tests are included
See merge request !67
DynamicList
-----------
- construction, assignment and append
HashSet
-------
- construction, insert, set.
- assignment will use the implicit List constructor
hashedWordList
--------------
- construction, assignment
- additional sort() and uniq() methods.
- Readonly access to HashTable information via lookup() method.
- NB: could avoid 'const char**' constructors in the future
- Write differences with respect to the specified dictionary
(or sub entry if -entry specified)
- Write the differences with respect to a template dictionary:
foamDictionary 0/U -diff $FOAM_ETC/templates/closedVolume/0/U
- Write the differences in boundaryField with respect to a
template dictionary:
foamDictionary 0/U -diff $FOAM_ETC/templates/closedVolume/0/U \
-entry boundaryField
Patch contributed by Mattijs Janssens
Patch contributed by Mattijs Janssens
- Added projected vertices
- Added projected edges
- Change of blockEdges API (operate on list lambdas)
- Change of blockFaces API (pass in blockDescriptor and blockFacei)
- Added sphere7ProjectedEdges tutorial to demonstrate vertex and edge projection
- Can occur with some user names, or mounted paths.
Resolve by using '?' for the separation character.
Since '?' is a shell-glob, it is highly unlikely to occur appear in
filenames. Additionally, it is not a meta-character in standard sed,
nor in the GNU extension (which uses '\?').
changed flag which caused infinite while loop. Background info:
- findCellZoneTopo tries to find for all named surface intersections
which side of the face is in the faceZone
- i.e. it tries to make the cellZone consistent with the faceZone
(to fix small problems)
- this had some logic to assign the neighbour cellZone to the owner cellZone
- which didn't check for the neighbour being the same value as the owner
- but still set a 'changed' flag which caused the loop to never end.
- Place common code under OSspecific.
By including "endian.H", either one of WM_BIG_ENDIAN or WM_LITTLE_ENDIAN
will be defined.
Provides inline 32-bit and 64-bit byte swap routines that can be
used/re-used elsewhere.
The inplace memory swaps currently used by the VTK output are left for
the moment pending further cleanup of that code.
For example, to mesh a sphere with a single block the geometry is defined in the
blockMeshDict as a searchableSurface:
geometry
{
sphere
{
type searchableSphere;
centre (0 0 0);
radius 1;
}
}
The vertices, block topology and curved edges are defined in the usual
way, for example
v 0.5773502;
mv -0.5773502;
a 0.7071067;
ma -0.7071067;
vertices
(
($mv $mv $mv)
( $v $mv $mv)
( $v $v $mv)
($mv $v $mv)
($mv $mv $v)
( $v $mv $v)
( $v $v $v)
($mv $v $v)
);
blocks
(
hex (0 1 2 3 4 5 6 7) (10 10 10) simpleGrading (1 1 1)
);
edges
(
arc 0 1 (0 $ma $ma)
arc 2 3 (0 $a $ma)
arc 6 7 (0 $a $a)
arc 4 5 (0 $ma $a)
arc 0 3 ($ma 0 $ma)
arc 1 2 ($a 0 $ma)
arc 5 6 ($a 0 $a)
arc 4 7 ($ma 0 $a)
arc 0 4 ($ma $ma 0)
arc 1 5 ($a $ma 0)
arc 2 6 ($a $a 0)
arc 3 7 ($ma $a 0)
);
which will produce a mesh in which the block edges conform to the sphere
but the faces of the block lie somewhere between the original cube and
the spherical surface which is a consequence of the edge-based
transfinite interpolation.
Now the projection of the block faces to the geometry specified above
can also be specified:
faces
(
project (0 4 7 3) sphere
project (2 6 5 1) sphere
project (1 5 4 0) sphere
project (3 7 6 2) sphere
project (0 3 2 1) sphere
project (4 5 6 7) sphere
);
which produces a mesh that actually conforms to the sphere.
See OpenFOAM-dev/tutorials/mesh/blockMesh/sphere
This functionality is experimental and will undergo further development
and generalization in the future to support more complex surfaces,
feature edge specification and extraction etc. Please get involved if
you would like to see blockMesh become a more flexible block-structured
mesher.
Henry G. Weller, CFD Direct.
Merge preconvert
Very basic cleanup of some of the mesh conversion infrastructure prior to binging in large pieces of code.
- Remove ancient samm, pro-am, prostar3 routines as being unused and unsupportable (since the original products ceased existence over 10 years ago).
- Open protected access to some meshReader bits, to help when implementing polyhedral readers.
- Drop meshReaders/meshWriters namespace, use fileFormats instead.
- Reorganize file-structure within src/conversion.
See merge request !69
- Use ensightCase for case writing.
Rebase ensightPartCells/ensightPartFaces on
ensightCells/ensightFaces routines.
- Greatly reduces code duplication potential source of errors.
to handle the size of bubbles created by boiling. To be used in
conjunction with the alphatWallBoilingWallFunction boundary condition.
The IATE variant of the wallBoiling tutorial case is provided to
demonstrate the functionality:
tutorials/multiphase/reactingTwoPhaseEulerFoam/RAS/wallBoilingIATE
- eliminate ensightAsciiStream, ensightBinaryStream, ensightStream in
favour of using ensightFile and ensightGeoFile classes throughout.
- encapsulate mesh-parts sorting with the ensightCells, ensightFaces
class.
- handle of patches/faceZones entirely within ensightMesh for a lighter
interaction with field output. Both faceZones and point fields need
more testing to see if they behave properly for all cases.
- move some output functionality into its own namespace
'ensightOutput', move into a library.
- use the ensightCase class to open new ensight output streams
in the proper sub-directory locations.
Output format
Output changes (issues #253 , #254 , #255 , #256) as well as minor change (issue #257).
Usage of the new methods to be applied as a later patch.
See merge request !65
Contributed by Juho Peltola, VTT
Notable changes:
1. The same wall function is now used for both phases, but user must
specify phaseType ‘liquid’ or ‘vapor’
2. Runtime selectable submodels for:
- wall heat flux partitioning between the phases
- nucleation site density
- bubble departure frequency
- bubble departure diameter
3. An additional iteration loop for the wall boiling model in case
the initial guess for the wall temperature proves to be poor.
The wallBoiling tutorial has been updated to demonstrate this new functionality.
ENH: wallDist - added option to evaluate every XXX steps
Added functionality to update the wall distance every XXX steps
Note: only applies to movePoints() - topology change bypasses the update interval and triggers a re-calculation
Syntax:
```
wallDist
{
method ...
updateInterval 5; // optional - default is 1
}
```
Test case: [mixerVesselAMI2D.tgz](/uploads/c0bee1decc0337018272f3566b6a4416/mixerVesselAMI2D.tgz)
See merge request !62
Writing an empty list in binary results in unnecessary newlines that
make the output 'noisier'.
Old output
~~~~~~~~~~
ASCII
someEmptyList___0();
Binary
someEmptyList___
0
;
Updated
~~~~~~~
ASCII
someEmptyList___0();
Binary
someEmptyList___0;
All of the access methods for autoPtr include validity checks and will
fail if the underlying point is NULL. In some cases, however, we'd
like to retain the automatic deletion mechanism, but still address a
nullptr. This is mostly for cases in which a file-stream should be
allocated, but only on the master process. For these cases we'd still
like to pass through and reference the underlying pointer (eg, to
obtain the correct method call) without tripping the pointer check
mechanism. If we attempt to use the ptr() method, the autoPtr memory
management is bypassed and we risk memory leaks.
Instead provide an alternative mechanism to obtain the raw underlying
pointers/references. Use rawPtr() and rawRef() for these potentially
useful, but also potentially dangerous, operations.
This supports the abstraction of the set of fields from the field code
generation macros making it easier to change the set of fields supported
by OpenFOAM. This functionality is demonstrated in the updated
fvPatchFields macros and will be applied to the rest of the field code
generation macros in the future.
- CGAL itself includes its library dependencies, we only need to
provide the -L... option to the proper ThirdParty locations.
Should help improve general build robustness.
- instead we use the CGAL settings directly since they have the
same option of (version | system | none)
- may wish to review this again in the future.
- Normally use '()' to deference. This has extra safety and issues a
fatal error if the underlying pointer is not valid.
However, in some cases we are happy with getting a null reference.
The refOrNull() method returns the reference without any checking.
Usage example:
autoPtr<OFstream> osPtr;
if (Pstream::master())
{
osPtr.reset(new OFstream(...));
}
writeViaMaster(osPtr.refOrNull());
- The writeViaMaster() call takes an OFstream reference,
but this is only used directly on the master.
The slaves will pass things through to the master.
- Some commonly used write methods that are independent of
the calling context (ie, 2D/3D data, geometry, fields)
- Provide singleton null() for ensightFile, ensightGeoFile.
Can be used for MPI slaves that need a file reference for their
methods, but will never write to it, but it is also reasonable
to use an autoPtr with rawRef() for that as well.
blockMesh -help
Usage: blockMesh [OPTIONS]
options:
-blockTopology write block edges and centres as .obj files
-case <dir> specify alternate case directory, default is the cwd
-dict <file> specify alternative dictionary for the blockMesh description
-noFunctionObjects
do not execute functionObjects
-region <name> specify alternative mesh region
-srcDoc display source code in browser
-doc display application documentation in browser
-help print the usage
Block description
For a given block, the correspondence between the ordering of
vertex labels and face labels is shown below.
For vertex numbering in the sequence 0 to 7 (block, centre):
faces 0 (f0) and 1 are left and right, respectively;
faces 2 and 3 are bottom and top;
and faces 4 and 5 are front the back:
4 ---- 5
f3 |\ |\ f5
| | 7 ---- 6 \
| 0 |--- 1 | \
| \| \| f4
f2 3 ---- 2
f0 ----- f1
Using: OpenFOAM-dev (see www.OpenFOAM.org)
Build: dev-dc59c63351e7
Patch contributed by Bruno Santos
Resolves bug-report http://bugs.openfoam.org/view.php?id=2267
1. Spaced ending of multi-level template parameters are not allowed, such as:
List<List<scalar> >
which instead should be:
List<List<scalar>>
2. The use of the 'NULL' macro should be replaced by 'nullptr'
to ensure 'patchType' is set as specified.
Required substantial change to the organization of the reading of the
'value' entry requiring careful testing and there may be some residual
issues remaining. Please report any problems with the reading and
initialization of patch fields.
Resolves bug-report http://bugs.openfoam.org/view.php?id=2266
e.g. for the cavity tutorial the moving wall patch can be specified in
terms of the block vertices as before:
boundary
(
movingWall
{
type wall;
faces
(
(3 7 6 2)
);
}
.
.
.
or the new specification of the face as block 0, block face 3:
boundary
(
movingWall
{
type wall;
faces
(
(0 3)
);
}
- Less looping when detecting lagrangian clouds and their fields.
- Avoid using Time::setTime() and IOobjectList in tight loops.
They both kill performance immensely.
ENH: provide a -noLagrangian option to foamToEnsight and foamToEnsightParts
for even more control.
- The new field needs initialization with a dimensioned<Type> not just
the dimensionSet.
- The new field was also incorrectly being registered, which could
cause issues later.
Old code:
Found 10990 time steps
Search for moving mesh ... no moving mesh detected.
Startup in 329.09 s
Updated:
Found 10990 time steps
Search for moving mesh ... no moving mesh detected.
Startup in 1.6 s
- Cause was checking "polyMesh/points" via an IOobject.
Short-circuit with a check for a polyMesh/ directory first.
Limit the check to the master-node as well to further reduce
load on the file-system.
------------------------------
ENH: improve per-step conversion times for foamToEnsight.
Old code:
Converting 11001 time steps
Time [0] = 0 Wrote in 1.53 s
Time [1] = 1 Wrote in 1.52 s
...
Time [100] = 100 Elapsed time 205.35 s
Updated:
Converting 11001 time steps
Time [0] = 0 Wrote in 1.4 s
Time [1] = 1 Wrote in 0.07 s
...
Time [100] = 100 Elapsed time 42.4 s
- Speedup by hashing test results from the first conversion step
instead of checking each time.
Check data on all nodes to avoid problems with incomplete writes.
------------------------------
BUG: moving mesh detection failed for foamToEnsightParts
- adjusted to agree with updated foamToEnsight
------------------------------
Note:
- foamToEnsightParts (serial) still has about twice the throughput of
foamToEnsight.
Renamed the original 'laminar' model to 'Stokes' to indicate it is a
linear stress model supporting both Newtonian and non-Newtonian
viscosity.
This general framework will support linear, non-linear, visco-elastic
etc. laminar transport models.
For backward compatibility the 'Stokes' laminar stress model can be
selected either the original 'laminar' 'simulationType'
specification in turbulenceProperties:
simulationType laminar;
or using the new more general 'laminarModel' specification:
simulationType laminar;
laminar
{
laminarModel Stokes;
}
which allows other laminar stress models to be selected.
Required to support LTS with the -postProcess option with sub-models dependent on ddt
terms during construction, in particular reactingTwoPhaseEulerFoam.
Individual inward-pointing faces are checked and if all faces are
inward-pointing the block is inside-out. These errors are fatal and the
message indicates which block the error occurs in and where in the
blockMeshDict the block is defined.
- bugfix (empty patches), and added detection of steady-state
scheme.
Caveat: when called via execFlowFunctionObjects will always produce a
zero field, since the oldTime field is not available for this mode.
Extrapolate internal field to walls for post-processing.
Uses as new syntax for handling the naming of multiple fields.
The input fields are selected via a wordReList.
For example,
fields (U "(T|k|epsilon|omega)");
The names of the resulting output fields use placeholder tokens for
flexibility. For example,
result zeroGradient(@@);
The '@@' placeholder is replaced by the name of the input field.
Eg,
fields (U T);
result zeroGradient(@@);
-> zeroGradient(U), zeroGradient(T)
Or,
fields (U T);
result @@nearWall;
-> UnearWall, TnearWall
NOTE:
The function object will skip over fields that only have
processor, empty, zeroGradient patches. The operation does not
make much sense for these, and it avoids inadvertently
re-processing fields twice.
- implemented using magSqr() instead of sqr().
For scalar fields they are the same, but can be useful
if this function object is extended for more field types.
- Default is a width of 8 characters, but this can be extended up to 31
characters via the '-width' command-line option.
- Now use a similar structure as foamToEnsightParts for the masking.
This reduces the clutter within the directory, makes it easier to
selectively delete some time steps (using shell commands).
- Added in a "time" information data in each sub-directory to
make it possible to reconstruct the case file with an external
script.
- Conversion of cloud data should now also work in parallel
(may need more testing).
- Support binary output for cloud data.
- Better avoidance of illegal ensight variable names.
But still partially incomplete (due to patch fields).
==================================================
Example of NEW file structure:
EnSight/verticalChannel.case # case name
EnSight/geometry # for non-moving geometry
EnSight/data/ # time-varying data
EnSight/data/00000000/
EnSight/data/00000001/
...
Fields are stored by name within the data/********/ directories:
EnSight/data/00000001/time # human-readable time info
EnSight/data/00000001/U
EnSight/data/00000001/p
...
EnSight/data/00000001/geometry # for moving geometry
Clouds are stored at the next sub-directory level:
EnSight/data/00000001/lagrangian/<cloudName>/positions
EnSight/data/00000001/lagrangian/<cloudName>/U
...
==================================================
The old structure was significantly more cluttered:
EnSight/verticalChannel.case
EnSight/verticalChannel.0000.mesh
EnSight/verticalChannel.0001.p
EnSight/verticalChannel.0001.<cloudName>
EnSight/verticalChannel.0001.<cloudName>.U
==================================================
Now the postProcess utility '-region' option works correctly, e.g. for
the chtMultiRegionSimpleFoam/heatExchanger case
postProcess -region air -func "mag(U)"
calculates 'mag(U)' for all the time steps in region 'air'.
using a run-time selectable preconditioner
References:
Van der Vorst, H. A. (1992).
Bi-CGSTAB: A fast and smoothly converging variant of Bi-CG
for the solution of nonsymmetric linear systems.
SIAM Journal on scientific and Statistical Computing, 13(2), 631-644.
Barrett, R., Berry, M. W., Chan, T. F., Demmel, J., Donato, J.,
Dongarra, J., Eijkhout, V., Pozo, R., Romine, C. & Van der Vorst, H.
(1994).
Templates for the solution of linear systems:
building blocks for iterative methods
(Vol. 43). Siam.
See also: https://en.wikipedia.org/wiki/Biconjugate_gradient_stabilized_method
Tests have shown that PBiCGStab with the DILU preconditioner is more
robust, reliable and shows faster convergence (~2x) than PBiCG with
DILU, in particular in parallel where PBiCG occasionally diverges.
This remarkable improvement over PBiCG prompted the update of all
tutorial cases currently using PBiCG to use PBiCGStab instead. If any
issues arise with this update please report on Mantis: http://bugs.openfoam.org
- There will be triangles rendered inside the mesh (when
surface-rendering), because one of the cell's triangles is defined
as a quadrangle in VTK_WEDGE.
- Therefore, this VTK_WEDGE representation is only used when
decomposing the mesh, otherwise the correct representation is done
by VTK_POLYHEDRON.
- Furthermore, using VTK_PYRAMID gave worse result, because it renders
2 triangles inside the mesh for the collapsed quadrangle, likely due
to mismatch with the adjacent cell's face.
- Using VTK_HEXAHEDRON was not tested in this iteration, given that it
should give even worse results, when compared to using VTK_PYRAMID.
Patch contributed by Bruno Santos
Resolves bug-report http://bugs.openfoam.org/view.php?id=2099
- "$FOAM_USER_APPBIN" and "$FOAM_USER_LIBBIN" have been added to
"foamOldDirs" in "etc/bashrc" and "etc/config.sh/unset"
- "$OPAL_PREFIX" is now undefined in the option "SYSTEMOPENMPI" within
"etc/config.sh/mpi", but only if the path defined in this variable
is cleaned when using "foamCleanPath".
- "$OPAL_PREFIX" is now also conditionally undefined in
"etc/config.sh/unset" when the path is picked up by "foamCleanPath".
Patch contributed by Bruno Santos
Resolved bug-report http://bugs.openfoam.org/view.php?id=2210
Description
An incompressible Casson non-Newtonian viscosity model.
References:
\verbatim
Casson, N. (1959).
Rheology of disperse systems.
In Proceedings of a Conference Organized by the
British Society of Rheology.
Pergamon Press, New York.
Fournier, R. L. (2011).
Basic transport phenomena in biomedical engineering.
CRC Press.
\endverbatim
Contributed by Sergey Sindeev
Description
Allows specification of different writing frequency of objects registered
to the database.
It has similar functionality as the main time database through the
\c writeControl setting:
- timeStep
- writeTime
- adjustableRunTime
- runTime
- clockTime
- cpuTime
It also has the ability to write the selected objects that were defined
with the respective write mode for the requested \c writeOption, namely:
- \c autoWrite - objects set to write at output time
- \c noWrite - objects set to not write by default
- \c anyWrite - any option of the previous two
Example of function object specification:
\verbatim
writeObjects1
{
type writeObjects;
libs ("libutilityFunctionObjects.so");
...
objects (obj1 obj2);
writeOption anyWrite;
}
\endverbatim
Patch contributed by Bruno Santos
Resolves bug-report http://bugs.openfoam.org/view.php?id=2090
Time: call functionObject 'execute()' and 'end()' for last time-step
Now the operation of functionObject 'end()' call is consistent between running and post-processing
Now the number of iterations to solve each component in a segregated
solution are stored and returned in the SolverPerformance class.
Resolves bug-report http://bugs.openfoam.org/view.php?id=2189
This was going wrong in a fair few cases where you would get regions which
were delimited by a combination of intersections with unnamed surfaces (wall)
and named surfaces (faceZone surface) but not with either of these sets
individually. This would cause there to be unvisited cells (zone = -2)
next to a visited cells but separated by a named surface only (and not an
unnamed surface). Fixed by using direct surface intersection in the removal
part. Related to #66.
Note that since these actually act more like 'patches'
(ie, contiguous addressing) it might be reasonable to rename as
surfPatchIdentifier / surfacePatchIdentifier
- For merging meshedSurf content from parallel sources.
Ensures zoneIds are properly preserved for sampling in parallel.
Current state
~~~~~~~~~~~~~
Current producers of the region information:
* sampledTriSurfaceMesh
Current consumers of the region information:
* nastran writer. The zone ids passed through as PSHELL Ids (with offset 1).
Limitations
The per-face region association is preserved, but the face/element
sort order gets lost in reconstruction. Would need to attach
additional information to the sampled surface and use that for
sorting, but this would also imply that sampled values be written
indirectly (or resorted) too to match the order. Zone ids are passed
through, but not their names. After reconstruction, zone ids are no
longer contiguous. Re-sorting (as mentioned above) would solve this
too, but again at the cost of more complexity when writing.
- Allows passing of additional information (per-face zone ids) or possibly
other things, while reducing the number of arguments to pass.
- In sampledTriSurfaceMesh, preserve the region information that was
read in, passing it onwards via the UnsortedMeshSurface content.
The Nastran surface writer is currently the only writer making use
of this per-face zone information.
Passing it through as a PSHELL attribute, which should retain the
distinction for parts. (issue #204)
- use surfFaces() to return the templated list of faces.
This frees up the method 'faces()' to be used as a virtual method,
which will be needed at a later stage.
Now the functionality to write single graph files or log files (vs time)
may be used in the creation of any form of functionObject, not just
those relating to a mesh region.
The change from C++0x to C++11 allows all of C++11 functionality to be
used in OpenFOAM, in particular constructor delegation which avoids code
duplication or constructor helper functions. However, this also means a
change to the minimum gcc version supported which is now 4.7 rather than
4.5.
Note that gcc-4.7 does not support the entire C++11 standard but does
support all of the functionality currently needed for further OpenFOAM
development. The minimum gcc-version which supports the entire C++11
standard is 4.8 which is now the recommended minimum gcc version.
The diameter of the drops formed are obtained from the local capillary
length multiplied by the \c dCoeff coefficient which defaults to 3.3.
Reference:
Lefebvre, A. (1988).
Atomization and sprays
(Vol. 1040, No. 2756). CRC press.
Changed default mode of operation to use standard y+ based switching
rather than the previous ad hoc blending and added consistent handling
of the near-wall generation term.
This boundary condition provides a wall constraint on turbulnce specific
dissipation, omega for both low and high Reynolds number turbulence models.
The near-wall omega may be either blended between the viscous region and
logarithmic region values using:
\f[
\omega = sqrt(\omega_{vis}^2 + \omega_{log}^2)
\f]
where
\vartable
\omega_{vis} | omega in viscous region
\omega_{log} | omega in logarithmic region
\endvartable
see eq.(15) of:
\verbatim
Menter, F., Esch, T.
"Elements of Industrial Heat Transfer Prediction"
16th Brazilian Congress of Mechanical Engineering (COBEM),
Nov. 2001
\endverbatim
or switched between these values based on the laminar-to-turbulent y+ value
derived from kappa and E. Recent tests have shown that the standard
switching method provides more accurate results for 10 < y+ < 30 when used
with high Reynolds number wall-functions and both methods provide accurate
results when used with continuous wall-functions. Based on this the
standard switching method is used by default.
This boundary condition provides a turbulence dissipation wall constraint
for low- and high-Reynolds number turbulence models.
The condition can be applied to wall boundaries for which it
- calculates \c epsilon and \c G
- specifies the near-wall epsilon value
where
\vartable
epsilon | turblence dissipation field
G | turblence generation field
\endvartable
The model switches between laminar and turbulent functions based on the
laminar-to-turbulent y+ value derived from kappa and E.
Recent tests have shown that this formulation is more accurate than
the standard high-Reynolds number form for 10 < y+ < 30 with both
standard and continuous wall-functions.
Replaces epsilonLowReWallFunction and should be used for all
low-Reynolds number models for which the epsilonLowReWallFunction BC was
recommended.
of film flow on an inclined plane by Brun et.al.
Brun, P. T., Damiano, A., Rieu, P., Balestra, G., & Gallaire, F. (2015).
Rayleigh-Taylor instability under an inclined plane.
Physics of Fluids (1994-present), 27(8), 084107.
Until C++ supports 'concepts' the only way to support construction from
two iterators is to provide a constructor of the form:
template<class InputIterator>
List(InputIterator first, InputIterator last);
which for some types conflicts with
//- Construct with given size and value for all elements
List(const label, const T&);
e.g. to construct a list of 5 scalars initialized to 0:
List<scalar> sl(5, 0);
causes a conflict because the initialization type is 'int' rather than
'scalar'. This conflict may be resolved by specifying the type of the
initialization value:
List<scalar> sl(5, scalar(0));
The new initializer list contructor provides a convenient and efficient alternative
to using 'IStringStream' to provide an initial list of values:
List<vector> list4(IStringStream("((0 1 2) (3 4 5) (6 7 8))")());
or
List<vector> list4
{
vector(0, 1, 2),
vector(3, 4, 5),
vector(6, 7, 8)
};
- previously just detected the presence of "processor" in the case
path name. Restrict to checking the final portion.
Does not solve all problems, but solves ones like this:
test-new-processor-generation/....
References:
Savill, A. M. (1993).
Some recent progress in the turbulence modelling of by-pass transition.
Near-wall turbulent flows, 829-848.
Savill, A. M. (1996).
One-point closures applied to transition.
In Turbulence and transition modelling (pp. 233-268).
Springer Netherlands.
Based on case contributed by Florian Schwertfirm, Kreuzinger und Manhart Turbulenz GmbH.
Description
Langtry-Menter 4-equation transitional SST model
based on the k-omega-SST RAS model.
References:
Langtry, R. B., & Menter, F. R. (2009).
Correlation-based transition modeling for unstructured parallelized
computational fluid dynamics codes.
AIAA journal, 47(12), 2894-2906.
Menter, F. R., Langtry, R., & Volker, S. (2006).
Transition modelling for general purpose CFD codes.
Flow, turbulence and combustion, 77(1-4), 277-303.
Langtry, R. B. (2006).
A correlation-based transition model using local variables for
unstructured parallelized CFD codes.
Phd. Thesis, Universität Stuttgart.
Implemented by Henry G. Weller, CFD Direct in collaboration with Florian
Schwertfirm, Kreuzinger und Manhart Turbulenz GmbH.
ENH: distinguish OpenFOAM version for user-coding (fixes#195)
The pre-processor macro 'OPENFOAM_PLUS' is defined with a numerical
value equal to the currently compatible version number.
This can be used judiciously within user coding to help with minor
differences between OpenFOAM versions. For example,
#ifdef OPENFOAM_PLUS
#if (OPENFOAM_PLUS >= 1612)
...
#endif
#endif
or simply
#if (OPENFOAM_PLUS >= 1612)
...
#endif
See merge request !56
replace system() call with vfork/exec combination (issue #185)
Tested systemCall function object, dynamicCode, but should be rechecked with IB+openmpi
@Prashant
See merge request !55
ENH: OSspecific - softlink handling (fixes#164)
Links are followed in most cases, with some notable exceptions:
- mv, mvBak:
renames the link, not the underlying file/directory
- rmDir:
remove the symlink to a directory, does not recurse into the
underlying directory
See merge request !51
The pre-processor macro 'OPENFOAM_PLUS' is defined with a numerical
value equal to the currently compatible version number.
This can be used judiciously within user coding to help with minor
differences between OpenFOAM versions. For example,
#ifdef OPENFOAM_PLUS
#if (OPENFOAM_PLUS >= 1612)
...
#endif
#endif
or simply
#if (OPENFOAM_PLUS >= 1612)
...
#endif
- the checking for point-connected multiple-regions now also writes the
conflicting points to a pointSet
- with the -writeSets option it now also reconstructs & writes pointSets
so will be out of date (w.r.t bounding box, subdivisions) when the mesh moves.
Only when all cells stays in all the same boxes can you skip rebuilding it
so this was not deemed worthwhile. Fixes#172
STYLE/ENH: reduce code duplication for coded boundary conditions (issue #184)
- relocate common dictionary output into codedBase class
@Mattijs please test with a few examples as well
See merge request !54
rather than being calculated on construction and stored as member data.
The convergence warning has be replaced with the 'convergence()' member
function which returns 'true' if the SVD iteration converged, otherwise 'false'.
The normal library system() command uses 'fork', which causes
problems on IB+OPENMPI.
STYLE: add Foam:: qualifier to system calls to make them easier to spot.
Provides efficient integration of complex laminar reaction chemistry,
combining the advantages of automatic dynamic specie and reaction
reduction with ISAT (in situ adaptive tabulation). The advantages grow
as the complexity of the chemistry increases.
References:
Contino, F., Jeanmart, H., Lucchini, T., & D’Errico, G. (2011).
Coupling of in situ adaptive tabulation and dynamic adaptive chemistry:
An effective method for solving combustion in engine simulations.
Proceedings of the Combustion Institute, 33(2), 3057-3064.
Contino, F., Lucchini, T., D'Errico, G., Duynslaegher, C.,
Dias, V., & Jeanmart, H. (2012).
Simulations of advanced combustion modes using detailed chemistry
combined with tabulation and mechanism reduction techniques.
SAE International Journal of Engines,
5(2012-01-0145), 185-196.
Contino, F., Foucher, F., Dagaut, P., Lucchini, T., D’Errico, G., &
Mounaïm-Rousselle, C. (2013).
Experimental and numerical analysis of nitric oxide effect on the
ignition of iso-octane in a single cylinder HCCI engine.
Combustion and Flame, 160(8), 1476-1483.
Contino, F., Masurier, J. B., Foucher, F., Lucchini, T., D’Errico, G., &
Dagaut, P. (2014).
CFD simulations using the TDAC method to model iso-octane combustion
for a large range of ozone seeding and temperature conditions
in a single cylinder HCCI engine.
Fuel, 137, 179-184.
Two tutorial cases are currently provided:
+ tutorials/combustion/chemFoam/ic8h18_TDAC
+ tutorials/combustion/reactingFoam/laminar/counterFlowFlame2D_GRI_TDAC
the first of which clearly demonstrates the advantage of dynamic
adaptive chemistry providing ~10x speedup,
the second demonstrates ISAT on the modest complex GRI mechanisms for
methane combustion, providing a speedup of ~4x.
More tutorials demonstrating TDAC on more complex mechanisms and cases
will be provided soon in addition to documentation for the operation and
settings of TDAC. Also further updates to the TDAC code to improve
consistency and integration with the rest of OpenFOAM and further
optimize operation can be expected.
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.
Implementation updated, optimized and integrated into OpenFOAM-dev by
Henry G. Weller, CFD Direct Ltd with the help of Francesco Contino.
- export/setenv WM_COMPILER_TYPE as suggested by Mattijs.
- for overall consistency, don't carp about an unset WM_COMPILER_TYPE,
since this would only be on the first instance (prior to the
export/setenv) and would be confusing about why/when this message
may occur.
- reduce clutter: only use (system|ThirdParty) for WM_COMPILER_TYPE.
Drop the old 'OpenFOAM' setting for WM_COMPILER_TYPE, which was
transitional in early 2011.
- make the error messages more meaningful
- remove old VTK_CONVEX_POINT_SET code, since VTK_POLYHEDRON exists
since several years
ENH: improve robustness of paraFoam script
- only check the relevant plugin types,
fallback to native reader if needed/possible.
- return 0 if not under git, since nothing particular can be said
about the build number.
- explicitly define which git-dir is to be used.
This ensure we don't accidentally get some values from some unrelated
project in the parent directory.
Note: this reuses the existing storage rather than costly reallocation
which requires the initial allocation to be sufficient for the largest
size the ODE system might have. Attempt to set a size larger than the
initial size is a fatal error.
e.g. to avoid excessive unphysical velocities generated during slamming events in
incompressible VoF simulations
Usage
Example usage:
limitU
{
type limitVelocity;
active yes;
limitVelocityCoeffs
{
selectionMode all;
max 100;
}
}
Contributed by Alberto Passalacqua, Iowa State University
Foam::dragModels::Beetstra
Drag model of Beetstra et al. for monodisperse gas-particle flows obtained
with direct numerical simulations with the Lattice-Boltzmann method and
accounting for the effect of particle ensembles.
Reference:
\verbatim
Beetstra, R., van der Hoef, M. A., & Kuipers, J. a. M. (2007).
Drag force of intermediate Reynolds number flow past mono- and
bidisperse arrays of spheres.
AIChE Journal, 53(2), 489–501.
\endverbatim
Foam::dragModels::Tenneti
Drag model of Tenneti et al. for monodisperse gas-particle flows obtained
with particle-resolved direct numerical simulations and accounting for the
effect of particle ensembles.
Reference:
\verbatim
Tenneti, S., Garg, R., & Subramaniam, S. (2011).
Drag law for monodisperse gas–solid systems using particle-resolved
direct numerical simulation of flow past fixed assemblies of spheres.
International Journal of Multiphase Flow, 37(9), 1072–1092.
\verbatim
and added support for queue scheduling option '-q', '-queue'
Now the 'Allwmake' scripts execute 'wmake -all' to handle parallel
processing in a general way, avoiding code duplication.
wmakeCollect collects the compilation commands for the all of the object
files to be compiled into a single makefile which is passed to make to
schedule the compilations in parallel efficiently.
Before wmakeCollect can be called the lnInclude directories must be
up-to-date and after wmakeCollect the linkage stage of the compilation
must executed using wmake.
This entire process is now handled by wmake using the new '-queue' or
'-q' option to compile sections of the OpenFOAM source tree or the
entire tree efficiently. The number of cores the compilation executes
on may be specified either using the WM_NCOMPPROCS variable or the '-j'
option.
To efficiently compile OpenFOAM after a 'git pull' the '-update' option
is provided which updates lnInclude directories, dep files and removes
deprecated files and directories. This option may be used with '-q':
wmake -q -update
- there are some cases in which the C-style sprintf is much more
convenient, albeit problematic for buffer overwrites.
Provide a formatting version of Foam::name() for language
primitives that is buffer-safe.
Returns a Foam::word, so that further output will be unquoted, but
without any checking that the characters are indeed entirely valid
word characters.
Example use,
i = 1234;
s = Foam::name("%08d", i);
produces '00001234'
Alternative using string streams:
std::ostringstream buf;
buf.fill('0');
buf << setw(8) << i;
s = buf.str();
Note that the format specification can also be slightly more complex:
Foam::name("output%08d.vtk", i);
Foam::name("timing=%.2fs", time);
It remains the caller's responsibility to ensure that the format mask
is valid.
- similar to foamToEnsightParts, provide a data/ subdirectory to hold
the time-varying field information (collated output only).
- widen data mask to avoid possible overflows with many time steps
- ensight does supports geometry in a separate file, but for the
surface writer we claim that this is not true. This allows
the field writers to control where the mesh/case files land.
With 'true', the uncollated output would incidentally create
things like this:
Previous (w/ fields) | Now (w/ fields)
----------------------------+----------------------
0.05/surf.case |
0.05/surf.mesh |
0.05/p/surf.case | 0.05/p/surf.case
0.05/p/surf.mesh | 0.05/p/surf.mesh
0.05/p/surf.0000.p | 0.05/p/surf.0000.p
Previous (w/o fields) | Now (w/o fields)
----------------------------+----------------------
0.05/surf.case | 0.05/surf.mesh
0.05/surf.case | 0.05/surf.mesh
Move the separateGeometry() flag to the *.C code, where it is less
likely to be mistakenly altered.
Reference:
Poletto, R., Craft, T., and Revell, A.,
"A New Divergence Free Synthetic Eddy Method for the
Reproduction of Inlet Flow Conditions for LES",
Flow Turbulence Combust (2013) 91:519-539
If a side is not yet assigned to a cellZone (but the neighbour is)
and the surface is not related to a faceZone, assign the neighbour cellZone.
Fixes#156
mapNearestAMI: move normalisation to AMIMethod.
Avoids cells shared among processors to be counted multiple times and having
weights > 1.
See merge request !37
- patchFields now get mapped (instead of created)
- with -consistent it now maps all patches except for processor ones (they are
the only ones that are processor-local)
- all constraint patches get evaluated after mapping to bring them up to date.
Patch contributed by Mattijs Janssens
- value corresponds to the max memory when the corresponding profiling
is started.
Only used when the top-level profiling has memInfo active.
- memInfo is disabled by default, since the new maxMem functionality
otherwise adds overhead with every call.
tutorial:
/lagrangian/reactingParcelFoam/verticalChannelLTS
since growing single cells just makes the zoneing inconsistent with the
surface intersections (so you don't have a patch when converting surface
intersections to baffles)
- this option overrides any controlDict settings as a convenient means
to selecting profiling without messing with the controlDict.
- provide Profiling::writeNow() to emit profiling for utilities that
don't have any natural time increment mechanism to trigger it.
- move unset mpi buffer size from config.csh/settings -> config.csh/mpi
- wmUNSET now also unalias wmREFRESH
Note: unsetenv WM_COMPILER_TYPE in csh variant?
- drop reference to paraview-3 in config files.
Cannot say anything definite about support for versions
this old (2012)
- replace with an alternative workaround.
Unset the _foamAddLib function prior to sourcing config.sh/CGAL:
- LD_LIBRARY_PATH will not be adjusted.
- cgal_version/boost_version variables will be retained.
Note: for ThirdParty builds, it is important that the boost and CGAL
paths are added into LD_LIBRARY_PATH even if before they are created.
This ensures that the OpenFOAM environment is functional after the
build.
The '*-none' and '*-system' specifications can still be used to avoid
setting them at all.
dictionary files of a particular name and extracts entries of a
particular keyword, sorting results into a unique list.
For example,
foamSearch $FOAM_TUTORIALS laplacianSchemes.default fvSchemes
produces...
default Gauss linear corrected;
default Gauss linear limited corrected 0.33;
default Gauss linear limited corrected 0.5;
default Gauss linear orthogonal;
default Gauss linear uncorrected;
default none;
Uses the fantastic foamDictionary utility.
- although the build is not 100% complete, it is only the run-time
post-processing with VTK that is affected.
- improve robustness and warning messages
COMP: adjust build order (solvers, utilities)
- as per http://bugs.openfoam.org/view.php?id=2116
- not previously possible to configure a third-party gcc
with system gmp/mpfr/mpc.
This makes it easier to switch between compilers for testing.
- use system libraries by default
Description
Constrain the field values within a specified region.
For example to set the turbulence properties within a porous region:
\verbatim
porosityTurbulence
{
type scalarFixedValueConstraint;
active yes;
scalarFixedValueConstraintCoeffs
{
selectionMode cellZone;
cellZone porosity;
fieldValues
{
k 30.7;
epsilon 1.5;
}
}
}
\endverbatim
See tutorials/compressible/rhoSimpleFoam/angledDuctExplicitFixedCoeff
constant/fvOptions for an example of this fvOption in action.
The modes of operation are set by the dimensions of the pressure field
to which this boundary condition is applied, the \c psi entry and the value
of \c gamma:
\table
Mode | dimensions | psi | gamma
incompressible subsonic | p/rho | |
compressible subsonic | p | none |
compressible transonic | p | psi | 1
compressible supersonic | p | psi | > 1
\endtable
For most applications the totalPressure boundary condition now only
requires p0 to be specified e.g.
outlet
{
type totalPressure;
p0 uniform 1e5;
}
- Translate a list of C++ strings into C-style (argc, argv) pair.
- Translate C-style (argc, argv) pair to list of C++ strings.
Useful when interfacing to external C-code and some libraries
- basic cpuInfo (model identification, MHz, etc)
- process memInfo
- profiling is activated via the case system/controlDict by
adding a "profiling" sub-dictionary.
Simply add the following (everything enabled):
profiling
{}
Which corresponds to the longer form:
profiling
{
active true; // default: true
cpuInfo true; // default: true
memInfo true; // default: true
sysInfo true; // default: true
}
This can be used to selectively disable any extra information
(eg, you don't want anyone else to know what hardware was used).
BUG: cyclicACMI: make conservative and remove faceAreas0
Need to review cyclicACMI patch non-overlap values
- values here preserve initial values only
- snGrad - used?
- wall functions - no longer call updateCoeffs with ACMI weights (?)
See merge request !46
The problem was the demand-loading of the functionObjectProperties
IOdictionary which can cause parallel communication (if timeStampMaster
it scatters the headerOk status). So call setProperty on all processors!
Fixes#118.
updateCoeffs(const scalarField&) -> updateWeightedCoeffs(const scalarField&)
to avoid confusion with other specialized forms of updateCoeffs.
Patch contributed by Mattijs Janssens
Added the option '-subDict' to specify a sub-dictionary if multiple
replacement sets are present in the same file. This also provides
backward compatibility by setting '-subDict dictionaryReplacement'
Usage: foamList [OPTIONS]
options:
-case <dir> specify alternate case directory, default is the cwd
-compressibleTurbulenceModels
List compressible turbulenceModels
-functionObjects List functionObjects
-fvOptions List fvOptions
-incompressibleTurbulenceModels
List incompressible turbulenceModels
-noFunctionObjects
do not execute functionObjects
-registeredSwitches
List switches registered for run-time modification
-scalarBCs List scalar field boundary conditions (fvPatchField<scalar>)
-switches List switches declared in libraries but not set in
etc/controlDict
-unset List switches declared in libraries but not set in
etc/controlDict
-vectorBCs List vector field boundary conditions (fvPatchField<vector>)
-srcDoc display source code in browser
-doc display application documentation in browser
-help print the usage
Usage: foamList [OPTIONS]
options:
-case <dir> specify alternate case directory, default is the cwd
-compressibleTurbulenceModels
List compressible turbulenceModels
-functionObjects List functionObjects
-fvOptions List fvOptions
-incompressibleTurbulenceModels
List incompressible turbulenceModels
-noFunctionObjects
do not execute functionObjects
-registeredSwitches
List switches registered for run-time modification
-switches List switches declared in libraries but not set in
etc/controlDict
-unset List switches declared in libraries but not set in
etc/controlDict
-srcDoc display source code in browser
-doc display application documentation in browser
-help print the usage
To re-use existing 'sampleDict' files simply add the following entries:
type sets;
libs ("libsampling.so");
and run
postProcess -func sampleDict
It is probably better to also rename 'sampleDict' -> 'sample' and then run
postProcess -func sampleDict
This is a bit complicated. When allocating cells to zones
(meshRefinementBaffles::zonify) in finishes with findCellTopo which
tried to fix the odd cell which wasn't put into the correct region. This
was actually modifying whole regions to be a certain cellZone so if
there was some 'bleeding' it would re-assign a whole region to be e.g.
background and get deleted. Instead it now will only reassign single
cells if these are
- unassigned
- inbetween multiple, differing cellZones
Fixes the simpleFoam/rotorDisk meshing (gitlab #141)
- cyclicACMIFvPatchField::updateCoeffs() now again redirects to
fvPatchField::updateCoeffs(const scalarField& weights);
- which redirects to fvPatchField::updateCoeffs();
- except on wall functions where the weights are used to switch off
turbulence generation
- renamed the updateCoeffs on the fixedFluxPressure bc to updateSnGrad.
Replaced the 'postProcess' argument to the 'write' and 'execute'
functions with the single static member 'postProcess' in the
functionObject base-class.
The use of the term 'source' in the context of post-processing is
confusing and does not properly describe the process of region
selection. The new names 'surfaceRegion' and 'volRegion' better
describe the purpose of the functionObjects which is to provide field
processing functionality limited to a specified region of space, either
a surface or volume.
The keyword 'source' is renamed 'regionType' which better describes the
purpose which is to specify the method by which the surface or volume
region is selected.
The keyword to select the name of the surface or volume region is
renamed from 'sourceName' to 'name' consistent with the other
name-changes above.
In parallel the sets are reconstructed. e.g.
mpirun -np 6 checkMesh -parallel -allGeometry -allTopology -writeSets vtk
will create a postProcessing/ folder with the vtk files of the
(reconstructed) faceSets and cellSets.
Also improved analysis of disconnected regions now also checks for point
connectivity with is useful for detecting if AMI regions have duplicate
points.
Patch contributed by Mattijs Janssens
- Introduce dictionary::writeEntries for better code-reuse.
Before
======
os << nl << indent << "name";
dict.write(os);
After
=====
dict.write(os, "name");
Feature mppic inter foam
New MPPICInterFoam solver. Add MPPIC cloud to a VOF approach. Particles volume are considered into transport Eq fluxes.
Solves for 2 incompressible, isothermal immiscible fluids using a VOF
(volume of fluid) phase-fraction based interface capturing approach.
The momentum and other fluid properties are of the "mixture" and a single
momentum equation is solved.
Solver:
/applications/solvers/multiphase/MPPICInterFoam
Tutorial:
/tutorials/multiphase/MPPICInterFoam/twoPhasePachuka
See merge request !41
ENH: Adding interCondensingEvaporatingFoam and tutorial
Solver for 2 incompressible, isothermal immiscible fluids using a VOF
(volume of fluid) phase-fraction based interface capturing approach.
The momentum and other fluid properties are of the "mixture" and a single
momentum equation is solved.
Solver:
/applications/solvers/multiphase/interCondensingEvaporatingFoam
Tutorial:
/tutorials/multiphase/interCondensingEvaporatingFoam/condensatingVessel
See merge request !43
- most notably the '%' which is used as a separator in places
caused problems.
EHN: only use valid ensight file/variable names for writers
- fixed: foamToEnsightParts, ensightSurfaceWriter
- pending: foamToEnsight
BUG: no geometry written for foamToEnsightParts with moving mesh (fixes#142)
- an incorrect path was causing the issue
FOAM_INST_DIR is the location of the OpenFOAM installation which defaults to
the directory containing the etc/bashrc,cshrc file. If this default is
not appropriate FOAM_INST_DIR can be set explicitly.
- Include newline in beginBlock/endBlock, since this corresponds to
the standard usage. The beginBlock now takes keyType instead of word.
- Provide Ostream::writeEntry method to reduce clutter and simplify
writing of entries.
Before
======
os << indent << "name" << nl
<< indent << token::BEGIN_BLOCK << incrIndent << nl;
os.writeKeyword("key1") << val1 << token::END_STATEMENT << nl;
os.writeKeyword("key2") << val2 << token::END_STATEMENT << nl;
os << decrIndent << indent << token::END_BLOCK << nl;
After
=====
os.beginBlock("name");
os.writeEntry("key1", val1);
os.writeEntry("key2", val2);
os.endBlock();
- For completeness, support inline use of various Ostream methods.
For example,
os << beginBlock;
os.writeEntry("key1", val1);
os.writeEntry("key2", val2);
os << endBlock;
- For those who wish to write in long form, can also use endEntry inline:
os.beginBlock("name");
os.writeKeyword("key1") << val2 << endEntry;
os.writeKeyword("key2") << val2 << endEntry;
os.endBlock();
The endEntry encapsulates a semi-colon, newline combination.
Description
Implementation of the k-omega-SST-DES turbulence model for
incompressible and compressible flows.
DES model described in:
\verbatim
Menter, F. R., Kuntz, M., and Langtry, R. (2003).
Ten Years of Industrial Experience with the SST Turbulence Model.
Turbulence, Heat and Mass Transfer 4, ed: K. Hanjalic, Y. Nagano,
& M. Tummers, Begell House, Inc., 625 - 632.
\endverbatim
Optional support for zonal filtering based on F1 or F2 is provided as
described in the paper.
For further details of the implementation of the base k-omega-SST model
see Foam::kOmegaSST.
The DES coefficient 'CDES' defaults to 0.61 but may be changed as
necessary.
The zonal filter filter defaults to '2' which uses "(1 - F2)" as
suggested in the paper but '0' (no filtering) and '1' which uses
"(1 - F1)" are also supported.
Replaces the dictionary access functionality of foamInfoExec and
provides additional options to edit individual entries.
Contributed by Mattijs Janssens
reactionSensitivityAnalysis FO
This function object creates four data files named:
"consumption" : consumption rate
"production" : destruction rate
"productionInt" : integral between dumps of the production rate
"consumptionInt" : integral between dumps of the consumption rate
The function object indicates reaction rates of creation or destruction of species in each reaction.
code:
src/postProcessing/functionObjects/utilities/reactionSensitivityAnalysis/
tutorial:
/tutorials/combustion/chemFoam/gri
The output format file is (consumption.dat):
time : 1e-2
dellat T: 1e-5
Reaction specie1 specie2 ....
1 RR11 RR12
2 RR21 RR22
.
.
See merge request !44
Feature lagrangian
Minor adjustments to static information attached to lagrangian parcels/particles.
Fixes#108 (duplicate of http://www.openfoam.org/mantisbt/view.php?id=1990), #109, #110, #111.
Future reworking would require a better mechanism to also deal with dynamic information such as particle collisions etc.
See merge request !34
ENH: Update tutorial for features directionalPressureGradient, Global file handling
- Activate directionalPressureGradient source
- Check for Global/Share file handling
See merge request !45
- The only reasonable means of mirroring the data layout.
The '{}' delimiters mark the extent of the binary writes.
The primitives 'label' and 'scalar' are directly supported and correspond
to known byte widths.
Using "List<scalar>" was a bad choice, since this triggers unpleasant
tokenizing behaviour. Instead use 'scalars' as a provisional placeholder
to indicates a list of scalar values. However, there is currently no
support for actually handling lists of scalars, for several reasons:
* The information is not available at compile-time.
The cloud or parcel must be queried. And it must be guaranteed
that this value is consistent for the entire cloud.
* Binary output of lists is currently not great for determining the
the encoded width:
- A zero-size list is a single '0'.
- The leading size is a non-constant number of digits.
- There are prefix/suffix newlines need to be tagged and
skipped.
The special '*' (glob) token indicates that the remaining content
has a dynamic variable length and nothing reasonable can be known
about their sizes. This is exemplified by the collision records.
- only affects transfer of C-style string with a single character
remaining after whitespace stripping. Test added into Test-parallel.
- Note some idiosyncrasies in the behaviour:
send | receives
-------------------------+-------------------------
string("a b c") | string "a b c"
string("a") | string "a"
"a b c" | word "abc"
'd' | char 'd'
"d" | char 'd'
"d " | char 'd'
e.g.
functions
{
#includeFunc mag(U)
}
executes 'mag' on the field 'U' writing the field 'mag(U)'.
The equivalent post-processing command is
postProcess -func 'mag(U)'
with the more general and flexible 'postProcess' utility and '-postProcess' solver option
Rationale
---------
Both the 'postProcess' utility and '-postProcess' solver option use the
same extensive set of functionObjects available for data-processing
during the run avoiding the substantial code duplication necessary for
the 'foamCalc' and 'postCalc' utilities and simplifying maintenance.
Additionally consistency is guaranteed between solver data processing
and post-processing.
The functionObjects have been substantially re-written and generalized
to simplify development and encourage contribution.
Configuration
-------------
An extensive set of simple functionObject configuration files are
provided in
OpenFOAM-dev/etc/caseDicts/postProcessing
and more will be added in the future. These can either be copied into
'<case>/system' directory and included into the 'controlDict.functions'
sub-dictionary or included directly from 'etc/caseDicts/postProcessing'
using the '#includeEtc' directive or the new and more convenient
'#includeFunc' directive which searches the
'<etc>/caseDicts/postProcessing' directories for the selected
functionObject, e.g.
functions
{
#includeFunc Q
#includeFunc Lambda2
}
'#includeFunc' first searches the '<case>/system' directory in case
there is a local configuration.
Description of #includeFunc
---------------------------
Specify a functionObject dictionary file to include, expects the
functionObject name to follow (without quotes).
Search for functionObject dictionary file in
user/group/shipped directories.
The search scheme allows for version-specific and
version-independent files using the following hierarchy:
- \b user settings:
- ~/.OpenFOAM/\<VERSION\>/caseDicts/postProcessing
- ~/.OpenFOAM/caseDicts/postProcessing
- \b group (site) settings (when $WM_PROJECT_SITE is set):
- $WM_PROJECT_SITE/\<VERSION\>/caseDicts/postProcessing
- $WM_PROJECT_SITE/caseDicts/postProcessing
- \b group (site) settings (when $WM_PROJECT_SITE is not set):
- $WM_PROJECT_INST_DIR/site/\<VERSION\>/caseDicts/postProcessing
- $WM_PROJECT_INST_DIR/site/caseDicts/postProcessing
- \b other (shipped) settings:
- $WM_PROJECT_DIR/etc/caseDicts/postProcessing
An example of the \c \#includeFunc directive:
\verbatim
#includeFunc <funcName>
\endverbatim
postProcess
-----------
The 'postProcess' utility and '-postProcess' solver option provide the
same set of controls to execute functionObjects after the run either by
reading a specified set of fields to process in the case of
'postProcess' or by reading all fields and models required to start the
run in the case of '-postProcess' for each selected time:
postProcess -help
Usage: postProcess [OPTIONS]
options:
-case <dir> specify alternate case directory, default is the cwd
-constant include the 'constant/' dir in the times list
-dict <file> read control dictionary from specified location
-field <name> specify the name of the field to be processed, e.g. U
-fields <list> specify a list of fields to be processed, e.g. '(U T p)' -
regular expressions not currently supported
-func <name> specify the name of the functionObject to execute, e.g. Q
-funcs <list> specify the names of the functionObjects to execute, e.g.
'(Q div(U))'
-latestTime select the latest time
-newTimes select the new times
-noFunctionObjects
do not execute functionObjects
-noZero exclude the '0/' dir from the times list, has precedence
over the -withZero option
-parallel run in parallel
-region <name> specify alternative mesh region
-roots <(dir1 .. dirN)>
slave root directories for distributed running
-time <ranges> comma-separated time ranges - eg, ':10,20,40:70,1000:'
-srcDoc display source code in browser
-doc display application documentation in browser
-help print the usage
pimpleFoam -postProcess -help
Usage: pimpleFoam [OPTIONS]
options:
-case <dir> specify alternate case directory, default is the cwd
-constant include the 'constant/' dir in the times list
-dict <file> read control dictionary from specified location
-field <name> specify the name of the field to be processed, e.g. U
-fields <list> specify a list of fields to be processed, e.g. '(U T p)' -
regular expressions not currently supported
-func <name> specify the name of the functionObject to execute, e.g. Q
-funcs <list> specify the names of the functionObjects to execute, e.g.
'(Q div(U))'
-latestTime select the latest time
-newTimes select the new times
-noFunctionObjects
do not execute functionObjects
-noZero exclude the '0/' dir from the times list, has precedence
over the -withZero option
-parallel run in parallel
-postProcess Execute functionObjects only
-region <name> specify alternative mesh region
-roots <(dir1 .. dirN)>
slave root directories for distributed running
-time <ranges> comma-separated time ranges - eg, ':10,20,40:70,1000:'
-srcDoc display source code in browser
-doc display application documentation in browser
-help print the usage
The functionObjects to execute may be specified on the command-line
using the '-func' option for a single functionObject or '-funcs' for a
list, e.g.
postProcess -func Q
postProcess -funcs '(div(U) div(phi))'
In the case of 'Q' the default field to process is 'U' which is
specified in and read from the configuration file but this may be
overridden thus:
postProcess -func 'Q(Ua)'
as is done in the example above to calculate the two forms of the divergence of
the velocity field. Additional fields which the functionObjects may depend on
can be specified using the '-field' or '-fields' options.
The 'postProcess' utility can only be used to execute functionObjects which
process fields present in the time directories. However, functionObjects which
depend on fields obtained from models, e.g. properties derived from turbulence
models can be executed using the '-postProcess' of the appropriate solver, e.g.
pisoFoam -postProcess -func PecletNo
or
sonicFoam -postProcess -func MachNo
In this case all required fields will have already been read so the '-field' or
'-fields' options are not be needed.
Henry G. Weller
CFD Direct Ltd.
//- Recursively search the given directory for the file
// returning the path relative to the directory or
// fileName::null if not found
fileName search(const word& file, const fileName& directory);
In most boundary conditions, fvOptions etc. required and optional fields
to be looked-up from the objectRegistry are selected by setting the
keyword corresponding to the standard field name in the BC etc. to the
appropriate name in the objectRegistry. Usually a default is provided
with sets the field name to the keyword name, e.g. in the
totalPressureFvPatchScalarField the velocity is selected by setting the
keyword 'U' to the appropriate name which defaults to 'U':
Property | Description | Required | Default value
U | velocity field name | no | U
phi | flux field name | no | phi
.
.
.
However, in some BCs and functionObjects and many fvOptions another
convention is used in which the field name keyword is appended by 'Name'
e.g.
Property | Description | Required | Default value
pName | pressure field name | no | p
UName | velocity field name | no | U
This difference in convention is unnecessary and confusing, hinders code
and dictionary reuse and complicates code maintenance. In this commit
the appended 'Name' is removed from the field selection keywords
standardizing OpenFOAM on the first convention above.
Generally fields and objects are selected using the 'field[s]' and
'object[s]' keywords but this was not consistent between all
functionObject, fvOptions etc. and now fixed by applying the following
renaming:
fieldName -> field
fieldNames -> fields
objectName -> object
objectNames -> objects
Updated and simplified 'div', 'grad' and 'mag' functionObjects by deriving from 'fieldExpression'.
Corrected the handling of cached gradients in 'grad'.
instead of removing them. Now done similar to 23x:
- in 'removing unreachable parts of mesh' keep regions unset (so they get removed)
- in final zoning set to background region
See Gitlab #66.
the equivalent functionality is provided by the writeRegisteredObject
functionObject in a MUCH simpler, easier and extensible manner.
functionObject: Removed the now redundant 'timeSet' function.
codedFunctionObject: Added the "codeWrite" entry
for the "write" function for consistency.
The previous method of using the "code" entry for the "write"
function was inconsistent and very confusing.
Description
This Foam::functionObject tracks a uncoupled kinematic particle cloud in the
specified velocity field of an incompressible flow (laminar, RANS or LES).
It may be used in conjunction with any transient single-phase incompressible
flow solver such as \c pisoFoam or \c pimpleFoam and tracks the particles or
parcels without affecting the the flow-field.
The \c kinematicCloud requires the the density of the fluid which is
looked-up from \c constant/transportProperties dictionary and the
acceleration due to gravity which is read from the \c constant/g file if
present or defaults to zero.
The \c kinematicCloud properties are read from the \c
constant/kinematicCloudProperties dictionary in the usual manner.
Example of function object specification:
\verbatim
tracks
{
libs ("liblagrangianFunctionObjects.so");
type icoUncoupledKinematicCloud;
}
\endverbatim
\heading Function object usage
\table
Property | Description | Required | Default value
type | Type name: icoUncoupledKinematicCloud | yes |
U | Name of the velocity field | no | U
kinematicCloud | Name of the kinematicCloud | no | kinematicCloud
\endtable
This changes simplifies the specification of functionObjects in
controlDict and is consistent with the 'libs' option in controlDict to
load special solver libraries.
Support for the old 'functionObjectLibs' name is supported for backward compatibility.
- Avoids the need for the 'OutputFilterFunctionObject' wrapper
- Time-control for execution and writing is now provided by the
'timeControlFunctionObject' which instantiates the processing
'functionObject' and controls its operation.
- Alternative time-control functionObjects can now be written and
selected at run-time without the need to compile wrapped version of
EVERY existing functionObject which would have been required in the
old structure.
- The separation of 'execute' and 'write' functions is now formalized in the
'functionObject' base-class and all derived classes implement the
two functions.
- Unnecessary implementations of functions with appropriate defaults
in the 'functionObject' base-class have been removed reducing
clutter and simplifying implementation of new functionObjects.
- The 'coded' 'functionObject' has also been updated, simplified and tested.
- Further simplification is now possible by creating some general
intermediate classes derived from 'functionObject'.
splitMeshRegions: handle flipping of faces for surface fields
subsetMesh: subset dimensionedFields
decomposePar: use run-time selection of decomposition constraints. Used to
keep cells on particular processors. See the decomposeParDict in
$FOAM_UTILITIES/parallel/decomposePar:
- preserveBaffles: keep baffle faces on same processor
- preserveFaceZones: keep faceZones owner and neighbour on same processor
- preservePatches: keep owner and neighbour on same processor. Note: not
suitable for cyclicAMI since these are not coupled on the patch level
- singleProcessorFaceSets: keep complete faceSet on a single processor
- refinementHistory: keep cells originating from a single cell on the
same processor.
decomposePar: clean up decomposition of refinement data from snappyHexMesh
reconstructPar: reconstruct refinement data (refineHexMesh, snappyHexMesh)
reconstructParMesh: reconstruct refinement data (refineHexMesh, snappyHexMesh)
redistributePar:
- corrected mapping surfaceFields
- adding processor patches in order consistent with decomposePar
argList: check that slaves are running same version as master
fvMeshSubset: move to dynamicMesh library
fvMeshDistribute:
- support for mapping dimensionedFields
- corrected mapping of surfaceFields
parallel routines: allow parallel running on single processor
Field: support for
- distributed mapping
- mapping with flipping
mapDistribute: support for flipping
AMIInterpolation: avoid constructing localPoints
Feature iotweaks
Enhancements for #114 and #115. Tagged as WIP, since there may be some need for discussion/rework prior to merging.
See merge request !35
to have the prefix 'write' rather than 'output'
So outputTime() -> writeTime()
but 'outputTime()' is still supported for backward-compatibility.
Also removed the redundant secondary-writing functionality from Time
which has been superseded by the 'writeRegisteredObject' functionObject.
for consistency with the time controls in controlDict and to avoid
unnecessary confusion. All code and tutorials have been updated.
The old names 'outputControl' and 'outputInterval' are but supported for
backward compatibility but deprecated.
Simplified and generalized the handling of functionObjects which fail to
construct by removing them from the list rather than maintaining an
"enabled" switch in each functionObject.
Merge foundation
Integrating latest code from the OF Foundation - main changes:
Lots of renaming/refactoring:
- to retrieve reference from tmp, now need to use tmp.ref() as opposed to tmp()
- fvc::flux function to replace fvc::interpolate(<field>) & mesh.Sf()
- integration of new c++ features: no more spaces between closing template braces, e.g. class1<class2<Type> > becomes class1<class2<Type>>
- DataEntry renamed to Function1
New functionality:
- Updated 6DoF
- fvOptions support in turbulence models
See merge request !33
See commit b627924a4bf104521b567d3aa3dc80c864325b1a
Allwmake: Added scripted changes for REALTYPEWIDTH and IDXTYPEWIDTH
Patch contributed by Bruno Santos
Resolves bug-report http://bugs.openfoam.org/view.php?id=2085
Description
This functionObject writes objects registered to the database in VTK format
using the foamToVTK library.
Currently only the writing of the cell-values of volFields is supported but
support for other field types, patch fields, Lagrangian data etc. will be
added.
Example of function object specification:
\verbatim
writeVTK1
{
type writeVTK;
functionObjectLibs ("libIOFunctionObjects.so");
...
objectNames (obj1 obj2);
}
\endverbatim
\heading Function object usage
\table
Property | Description | Required | Default value
type | type name: writeVTK | yes |
objectNames | objects to write | yes |
\endtable
Executes application functionObjects to post-process existing results.
If the "dict" argument is specified the functionObjectList is constructed
from that dictionary otherwise the functionObjectList is constructed from
the "functions" sub-dictionary of "system/controlDict"
Multiple time-steps may be processed and the standard utility time
controls are provided.
This functionality is equivalent to execFlowFunctionObjects but in a
more efficient and general manner and will be included in all the
OpenFOAM solvers if it proves effective and maintainable.
The command-line options available with the "-postProcess" option may be
obtained by
simpleFoam -help -postProcess
Usage: simpleFoam [OPTIONS]
options:
-case <dir> specify alternate case directory, default is the cwd
-constant include the 'constant/' dir in the times list
-dict <file> read control dictionary from specified location
-latestTime select the latest time
-newTimes select the new times
-noFunctionObjects
do not execute functionObjects
-noZero exclude the '0/' dir from the times list, has precedence
over the -withZero option
-parallel run in parallel
-postProcess Execute functionObjects only
-region <name> specify alternative mesh region
-roots <(dir1 .. dirN)>
slave root directories for distributed running
-time <ranges> comma-separated time ranges - eg, ':10,20,40:70,1000:'
-srcDoc display source code in browser
-doc display application documentation in browser
-help print the usage
Henry G. Weller
CFD Direct Ltd.
ENH: added -decomposeParDict as argument to getNumberOfProcessors()
Continuing discussion at
1507178a1b (note_1093)
Now the Allrun script could be
```
runParallel -decomposeParDict system/decomposeParDict-6 snappyHexMesh -overwrite
```
Thanks @Mattijs
See merge request !36
Rather than requiring each functionObject to handle failed construction
internally (using the active_ flag) the static member function "viable"
is provided which returns true if construction of the functionObject is
likely to be successful. Failed construction is then handled by the
wrapper-class which constructs the functionObject,
e.g. "OutputFilterFunctionObject".
See http://www.openfoam.org/mantisbt/view.php?id=2076
- .org is the file extension for emacs org-mode as well
- .orig is more to the point (.org isn't always recognized as "original")
- .original is too long, although more consistent with the convention
of source code file naming
Update script contributed by Bruno Santos
These new names are more consistent and logical because:
primitiveField():
primitiveFieldRef():
Provides low-level access to the Field<Type> (primitive field)
without dimension or mesh-consistency checking. This should only be
used in the low-level functions where dimensional consistency is
ensured by careful programming and computational efficiency is
paramount.
internalField():
internalFieldRef():
Provides access to the DimensionedField<Type, GeoMesh> of values on
the internal mesh-type for which the GeometricField is defined and
supports dimension and checking and mesh-consistency checking.
In order to simplify expressions involving dimensioned internal field it
is preferable to use a simpler access convention. Given that
GeometricField is derived from DimensionedField it is simply a matter of
de-referencing this underlying type unlike the boundary field which is
peripheral information. For consistency with the new convention in
"tmp" "dimensionedInteralFieldRef()" has been renamed "ref()".
Non-const access to the internal field now obtained from a specifically
named access function consistent with the new names for non-canst access
to the boundary field boundaryFieldRef() and dimensioned internal field
dimensionedInternalFieldRef().
See also commit 22f4ad32b1
When the GeometricBoundaryField template class was originally written it
was a separate class in the Foam namespace rather than a sub-class of
GeometricField as it is now. Without loss of clarity and simplifying
code which access the boundary field of GeometricFields it is better
that GeometricBoundaryField be renamed Boundary for consistency with the
new naming convention for the type of the dimensioned internal field:
Internal, see commit 4a57b9be2e
This is a very simple text substitution change which can be applied to
any code which compiles with the OpenFOAM-dev libraries.
Given that the type of the dimensioned internal field is encapsulated in
the GeometricField class the name need not include "Field"; the type
name is "Internal" so
volScalarField::DimensionedInternalField -> volScalarField::Internal
In addition to the ".dimensionedInternalField()" access function the
simpler "()" de-reference operator is also provided to greatly simplify
FV equation source term expressions which need not evaluate boundary
conditions. To demonstrate this kEpsilon.C has been updated to use
dimensioned internal field expressions in the k and epsilon equation
source terms.
both of which return the dimensionedInternalField for volFields only.
These will be useful in FV equation source term expressions which need
not evaluate boundary conditions.
Resolves bug-report http://www.openfoam.org/mantisbt/view.php?id=1938
Because C++ does not support overloading based on the return-type there
is a problem defining both const and non-const member functions which
are resolved based on the const-ness of the object for which they are
called rather than the intent of the programmer declared via the
const-ness of the returned type. The issue for the "boundaryField()"
member function is that the non-const version increments the
event-counter and checks the state of the stored old-time fields in case
the returned value is altered whereas the const version has no
side-effects and simply returns the reference. If the the non-const
function is called within the patch-loop the event-counter may overflow.
To resolve this it in necessary to avoid calling the non-const form of
"boundaryField()" if the results is not altered and cache the reference
outside the patch-loop when mutation of the patch fields is needed.
The most straight forward way of resolving this problem is to name the
const and non-const forms of the member functions differently e.g. the
non-const form could be named:
mutableBoundaryField()
mutBoundaryField()
nonConstBoundaryField()
boundaryFieldRef()
Given that in C++ a reference is non-const unless specified as const:
"T&" vs "const T&" the logical convention would be
boundaryFieldRef()
boundaryFieldConstRef()
and given that the const form which is more commonly used is it could
simply be named "boundaryField()" then the logical convention is
GeometricBoundaryField& boundaryFieldRef();
inline const GeometricBoundaryField& boundaryField() const;
This is also consistent with the new "tmp" class for which non-const
access to the stored object is obtained using the ".ref()" member function.
This new convention for non-const access to the components of
GeometricField will be applied to "dimensionedInternalField()" and "internalField()" in the
future, i.e. "dimensionedInternalFieldRef()" and "internalFieldRef()".
There is a need to specify const or non-const access to a non-const
object which is not currently possible with the "boundaryField()" access
function the const-ness of the return of which is defined by the
const-ness of the object for which it is called. For consistency with
the latest "tmp" storage class in which non-const access is obtained
with the "ref()" function it is proposed to replace the non-const form
of "boundaryField()" with "boundaryFieldRef()".
Thanks to Mattijs Janssens for starting the process of migration to
"boundaryFieldRef()" and providing a patch for the OpenFOAM and
finiteVolume libraries.
This condition creates a zero-dimensional model of an enclosed volume of
gas upstream of the inlet. The pressure that the boundary condition
exerts on the inlet boundary is dependent on the thermodynamic state of
the upstream volume. The upstream plenum density and temperature are
time-stepped along with the rest of the simulation, and momentum is
neglected. The plenum is supplied with a user specified mass flow and
temperature.
The result is a boundary condition which blends between a pressure inlet
condition condition and a fixed mass flow. The smaller the plenum
volume, the quicker the pressure responds to a deviation from the supply
mass flow, and the closer the model approximates a fixed mass flow. As
the plenum size increases, the model becomes more similar to a specified
pressure.
The expansion from the plenum to the inlet boundary is controlled by an
area ratio and a discharge coefficient. The area ratio can be used to
represent further acceleration between a sub-grid blockage such as fins.
The discharge coefficient represents a fractional deviation from an
ideal expansion process.
This condition is useful for simulating unsteady internal flow problems
for which both a mass flow boundary is unrealistic, and a pressure
boundary is susceptible to flow reversal. It was developed for use in
simulating confined combustion.
tutorials/compressible/rhoPimpleFoam/laminar/helmholtzResonance:
helmholtz resonance tutorial case for plenum pressure boundary
This development was contributed by Will Bainbridge
Also added the new prghTotalHydrostaticPressure p_rgh BC which uses the
hydrostatic pressure field as the reference state for the far-field
which provides much more accurate entrainment is large open domains
typical of many fire simulations.
The hydrostatic field solution is controlled by the optional entries in
the fvSolution.PIMPLE dictionary, e.g.
hydrostaticInitialization yes;
nHydrostaticCorrectors 5;
and the solver must also be specified for the hydrostatic p_rgh field
ph_rgh e.g.
ph_rgh
{
$p_rgh;
}
Suitable boundary conditions for ph_rgh cannot always be derived from
those for p_rgh and so the ph_rgh is read to provide them.
To avoid accuracy issues with IO, restart and post-processing the p_rgh
and ph_rgh the option to specify a suitable reference pressure is
provided via the optional pRef file in the constant directory, e.g.
dimensions [1 -1 -2 0 0 0 0];
value 101325;
which is used in the relationship between p_rgh and p:
p = p_rgh + rho*gh + pRef;
Note that if pRef is specified all pressure BC specifications in the
p_rgh and ph_rgh files are relative to the reference to avoid round-off
errors.
For examples of suitable BCs for p_rgh and ph_rgh for a range of
fireFoam cases please study the tutorials in
tutorials/combustion/fireFoam/les which have all been updated.
Henry G. Weller
CFD Direct Ltd.
Patch contributed by Juho Peltola, VTT
The new JohnsonJacksonSchaefferFrictionalStress model is included and
the LBend tutorial case to demonstrate the need for the changes to the
frictional stress models.
Resolves bug-report http://www.openfoam.org/mantisbt/view.php?id=2058
Old:
- Previous versions created k and epsilon fields by default, and
then processed omega and nuTilda fields if present.
- Depending on the choice of turbulence model, not all of these fields
would be used, and could lead to errors when running some utilities
due to erroneous values.
- If the omega field did not exist, it would be derived from the epsilon
field, and also inherit the epsilon boundary conditions (wall
functions)
New:
- This version will only update fields that already exist on file, i.e.
will not generate any new fields, and will preserve the boundary
conditions
- assists in decoding what the binary IO content means
ENH: use label instead of bool for the KinematicParcel active state (fixes#111)
- avoids internal padding of the data structure and simplifies
downstream use.
ENH: make particle sizeofFields public (fixes#110)
Also fixes#108 (missing faceI and stepFraction entries) which had
also been fixed in the upstream as well.
The joint-space dynamics is solved on the master processor only and the
resulting joint-state distributed to the slave processors on which the
body-state is then updated. This guarantees consistency of the body
position and orientation on all processors.
The motion of the bodies is integrated using the rigidBodyDynamics
library with joints, restraints and external forces.
The mesh-motion is interpolated using septernion averaging.
This development is sponsored by Carnegie Wave Energy Ltd.
inline Foam::vector Foam::septernion::transformPoint(const vector& v) const
{
return r().transform(v - t());
}
Now there is a 1:1 correspondence between septernion and
spatialTransform and a septernion constructor from spatialTransform
provided.
Additionally "septernion::transform" has been renamed
"septernion::transformPoint" to clarify that it transforms coordinate
points rather than displacements or other relative vectors.
'w' is now obtained from 'v' using the relation w = sqrt(1 - |sqr(v)|)
and 'v' is stored in the joint state field 'q' and integrated in the
usual manner but corrected using quaternion transformations.
Currently supported solvers: symplectic, Newmark, CrankNicolson
The symplectic solver should only be used if iteration over the forces
and body-motion is not required. Newmark and CrankNicolson both require
iteration to provide 2nd-order behavior.
See applications/test/rigidBodyDynamics/spring for an example of the
application of the Newmark solver.
This development is sponsored by Carnegie Wave Energy Ltd.
This is a more convenient way of maintaining the state or multiple
states (for higher-order integration), storing, retrieving and passing
between processors.
Included for backward-compatibility with the 6-DoF solver but in the
future will be re-implemented as a joint rather than body restraint and
accumulated in tau (internal forces) rather than fx (external forces).
applications/test/rigidBodyDynamics/spring: Test of the linear spring with damper restraint
Damped simple harmonic motion of a weight on a spring is simulated and
the results compared with analytical solution
Test-spring
gnuplot spring.gnuplot
evince spring.eps
This development is sponsored by Carnegie Wave Energy Ltd.
e.g. (fvc::interpolate(HbyA) & mesh.Sf()) -> fvc::flux(HbyA)
This removes the need to create an intermediate face-vector field when
computing fluxes which is more efficient, reduces the peak storage and
improved cache coherency in addition to providing a simpler and cleaner
API.
dotInterpolate interpolates the field and "dots" the resulting
face-values with the vector field provided which removes the need to
create a temporary field for the interpolate. This reduces the peak
storage of OpenFOAM caused by the divergence of the gradient of vector
fields, improves memory management and under some conditions decreases
run-time.
This development is based on a patch contributed by Paul Edwards, Intel.
to allow the construction of vtables for virtual member functions
involving the inner-products of fields for which a "NotImplemented"
specialization for scalar is provided.
Based on the principles, algorithms, data structures and notation
presented in the book:
Featherstone, R. (2008).
Rigid body dynamics algorithms.
Springer.
This development is sponsored by Carnegie Wave Energy Ltd.
//- Disallow default shallow-copy assignment
//
// Assignment of UList<T> may need to be either shallow (copy pointer)
// or deep (copy elements) depending on context or the particular type
// of list derived from UList and it is confusing and prone to error
// for the default assignment to be either. The solution is to
// disallow default assignment and provide separate 'shallowCopy' and
// 'deepCopy' member functions.
void operator=(const UList<T>&) = delete;
//- Copy the pointer held by the given UList.
inline void shallowCopy(const UList<T>&);
//- Copy elements of the given UList.
void deepCopy(const UList<T>&);
Contributed by Mattijs Janssens.
1. Any non-blocking data exchange needs to know in advance the sizes to
receive so it can size the buffer. For "halo" exchanges this is not
a problem since the sizes are known in advance but or all other data
exchanges these sizes need to be exchanged in advance.
This was previously done by having all processors send the sizes of data to
send to the master and send it back such that all processors
- had the same information
- all could work out who was sending what to where and hence what needed to
be received.
This is now changed such that we only send the size to the
destination processor (instead of to all as previously). This means
that
- the list of sizes to send is now of size nProcs v.s. nProcs*nProcs before
- we cut out the route to the master and back by using a native MPI
call
It causes a small change to the API of exchange and PstreamBuffers -
they now return the sizes of the local buffers only (a labelList) and
not the sizes of the buffers on all processors (labelListList)
2. Reversing the order of the way in which the sending is done when
scattering information from the master processor to the other
processors. This is done in a tree like fashion. Each processor has a
set of processors to receive from/ send to. When receiving it will
first receive from the processors with the least amount of
sub-processors (i.e. the ones which return first). When sending it
needs to do the opposite: start sending to the processor with the
most amount of sub-tree since this is the critical path.
The blocks may be specified directly in terms of the size and location in the
parent matrix or with the size obtained from a template specified
VectorSpace or MatrixSpace type.
This new approach to 0 initialization is simpler, cleaner, more readable
and more efficient. The rest of the OpenFOAM code will be updated in
due course.
Patch contributed by Bruno Santos:
- "etc/config.sh/CGAL":
- Indented the contents of the recently added if block.
- Added comment about using system versions.
- Library paths are now only added if the respective version is not "boost-system" and "cgal-system".
- "src/renumber/Allwmake":
It now relies on the previous file to get the version for
Boost (the same way as in "makeCGAL"). This is so that it will also
build "SloanRenumber" if "boost_version" is set to "boost-system".
- "applications/utilities/mesh/generation/Allwmake":
It now also relies on the script "config.sh/CGAL" to get the
version for CGAL. If "cgal_version" is set to "cgal-system", it
will now also build "foamy*Mesh" utilities and respective
libraries.
Resolves report http://www.openfoam.org/mantisbt/view.php?id=1232
The row-start pointer array provided performance benefits on old
computers but now that computation is often cache-miss limited the
benefit of avoiding a integer multiply is more than offset by the
addition memory access into a separately allocated array.
With the new addressing scheme LUsolve is 15% faster.
in terms of the rotation tensor \c E and translation vector \c r .
See Chapter 2 and Appendix A in reference:
Featherstone, R. (2008).
Rigid body dynamics algorithms.
Springer.
This work is sponsored by Carnegie Wave Energy Ltd
Henry G. Weller
CFD Direct
Based on definitions in chapter 2 of the book:
Featherstone, R. (2008).
Rigid body dynamics algorithms.
Springer.
This work is sponsored by Carnegie Wave Energy Ltd
Feature shared file
This contains the functionality from dev to do with (processor-)global/local file marking.
global files are those that are the same on all processors (e.g. dictionaries) and so can be read on the master processor only. 'local' files are specific to the processor (e.g. fields).
See merge request !30
The particular rotation sequence is specified via the enumeration:
//- Euler-angle rotation sequence
enum rotationSequence
{
ZYX, ZYZ, ZXY, ZXZ, YXZ, YXY, YZX, YZY, XYZ, XYX, XZY, XZX
};
and provided as an argument to the constructor from Euler-angles
//- Construct a quaternion given the three Euler angles:
inline quaternion
(
const rotationSequence rs,
const vector& angles
);
and conversion to Euler-angles:
//- Return a vector of euler angles corresponding to the
// specified rotation sequence
inline vector eulerAngles(const rotationSequence rs) const;
Provides '(i, j)' element access and general forms of inner and outer
products, transpose etc. for square and rectangular VectorSpaces.
VectorSpaces default to be column-vectors as before whereas row-vectors
may be represented as 1xn MatrixSpaces. In the future it may be
preferable to create a specializations of VectorSpace for column- and
maybe row-vectors but it would add complexity to MatrixSpace to handle
all the type combinations.
Tensor is now a 3x3 specialization of MatrixSpace.
Sub-block const and non-const access is provided via the
'.block<SubTensor, RowStart, ColStart>()' member functions. Consistent
sub-block access is also provide for VectorSpace so that columns of
MatrixSpaces may be accessed and substituted.
These new classes will be used to create a more extensive set of
primitive vector and tensor types over the next few weeks.
Henry G. Weller
CFD Direct
Foam::direction is an unsigned type which makes it easier for the
compiler to pickup and report errors in the instantiation of
VectorSpaces and associated types.
1. "foamCompiler" was changed to a more permanent "WM_COMPILER_TYPE"
environment variable, so that it can be used by 3rd party
installation scripts, such as "makeGcc", "makeLLVM" and so on. More
on this will be provided in issue #1215.
2. The script functions such as "_foamSource()" and "_foamAddPath()"
were moved to a new file "etc/config.sh/functions". It has the
ability to set or unset, depending on whether "WM_BASH_FUNCTIONS" is
defined or not. This allows for these functions to be reused by
other scripts, such as "makeGcc".
3. The script "etc/config.sh/CGAL" relies on whether a local
environment variable "SOURCE_CGAL_VERSIONS_ONLY" is defined or not,
so that it will load only the version settings if it's defined. This
is to make it easier to call this script from "makeCGAL". Although
it still feels a bit of a clunky hack, but I didn't manage to deduce
any other way we could do this :( I didn't add indentation within
the if-block, to make it easier to read the changes. In addition,
the local variable "common_path" is used to shorten the length of
the lines and use slightly less repeated code.
4. Added another new script "etc/config.sh/compiler", which has only
the version numbers for the compilers taken out from the "settings"
file. It currently depends on "WM_COMPILER_TYPE" for setting the
variables, the same way it did with "foamCompiler". This script is
now always sourced from the "settings" file, for the following
reasons:
- "makeGCC" and "makeLLVM" can now take advantage of this script file.
- The example "compiler" script (detailed next) can rely on this
script file and then override parameters on-demand, as well as
allowing for system compilers to have dedicated settings, such as
setting "WM_CC". This is similar to how the example environment
script for "paraview" works.
5. To the script "etc/config.sh/example/compiler" were added a few more examples:
- It now starts with a block where it first loads the default "compiler" script.
- Has a "WM_COMPILER=Gcc48u" case example for when we try to use GCC
4.8 in Ubuntu 15.10. This is just to give the idea that in a
particular system, we might have several system-wide compiler
versions. For example, in Ubuntu 15.10, there is GCC 4.7, 4.8 and
5.2, which could be used for testing performances or compatibility
with some other 3rd party library.
- Has the "WM_COMPILER=Icc" case example, related to the original bug
report, where "WM_CC=icc" and "WM_CXX=icpc", so that the user then
simply copies this file to their own local preferences folder.
6. Small bug fix in "etc/config.sh/mpi", where unsetting "minBufferSize" was missing at the end of the script.
7. Small change in "etc/config.sh/paraview", where "CMAKE_ROOT" is set
along with "CMAKE_HOME". This is due to a rare issue that occurs on
people's systems where they have a custom system-wide CMake version
installed and which is used by having "CMAKE_ROOT" set on that
environment. This can mess up OpenFOAM's custom ParaView builds,
given that conflicting CMake versions can lead to not building
ParaView at all.
- For more details about "CMAKE_ROOT":
https://cmake.org/Wiki/CMake_Useful_Variables [^]
8. The scripts "_foamAddPath _foamAddLib _foamAddMan" were not being
unset at the end of "settings". They are now unset at the end of
"bashrc", through a call to the new double-use "functions" script.
Additionally all references to "foamCompiler" have been changed to
"WM_COMPILER_TYPE".
See also http://www.openfoam.org/mantisbt/view.php?id=1232
Wall-velocity condition to be used in conjunction with the single rotating
frame (SRF) model (see: FOAM::SRFModel)
The condition applies the appropriate rotation transformation in time and
space to determine the local SRF velocity of the wall.
\f[
U_p = - U_{p,srf}
\f]
where
\vartable
U_p = patch velocity [m/s]
U_{p,srf} = SRF velocity
\endvartable
The normal component of \f$ U_p \f$ is removed to ensure 0 wall-flux even
if the wall patch faces are irregular.
\heading Patch usage
Example of the boundary condition specification:
\verbatim
myPatch
{
type SRFWallVelocity;
value uniform (0 0 0); // Initial value
}
\endverbatim
DebugInfo:
Report an information message using Foam::Info if the local debug
switch is true
DebugInFunction:
Report an information message using Foam::Info for FUNCTION_NAME in
file __FILE__ at line __LINE__ if the local debug switch is true
which reduces the number of potential problems with the reuse of
temporary objects.
In order to avoid unnecessary creation of tmp's referring to temporary
objects the assignment operator now transfers ownership of the object
and resets the argument.
The deprecated non-const tmp functionality is now on the compiler switch
NON_CONST_TMP which can be enabled by adding -DNON_CONST_TMP to EXE_INC
in the Make/options file. However, it is recommended to upgrade all
code to the new safer tmp by using the '.ref()' member function rather
than the non-const '()' dereference operator when non-const access to
the temporary object is required.
Please report any problems on Mantis.
Henry G. Weller
CFD Direct.
in case of tmp misuse.
Simplified tmp reuse pattern in field algebra to use tmp copy and
assignment rather than the complex delayed call to 'ptr()'.
Removed support for unused non-const 'REF' storage of non-tmp objects due to C++
limitation in constructor overloading: if both tmp(T&) and tmp(const T&)
constructors are provided resolution is ambiguous.
The turbulence libraries have been upgraded and '-DCONST_TMP' option
specified in the 'options' file to switch to the new 'tmp' behavior.
This change requires that the de-reference operator '()' returns a
const-reference to the object stored irrespective of the const-ness of
object stored and the new member function 'ref()' is provided to return
an non-const reference to stored object which throws a fatal error if the
stored object is const.
In order to smooth the transition to this new safer 'tmp' the now
deprecated and unsafe non-const de-reference operator '()' is still
provided by default but may be switched-off with the compilation switch
'CONST_TMP'.
The main OpenFOAM library has already been upgraded and '-DCONST_TMP'
option specified in the 'options' file to switch to the new 'tmp'
behavior. The rest of OpenFOAM-dev will be upgraded over the following
few weeks.
Henry G. Weller
CFD Direct
To be used instead of zeroGradientFvPatchField for temporary fields for
which zero-gradient extrapolation is use to evaluate the boundary field
but avoiding fields derived from temporary field using field algebra
inheriting the zeroGradient boundary condition by the reuse of the
temporary field storage.
zeroGradientFvPatchField should not be used as the default patch field
for any temporary fields and should be avoided for non-temporary fields
except where it is clearly appropriate;
extrapolatedCalculatedFvPatchField and calculatedFvPatchField are
generally more suitable defaults depending on the manner in which the
boundary values are specified or evaluated.
The entire OpenFOAM-dev code-base has been updated following the above
recommendations.
Henry G. Weller
CFD Direct
Vastly reduces the scattering and churning behaviour of packed beds.
Development provided by Will Bainbridge <github.com/will-bainbridge>
See also http://www.openfoam.org/mantisbt/view.php?id=1994
RunFunctions: Added "isTest()" argument parsing function
tutorials: Updated Allrun scripts to propagate the "-test" option
tutorials: Removed the lower Alltest scripts and updated the Allrun to
use the "isTest()" function to handle test-specific operation
The boundary conditions of HbyA are now constrained by the new "constrainHbyA"
function which applies the velocity boundary values for patches for which the
velocity cannot be modified by assignment and pressure extrapolation is
not specified via the new
"fixedFluxExtrapolatedPressureFvPatchScalarField".
The new function "constrainPressure" sets the pressure gradient
appropriately for "fixedFluxPressureFvPatchScalarField" and
"fixedFluxExtrapolatedPressureFvPatchScalarField" boundary conditions to
ensure the evaluated flux corresponds to the known velocity values at
the boundary.
The "fixedFluxPressureFvPatchScalarField" boundary condition operates
exactly as before, ensuring the correct flux at fixed-flux boundaries by
compensating for the body forces (gravity in particular) with the
pressure gradient.
The new "fixedFluxExtrapolatedPressureFvPatchScalarField" boundary
condition may be used for cases with or without body-forces to set the
pressure gradient to compensate not only for the body-force but also the
extrapolated "HbyA" which provides a second-order boundary condition for
pressure. This is useful for a range a problems including impinging
flow, extrapolated inlet conditions with body-forces or for highly
viscous flows, pressure-induced separation etc. To test this boundary
condition at walls in the motorBike tutorial case set
lowerWall
{
type fixedFluxExtrapolatedPressure;
}
motorBikeGroup
{
type fixedFluxExtrapolatedPressure;
}
Currently the new extrapolated pressure boundary condition is supported
for all incompressible and sub-sonic compressible solvers except those
providing implicit and tensorial porosity support. The approach will be
extended to cover these solvers and options in the future.
Note: the extrapolated pressure boundary condition is experimental and
requires further testing to assess the range of applicability,
stability, accuracy etc.
Henry G. Weller
CFD Direct Ltd.
with optional specification of the mark/space ratio
Templated square-wave function with support for an offset level.
\f[
a square(f (t - t_0)) s + l
\f]
where
\f$ square(t) \f$ is the square-wave function in range \f$ [-1, 1] \f$
with a mark/space ratio of \f$ r \f$
\vartable
symbol | Description | Data type | Default
a | Amplitude | Function1<scalar> |
f | Frequency [1/s] | Function1<scalar> |
s | Type scale factor | Function1<Type> |
l | Type offset level | Function1<Type> |
t_0 | Start time [s] | scalar | 0
r | mark/space ratio | scalar | 1
t | Time [s] | scalar
\endvartable
Example for a scalar:
\verbatim
<entryName> square;
<entryName>Coeffs
{
frequency 10;
amplitude 0.1;
scale 2e-6;
level 2e-6;
}
\endverbatim
etc/config.sh and etc/config.csh
This structure is more convenient to add support for other shells, e.g. zsh, fish etc.
Resolves feature request to simplify support for other shells in
http://www.openfoam.org/mantisbt/view.php?id=1232
To see the different behavior of flow through and around the blockage
change D in constant/fvOptions:
// D 100; // Very little blockage
// D 200; // Some blockage but steady flow
// D 500; // Slight waviness in the far wake
D 1000; // Fully shedding behavior
Templated sine function with support for an offset level.
\f[
a sin(2 \pi f (t - t_0)) s + l
\f]
where
\vartable
symbol | Description | Data type
a | Amplitude | Function1<scalar>
f | Frequency [1/s] | Function1<scalar>
s | Type scale factor | Function1<Type>
l | Type offset level | Function1<Type>
t_0 | Start time [s] | scalar
t | Time [s] | scalar
\endvartable
Function1 is an abstract base-class of run-time selectable unary
functions which may be composed of other Function1's allowing the user
to specify complex functions of a single scalar variable, e.g. time.
The implementations need not be a simple or continuous functions;
interpolated tables and polynomials are also supported. In fact form of
mapping between a single scalar input and a single primitive type output
is supportable.
The primary application of Function1 is in time-varying boundary
conditions, it also used for other functions of time, e.g. injected mass
is spray simulations but is not limited to functions of time.
Description
Templated sine function with support for an offset level.
\f[
a sin(2 \pi f (t - t_0)) s + l
\f]
where
\vartable
a | Amplitude
f | Frequency [1/s]
s | Type scale factor
l | Type offset level
t_0 | Start time [s]
t | Time [s]
\endvartable
Example for a scalar:
\verbatim
<entryName> sine;
<entryName>Coeffs
{
frequency 10;
amplitude 0.1;
scale 2e-6;
level 2e-6;
}
\endverbatim
Example for a vector:
\verbatim
<entryName> sine;
<entryName>Coeffs
{
frequency 10;
amplitude 1;
scale (1 0.1 0);
level (10 1 0);
}
\endverbatim
PV4FoamReaders: Updated to build with ParaView-5.0.0
paraFoam: Updated to load PV4FoamReaders for ParaView-5.0.0
Currently this is experimental but if it becomes clear that ParaView-4
and ParaView-5 are and will remain consistent with respect to readers
the plan is to rename
PV4 -> PV
or
PV4 -> PV45 if it is assumed that PV6 may need to be different.
Removed inconsistent binary output.
Removed unused and IO-inconsistent functions.
Simplified the handling of backward-compatible constant value:
Removed the unnecessary CompatibilityConstant,
Updated Constant and DataEntryNew to handle constant value construction.
// Polynomial functions and interpolation do evaluate to label
// Instead evaluate a scalar and convert to label as appropriate
// makeDataEntryType(PolynomialEntry, label);
// makeDataEntryType(CSV, label);
// makeDataEntryType(Table, label);
// makeDataEntryType(TableFile, label);
Resolves bug-report http://www.openfoam.org/mantisbt/view.php?id=1987
If the mean velocity force is applied to a cyclic patch for parallel
runs include contributions from processorCyclic patches generated
from the decomposition of the cyclic patch
When restarting form a previous calculation, the averaging is continuous or
may be restarted using the \c restartOnRestart option.
The averaging process may be restarted after each calculation output time
using the \c restartOnOutput option or restarted periodically using the \c
periodicRestart option and setting \c restartPeriod to the required
averaging period.
Example of function object specification:
\verbatim
fieldAverage1
{
type fieldAverage;
functionObjectLibs ("libfieldFunctionObjects.so");
...
restartOnRestart false;
restartOnOutput false;
periodicRestart false;
restartPeriod 0.002;
fields
(
U
{
mean on;
prime2Mean on;
base time;
window 10.0;
windowName w1;
}
p
{
mean on;
prime2Mean on;
base time;
}
);
}
\endverbatim
\heading Function object usage
\table
Property | Description | Required | Default value
type | type name: fieldAverage | yes |
restartOnRestart | Restart the averaging on restart | no | no
restartOnOutput | Restart the averaging on output | no | no
periodicRestart | Periodically restart the averaging | no | no
restartPeriod | Periodic restart period | conditional |
fields | list of fields and averaging options | yes |
\endtable
in decomposeParDict.
This default number of processors may be overridden by the new "-np"
option to runParallel which must be specified before the application
name e.g.:
runParallel -np 4 pisoFoam
Moved file path handling to regIOobject and made it type specific so
now every object can have its own rules. Examples:
- faceZones are now processor local (and don't search up anymore)
- timeStampMaster is now no longer hardcoded inside IOdictionary
(e.g. uniformDimensionedFields support it as well)
- the distributedTriSurfaceMesh is properly processor-local; no need
for fileModificationChecking manipulation.
- was merging all boundary points originating from the same point
- which caused merging of multiple extruded points (since all originating
from the same point)
- there is no more addressing available from addPatchCell layer so
instead do a geometric merge
- additional bug: calculating weights if faceZone on processor patch
which may be optionally overridden by version-specific rules.
For example the default rules for gcc on GNU/Linux x86_64 are in the
wmake/rules/linux64Gcc directory. If there is a need to change any of
the rules for a specific version of gcc, e.g. gcc-4.8.4 the directory
wmake/rules/linux64Gcc48 may be created into which any of the language
files may be provided containing the rules to override the defaults.
This function object calculates mole-fraction fields from the mass-fraction
fields of the psi/rhoReactionThermo and caches them for output and further
post-processing.
The names of the mole-fraction fields are obtained from the corresponding
mass-fraction fields prepended by "X_"
Example of function object specification:
moleFractions
{
type psiReactionThermoMoleFractions;
}
or
moleFractions
{
type rhoReactionThermoMoleFractions;
}
depending on the thermodynamics package used in the solver.
Evaluates the contact angle as a function of the optionally specified
temperature field (defaults to T). The "theta0" function is provided as
a DataEntry currently supporting:
CompatibilityConstant
constant
csvFile
polynomial
table
tableFile
It is not clear what form an fvOptions source should take as f is not a
transported dynamic field. For the moment the fvOptions source from the
f-equation has been removed until there is a specific need which will
show what the form should be.
Resolves bug-report http://www.openfoam.org/mantisbt/view.php?id=1955
The Makefiles are now in the makefiles sub-directory
The "-f | -force" option in wmakeLnInclude is now "-u | -update" for
consistency with the other scripts.
The "Usage" entry in the headers is now consistently formatted in all
scripts.
wcleanPlatform is a more general and cleaner version of wcleanMachine
supporting the "-all" option to provide the equivalent of wcleanAll.
Both wcleanMachine and wcleanAll are now deprecated and will be removed
for the next major release.
Updates lnInclude directories and dep files before compilation. This is
useful to apply following a "git pull" to ensure consistency between the
source files, dep files and links.
Searches all the "src" and "application" directories of the project for
broken symbolic links for source code files and then remove all .dep
files that relate to the files that no longer exist. Must be executed
in main project source code folder: $WM_PROJECT_DIR
Patch provided by Bruno Santos
Resolves feature-request http://www.openfoam.org/mantisbt/view.php?id=1941
It will exit after removing the empty folders and it will not do the
other standard "wclean" operations. This replaces the functionality
provided by "wrmdepold".
Patch provided by Bruno Santos
Starting from an initial buffer size of 256 it is incremented in steps
of 256 upto the maximum of 4096 as required.
Based on patch provided by Bruno Santos
Resolves bug-report http://www.openfoam.org/mantisbt/view.php?id=1944
Drag model for gas-liquid system of Tomiyama et al.
Reference:
"Drag coefficients of single bubbles under normal and microgravity
conditions"
Tomiyama, A., Kataoka, I., Zun, I., Sakaguchi, T.
JSME International Series B, Fluids and Thermal Engineering,
Vol. 41, 1998, pp. 472-479
Provided by Alberto Passalacq
It is better to declare the namespace of each function in the C file
rather than "open" the namespace as this may lead to inconsistencies
between the declaration in the H files and definition in the C file.
Links are followed in most cases, with some notable exceptions:
- mv, mvBak:
renames the link, not the underlying file/directory
- rmDir:
remove the symlink to a directory, does not recurse into the
underlying directory
2014-04-23 15:00:00 +02:00
10457 changed files with 420892 additions and 308843 deletions
OpenFOAM is a free, open source CFD software package developed primarily by [OpenCFD](http://www.openfoam.com) since 2004 and is currently distributed by [ESI-OpenCFD](http://www.openfoam.com) and the [OpenFOAM Foundation](http://openfoam.org). 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 primarily by OpenCFD Ltd](http://www.openfoam.com) since 2004. It has a large user base across most areas of engineering and science, from both commercial and academic organisations. OpenFOAM has an extensive range of features to solve anything from complex fluid flows involving chemical reactions, turbulence and heat transfer, to acoustics, solid mechanics and electromagnetics. [More...](http://www.openfoam.com/documentation)
OpenFOAM+ uses the OpenFOAM Foundation version as a common code base, with wider functionality and platform support. Its purpose is to accelerate the public availability of new features which are sponsored by OpenCFD's customers and contributed by the OpenFOAM community.
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.
# Copyright
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 can copy the files.
# OpenFOAM Trademark
OpenCFD Limited, owner of the OpenFOAM Trademark, has granted the use of the Trademark to the OpenFOAM Foundation. 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.
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 Name and agreed Domain Name. For information on trademark use, please refer to the [trademark policy guidelines](http://www.openfoam.com/legal/trademark-policy.php).
Please [contact OpenCFD](http://www.openfoam.com/contact) if you have any questions on the use of the OpenFOAM trademark.
Violations of the Trademark are continuously monitored, and will be duly prosecuted.
# Useful Links
- [Download and installation instructions](http://www.openfoam.com/releases)
- [Download and installation instructions](http://www.openfoam.com/download/)
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.
