Permalink
Browse files

postProcessing: Replaced 'foamCalc' and the 'postCalc' utilities

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.
1 parent 7a3f939 commit 8b672f0f1af033605cf8fa0407ad643816b61675 Henry Weller committed May 28, 2016
Showing 394 changed files with 1,450 additions and 5,384 deletions.
@@ -20,7 +20,6 @@ EXE_LIBS = \
-lfieldFunctionObjects \
-lfileFormats \
-lfiniteVolume \
- -lfoamCalcFunctions \
-lforces \
-lfvMotionSolvers \
-lgenericPatchFields \
@@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
- \\ / A nd | Copyright (C) 2011-2013 OpenFOAM Foundation
+ \\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@@ -34,6 +34,7 @@ Description
#include "IFstream.H"
#include "IOobject.H"
#include "HashSet.H"
+#include "etcFiles.H"
using namespace Foam;
@@ -1,3 +0,0 @@
-foamCalcApp.C
-
-EXE = $(FOAM_APPBIN)/foamCalc
@@ -1,10 +0,0 @@
-EXE_INC = \
- -I$(LIB_SRC)/postProcessing/foamCalcFunctions/lnInclude \
- -I$(LIB_SRC)/finiteVolume/lnInclude \
- -I$(LIB_SRC)/meshTools/lnInclude
-
-EXE_LIBS = \
- -lgenericPatchFields \
- -lfoamCalcFunctions \
- -lfiniteVolume \
- -lmeshTools
@@ -1,100 +0,0 @@
-/*---------------------------------------------------------------------------*\
- ========= |
- \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
- \\ / O peration |
- \\ / A nd | Copyright (C) 2011-2016 OpenFOAM Foundation
- \\/ M anipulation |
--------------------------------------------------------------------------------
-License
- This file is part of OpenFOAM.
-
- 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.
-
- OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
- ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
- FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
- for more details.
-
- You should have received a copy of the GNU General Public License
- along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
-
-Application
- foamCalc
-
-Description
- Generic wrapper for calculating a quantity at each time.
-
- Split into four phases:
- 1. Intialise
- 2. Pre-time calculation loop
- 3. Calculation loop
- 4. Post-calculation loop
-
-\*---------------------------------------------------------------------------*/
-
-#include "timeSelector.H"
-#include "calcType.H"
-
-using namespace Foam;
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-int main(int argc, char *argv[])
-{
- Foam::timeSelector::addOptions();
- #include "addRegionOption.H"
- Foam::argList::addBoolOption
- (
- "noWrite",
- "suppress writing results"
- );
- #include "addDictOption.H"
-
- if (argc < 2)
- {
- FatalError
- << "No utility has been supplied" << nl
- << exit(FatalError);
- }
-
- const word utilityName = argv[1];
-
- Foam::autoPtr<Foam::calcType> utility
- (
- calcType::New(utilityName)
- );
-
- utility().tryInit();
-
- #include "setRootCase.H"
- #include "createTime.H"
- Foam::instantList timeDirs = Foam::timeSelector::select0(runTime, args);
- #include "createNamedMesh.H"
-
- utility().tryPreCalc(args, runTime, mesh);
-
- forAll(timeDirs, timeI)
- {
- runTime.setTime(timeDirs[timeI], timeI);
-
- Foam::Info<< "Time = " << runTime.timeName() << Foam::endl;
-
- mesh.readUpdate();
-
- utility().tryCalc(args, runTime, mesh);
-
- Foam::Info<< Foam::endl;
- }
-
- utility().tryPostCalc(args, runTime, mesh);
-
- Info<< "End\n" << endl;
-
- return 0;
-}
-
-
-// ************************************************************************* //
@@ -0,0 +1,3 @@
+postProcess.C
+
+EXE = $(FOAM_APPBIN)/postProcess
@@ -1,6 +1,5 @@
EXE_INC = \
- -I$(LIB_SRC)/lagrangian/basic/lnInclude \
- -I$(LIB_SRC)/lagrangian/DSMC/lnInclude \
+ -I$(LIB_SRC)/transportModels \
-I$(LIB_SRC)/transportModels \
-I$(LIB_SRC)/transportModels/incompressible/singlePhaseTransportModel \
-I$(LIB_SRC)/TurbulenceModels/turbulenceModels/lnInclude \
@@ -9,11 +8,11 @@ EXE_INC = \
-I$(LIB_SRC)/transportModels/compressible/lnInclude \
-I$(LIB_SRC)/thermophysicalModels/basic/lnInclude \
-I$(LIB_SRC)/finiteVolume/lnInclude \
+ -I$(LIB_SRC)/fvOptions/lnInclude \
-I$(LIB_SRC)/meshTools/lnInclude \
-I$(LIB_SRC)/sampling/lnInclude
-LIB_LIBS = \
- -lfvOptions \
+EXE_LIBS = \
-lturbulenceModels \
-lincompressibleTurbulenceModels \
-lcompressibleTurbulenceModels \
@@ -22,5 +21,7 @@ LIB_LIBS = \
-lfluidThermophysicalModels \
-lspecie \
-lfiniteVolume \
+ -lfvOptions \
+ -lgenericPatchFields \
-lmeshTools \
-lsampling
@@ -0,0 +1,202 @@
+/*---------------------------------------------------------------------------*\
+ ========= |
+ \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
+ \\ / O peration |
+ \\ / A nd | Copyright (C) 2016 OpenFOAM Foundation
+ \\/ M anipulation |
+-------------------------------------------------------------------------------
+License
+ This file is part of OpenFOAM.
+
+ 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.
+
+ OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
+
+Application
+ postProcess
+
+Description
+ Execute the set of functionObjects specified in the selected dictionary
+ (which defaults to system/controlDict) or on the command-line for the
+ selected set of times on the selected set of fields.
+
+\*---------------------------------------------------------------------------*/
+
+#include "argList.H"
+#include "timeSelector.H"
+#include "ReadFields.H"
+#include "volFields.H"
+#include "surfaceFields.H"
+#include "pointFields.H"
+#include "uniformDimensionedFields.H"
+
+using namespace Foam;
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#define ReadFields(GeoFieldType) \
+ readFields<GeoFieldType>(mesh, objects, selectedFields, storedObjects);
+
+#define ReadPointFields(GeoFieldType) \
+ readFields<GeoFieldType>(pMesh, objects, selectedFields, storedObjects);
+
+#define ReadUniformFields(FieldType) \
+ readUniformFields<FieldType> \
+ (constantObjects, selectedFields, storedObjects);
+
+void executeFunctionObjects
+(
+ const argList& args,
+ const Time& runTime,
+ fvMesh& mesh,
+ const HashSet<word>& selectedFields,
+ functionObjectList& functions
+)
+{
+ Info<< nl << "Reading fields:" << endl;
+
+ // Maintain a stack of the stored objects to clear after executing
+ // the functionObjects
+ LIFOStack<regIOobject*> storedObjects;
+
+ // Read objects in time directory
+ IOobjectList objects(mesh, runTime.timeName());
+
+ // Read volFields
+ ReadFields(volScalarField);
+ ReadFields(volVectorField);
+ ReadFields(volSphericalTensorField);
+ ReadFields(volSymmTensorField);
+ ReadFields(volTensorField);
+
+ // Read internal fields
+ ReadFields(volScalarField::Internal);
+ ReadFields(volVectorField::Internal);
+ ReadFields(volSphericalTensorField::Internal);
+ ReadFields(volSymmTensorField::Internal);
+ ReadFields(volTensorField::Internal);
+
+ // Read surface fields
+ ReadFields(surfaceScalarField);
+ ReadFields(surfaceVectorField);
+ ReadFields(surfaceSphericalTensorField);
+ ReadFields(surfaceSymmTensorField);
+ ReadFields(surfaceTensorField);
+
+ // Read point fields.
+ const pointMesh& pMesh = pointMesh::New(mesh);
+
+ ReadPointFields(pointScalarField)
+ ReadPointFields(pointVectorField);
+ ReadPointFields(pointSphericalTensorField);
+ ReadPointFields(pointSymmTensorField);
+ ReadPointFields(pointTensorField);
+
+ // Read uniform dimensioned fields
+ IOobjectList constantObjects(mesh, runTime.constant());
+
+ ReadUniformFields(uniformDimensionedScalarField);
+ ReadUniformFields(uniformDimensionedVectorField);
+ ReadUniformFields(uniformDimensionedSphericalTensorField);
+ ReadUniformFields(uniformDimensionedSymmTensorField);
+ ReadUniformFields(uniformDimensionedTensorField);
+
+ Info<< nl << "Executing functionObjects" << endl;
+
+ // Execute the functionObjects in post-processing mode
+ functions.execute(true);
+
+ while (!storedObjects.empty())
+ {
+ storedObjects.pop()->checkOut();
+ }
+}
+
+
+int main(int argc, char *argv[])
+{
+ Foam::timeSelector::addOptions();
+ #include "addRegionOption.H"
+ #include "addFunctionObjectOptions.H"
+
+ #include "setRootCase.H"
+ #include "createTime.H"
+ Foam::instantList timeDirs = Foam::timeSelector::select0(runTime, args);
+ #include "createNamedMesh.H"
+
+ // Initialize the set of selected fields from the command-line options
+ HashSet<word> selectedFields;
+ if (args.optionFound("fields"))
+ {
+ args.optionLookup("fields")() >> selectedFields;
+ }
+ if (args.optionFound("field"))
+ {
+ selectedFields.insert(args.optionLookup("field")());
+ }
+
+ // Externally stored dictionary for functionObjectList
+ // if not constructed from runTime
+ dictionary functionsDict;
+
+ // Construct functionObjectList
+ autoPtr<functionObjectList> functionsPtr
+ (
+ functionObjectList::New(args, runTime, functionsDict, selectedFields)
+ );
+
+ forAll(timeDirs, timeI)
+ {
+ runTime.setTime(timeDirs[timeI], timeI);
+
+ Info<< "Time = " << runTime.timeName() << endl;
+
+ if (mesh.readUpdate() != polyMesh::UNCHANGED)
+ {
+ // Update functionObjectList if mesh changes
+ functionsPtr = functionObjectList::New
+ (
+ args,
+ runTime,
+ functionsDict,
+ selectedFields
+ );
+ }
+
+ FatalIOError.throwExceptions();
+
+ try
+ {
+ executeFunctionObjects
+ (
+ args,
+ runTime,
+ mesh,
+ selectedFields,
+ functionsPtr()
+ );
+ }
+ catch (IOerror& err)
+ {
+ Warning<< err << endl;
+ }
+
+ Info<< endl;
+ }
+
+ Info<< "End\n" << endl;
+
+ return 0;
+}
+
+
+// ************************************************************************* //
Oops, something went wrong.

0 comments on commit 8b672f0

Please sign in to comment.