Add the OpenFOAM source tree

src/postProcessing/functionObjects/Allwmake

@@ -0,0 +1,15 @@
+#!/bin/sh
+cd ${0%/*} || exit 1    # run from this directory
+makeType=${1:-libso}
+set -x
+
+wmake $makeType cloud
+wmake $makeType field
+wmake $makeType forces
+wmake $makeType fvTools
+wmake $makeType IO
+wmake $makeType jobControl
+wmake $makeType systemCall
+wmake $makeType utilities
+
+# ----------------------------------------------------------------- end-of-file

src/postProcessing/functionObjects/IO/IOFunctionObjectsDoc.H

@@ -0,0 +1,30 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012-2013 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/>.
+
+\defgroup grpIOFunctionObjects Input/output function objects
+@{
+    \ingroup grpFunctionObjects
+    This group contains input/output-based function objects
+@}
+
+\*---------------------------------------------------------------------------*/

src/postProcessing/functionObjects/IO/Make/files

@@ -0,0 +1,13 @@
+partialWrite/partialWrite.C
+partialWrite/partialWriteFunctionObject.C
+
+removeRegisteredObject/removeRegisteredObject.C
+removeRegisteredObject/removeRegisteredObjectFunctionObject.C
+
+writeDictionary/writeDictionary.C
+writeDictionary/writeDictionaryFunctionObject.C
+
+writeRegisteredObject/writeRegisteredObject.C
+writeRegisteredObject/writeRegisteredObjectFunctionObject.C
+
+LIB = $(FOAM_LIBBIN)/libIOFunctionObjects

src/postProcessing/functionObjects/IO/Make/options

@@ -0,0 +1,7 @@
+EXE_INC = \
+    -I$(LIB_SRC)/finiteVolume/lnInclude \
+    -I$(LIB_SRC)/meshTools/lnInclude
+
+LIB_LIBS = \
+    -lfiniteVolume \
+    -lmeshTools

src/postProcessing/functionObjects/IO/controlDict

@@ -0,0 +1,122 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  dev                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    object      controlDict;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+// So we get a decent warning if we have multiple functionObject entries
+// with the same name.
+#inputMode error;
+
+application     icoFoam;
+
+startFrom       startTime;
+
+startTime       0;
+
+stopAt          endTime;
+
+endTime         0.5;
+
+deltaT          0.005;
+
+writeControl    timeStep;
+
+writeInterval   20;
+
+purgeWrite      0;
+
+writeFormat     ascii;
+
+writePrecision  6;
+
+writeCompression uncompressed;
+
+timeFormat      general;
+
+timePrecision   6;
+
+runTimeModifiable yes;
+
+functions
+{
+    partialWrite
+    {
+        // Write some registered objects more often than others.
+        // Above writeControl determines most frequent dump.
+
+        type            partialWrite;
+
+        // Where to load it from
+        functionObjectLibs ("libIOFunctionObjects.so");
+
+        // Optional mesh region to operate on. Only one partialWrite per
+        // region allowed.
+        region wallFilmRegion;
+
+        // Execute upon options:
+        //  timeStep
+        //  outputTime
+        //  adjustableTime
+        //  runTime
+        //  clockTime
+        //  cpuTime
+        outputControl   outputTime;
+
+        // Objects (fields or lagrangian fields in any of the clouds)
+        // to write every outputTime
+        objectNames    (p positions nParticle);
+
+        // Write as normal every writeInterval'th outputTime.
+        outputInterval  1; // (timeStep, outputTime)
+
+        // Interval of time (sec) to write down(
+        writeInterval   10.5 //(adjustableTime, runTime, clockTime, cpuTime)
+    }
+
+    dumpObjects
+    {
+        // Forcibly write registered objects
+
+        type            writeRegisteredObject;
+
+        // Where to load it from
+        functionObjectLibs ("libIOFunctionObjects.so");
+
+        // When to write:
+        //  timeStep            (with optional outputInterval)
+        //  outputTime          (with optional outputInterval)
+        //  adjustableTime
+        //  runTime
+        //  clockTime
+        //  cpuTime
+        outputControl   outputTime;
+
+         // Write every writeInterval (only valid for timeStemp, outputTime)
+        outputInterval  1;
+
+         // Interval of time (valid for adjustableTime, runTime, clockTime,
+        //  cpuTime)
+        writeInterval   10.5;
+
+        // Objects to write
+        objectNames    ();
+
+
+        // Is the object written by this function Object alone
+        // (default is false)
+        //exclusiveWriting       true;
+    }
+}
+
+// ************************************************************************* //

src/postProcessing/functionObjects/IO/partialWrite/IOpartialWrite.H

@@ -0,0 +1,49 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 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/>.
+
+Typedef
+    Foam::IOpartialWrite
+
+Description
+    Instance of the generic IOOutputFilter for partialWrite.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef IOpartialWrite_H
+#define IOpartialWrite_H
+
+#include "partialWrite.H"
+#include "IOOutputFilter.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    typedef IOOutputFilter<partialWrite> IOpartialWrite;
+}
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/postProcessing/functionObjects/IO/partialWrite/partialWrite.C

@@ -0,0 +1,181 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2014 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "partialWrite.H"
+#include "dictionary.H"
+#include "Time.H"
+#include "IOobjectList.H"
+#include "polyMesh.H"
+#include "cloud.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(partialWrite, 0);
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::partialWrite::partialWrite
+(
+    const word& name,
+    const objectRegistry& obr,
+    const dictionary& dict,
+    const bool loadFromFiles
+)
+:
+    name_(name),
+    obr_(obr)
+{
+    read(dict);
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::partialWrite::~partialWrite()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+void Foam::partialWrite::read(const dictionary& dict)
+{
+    dict.lookup("objectNames") >> objectNames_;
+    dict.lookup("writeInterval") >> writeInterval_;
+    writeInstance_ = 0;
+
+    Info<< type() << " " << name() << ":" << nl
+        << "    dumping every " << writeInterval_
+        << " th outputTime : " << nl << endl ;
+    forAllConstIter(HashSet<word>, objectNames_, iter)
+    {
+        Info<< ' ' << iter.key();
+    }
+
+    if (writeInterval_ < 1)
+    {
+        FatalIOErrorIn("partialWrite::read(const dictionary&)", dict)
+            << "Illegal value for writeInterval " << writeInterval_
+            << ". It should be >= 1."
+            << exit(FatalIOError);
+    }
+
+    // Clear out any previously loaded fields
+    vsf_.clear();
+    vvf_.clear();
+    vSpheretf_.clear();
+    vSymmtf_.clear();
+    vtf_.clear();
+
+    ssf_.clear();
+    svf_.clear();
+    sSpheretf_.clear();
+    sSymmtf_.clear();
+    stf_.clear();
+
+    forAllConstIter(HashSet<word>, objectNames_, iter)
+    {
+        loadField<scalar>(iter.key(), vsf_, ssf_);
+        loadField<vector>(iter.key(), vvf_, svf_);
+        loadField<sphericalTensor>(iter.key(), vSpheretf_, sSpheretf_);
+        loadField<symmTensor>(iter.key(), vSymmtf_, sSymmtf_);
+        loadField<tensor>(iter.key(), vtf_, stf_);
+    }
+}
+
+
+void Foam::partialWrite::execute()
+{
+}
+
+
+void Foam::partialWrite::end()
+{
+    //Pout<< "end at time " << obr_.time().timeName() << endl;
+    // Do nothing - only valid on write
+}
+
+
+void Foam::partialWrite::timeSet()
+{
+    if (obr_.time().outputTime())
+    {
+        writeInstance_++;
+
+        if (writeInstance_ == writeInterval_)
+        {
+            // Next overall dump corresponds to partial write. Change
+            // write options to AUTO_WRITE
+            writeInstance_ = 0;
+
+            changeWriteOptions<scalar>(vsf_, ssf_, IOobject::AUTO_WRITE);
+            changeWriteOptions<vector>(vvf_, svf_, IOobject::AUTO_WRITE);
+            changeWriteOptions<sphericalTensor>
+            (
+                vSpheretf_,
+                sSpheretf_,
+                IOobject::AUTO_WRITE
+            );
+            changeWriteOptions<symmTensor>
+            (
+                vSymmtf_,
+                sSymmtf_,
+                IOobject::AUTO_WRITE
+            );
+            changeWriteOptions<tensor>(vtf_, stf_, IOobject::AUTO_WRITE);
+        }
+        else
+        {
+            changeWriteOptions<scalar>(vsf_, ssf_, IOobject::NO_WRITE);
+            changeWriteOptions<vector>(vvf_, svf_, IOobject::NO_WRITE);
+            changeWriteOptions<sphericalTensor>
+            (
+                vSpheretf_,
+                sSpheretf_,
+                IOobject::NO_WRITE
+            );
+            changeWriteOptions<symmTensor>
+            (
+                vSymmtf_,
+                sSymmtf_,
+                IOobject::NO_WRITE
+            );
+            changeWriteOptions<tensor>(vtf_, stf_, IOobject::NO_WRITE);
+        }
+    }
+}
+
+
+void Foam::partialWrite::write()
+{
+    // Do nothing. The fields get written through the
+    // standard dump
+}
+
+
+// ************************************************************************* //

src/postProcessing/functionObjects/IO/partialWrite/partialWrite.H

@@ -0,0 +1,223 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2013 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/>.
+
+Class
+    Foam::partialWrite
+
+Group
+    grpIOFunctionObjects
+
+Description
+    This function object allows user-selected fields/registered objects to be
+    written at a custom write interval. The interval is given in terms of
+    number of overall dumps
+
+    Example of function object specification:
+    \verbatim
+    partialWrite1
+    {
+        type        partialWrite;
+        functionObjectLibs ("libIOFunctionObjects.so");
+        ...
+        objectNames (p U T);
+        writeInterval 100;
+    }
+    \endverbatim
+
+    \heading Function object usage
+    \table
+        Property     | Description             | Required    | Default value
+        type         | type name: partialWrite | yes         |
+        objectNames  | objects to write        | yes         |
+        writeInterval | write interval         | yes         |
+    \endtable
+
+SeeAlso
+    Foam::functionObject
+    Foam::OutputFilterFunctionObject
+
+SourceFiles
+    partialWrite.C
+    IOpartialWrite.H
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef partialWrite_H
+#define partialWrite_H
+
+#include "HashSet.H"
+#include "runTimeSelectionTables.H"
+#include "volFields.H"
+#include "surfaceFields.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// Forward declaration of classes
+class objectRegistry;
+class dictionary;
+class polyMesh;
+class mapPolyMesh;
+
+/*---------------------------------------------------------------------------*\
+                        Class partialWrite Declaration
+\*---------------------------------------------------------------------------*/
+
+class partialWrite
+{
+protected:
+
+    // Private data
+
+        //- Name of this set of partialWrite
+        word name_;
+
+        const objectRegistry& obr_;
+
+        //- Loaded fields
+        UPtrList<volScalarField> vsf_;
+        UPtrList<volVectorField> vvf_;
+        UPtrList<volSphericalTensorField> vSpheretf_;
+        UPtrList<volSymmTensorField> vSymmtf_;
+        UPtrList<volTensorField> vtf_;
+
+        UPtrList<surfaceScalarField> ssf_;
+        UPtrList<surfaceVectorField> svf_;
+        UPtrList<surfaceSphericalTensorField> sSpheretf_;
+        UPtrList<surfaceSymmTensorField> sSymmtf_;
+        UPtrList<surfaceTensorField> stf_;
+
+        // Read from dictionary
+
+            //- Names of objects to dump always
+            HashSet<word> objectNames_;
+
+            //- Write interval for restart dump
+            label writeInterval_;
+
+
+
+        //- Current dump instance. If reaches writeInterval do a full write.
+        label writeInstance_;
+
+
+    // Private Member Functions
+
+        //- Disallow default bitwise copy construct
+        partialWrite(const partialWrite&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const partialWrite&);
+
+
+        //- Load objects in the objectNames
+        template<class Type>
+        void loadField
+        (
+            const word&,
+            UPtrList<GeometricField<Type, fvPatchField, volMesh> >&,
+            UPtrList<GeometricField<Type, fvsPatchField, surfaceMesh> >&
+        ) const;
+
+        template<class Type>
+        void changeWriteOptions
+        (
+            UPtrList<GeometricField<Type, fvPatchField, volMesh> >&,
+            UPtrList<GeometricField<Type, fvsPatchField, surfaceMesh> >&,
+            const IOobject::writeOption
+        ) const;
+
+
+public:
+
+    //- Runtime type information
+    TypeName("partialWrite");
+
+
+    // Constructors
+
+        //- Construct for given objectRegistry and dictionary.
+        //  Allow the possibility to load fields from files
+        partialWrite
+        (
+            const word& name,
+            const objectRegistry&,
+            const dictionary&,
+            const bool loadFromFiles = false
+        );
+
+
+    //- Destructor
+    virtual ~partialWrite();
+
+
+    // Member Functions
+
+        //- Return name of the partialWrite
+        virtual const word& name() const
+        {
+            return name_;
+        }
+
+        //- Read the partialWrite data
+        virtual void read(const dictionary&);
+
+        //- Execute
+        virtual void execute();
+
+        //- Execute at the final time-loop, currently does nothing
+        virtual void end();
+
+        //- Called when time was set at the end of the Time::operator++
+        virtual void timeSet();
+
+        //- Write the partialWrite
+        virtual void write();
+
+        //- Update for changes of mesh
+        virtual void updateMesh(const mapPolyMesh&)
+        {}
+
+        //- Update for changes of mesh
+        virtual void movePoints(const polyMesh&)
+        {}
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+#   include "partialWriteTemplates.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/postProcessing/functionObjects/IO/partialWrite/partialWriteFunctionObject.C

@@ -0,0 +1,46 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "partialWriteFunctionObject.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineNamedTemplateTypeNameAndDebug
+    (
+        partialWriteFunctionObject,
+        0
+    );
+
+    addToRunTimeSelectionTable
+    (
+        functionObject,
+        partialWriteFunctionObject,
+        dictionary
+    );
+}
+
+// ************************************************************************* //

src/postProcessing/functionObjects/IO/partialWrite/partialWriteFunctionObject.H

@@ -0,0 +1,54 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 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/>.
+
+Typedef
+    Foam::partialWriteFunctionObject
+
+Description
+    FunctionObject wrapper around partialWrite to allow them to be
+    created via the functions list within controlDict.
+
+SourceFiles
+    partialWriteFunctionObject.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef partialWriteFunctionObject_H
+#define partialWriteFunctionObject_H
+
+#include "partialWrite.H"
+#include "OutputFilterFunctionObject.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    typedef OutputFilterFunctionObject<partialWrite>
+        partialWriteFunctionObject;
+}
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/postProcessing/functionObjects/IO/partialWrite/partialWriteTemplates.C

@@ -0,0 +1,105 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "partialWrite.H"
+#include "volFields.H"
+#include "surfaceFields.H"
+#include "Time.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+template<class Type>
+void Foam::partialWrite::loadField
+(
+    const word& fieldName,
+    UPtrList<GeometricField<Type, fvPatchField, volMesh> >& vflds,
+    UPtrList<GeometricField<Type, fvsPatchField, surfaceMesh> >& sflds
+) const
+{
+    typedef GeometricField<Type, fvPatchField, volMesh> vfType;
+    typedef GeometricField<Type, fvsPatchField, surfaceMesh> sfType;
+
+    if (obr_.foundObject<vfType>(fieldName))
+    {
+        if (debug)
+        {
+            Info<< "partialWrite : Field "
+                << fieldName << " found in database" << endl;
+        }
+
+        vfType& vField =
+            const_cast<vfType&>
+            (
+                obr_.lookupObject<vfType>(fieldName)
+            );
+
+
+        const unsigned int sz = vflds.size();
+        vflds.setSize(sz + 1);
+        vflds.set(sz, &vField);
+    }
+    else if (obr_.foundObject<sfType>(fieldName))
+    {
+        if (debug)
+        {
+            Info<< "partialWrite : Field " << fieldName
+                << " found in database" << endl;
+        }
+
+         sfType& sField =
+            const_cast<sfType&>
+            (
+                obr_.lookupObject<sfType>(fieldName)
+            );
+
+
+        const unsigned int sz = sflds.size();
+        sflds.setSize(sz + 1);
+        sflds.set(sz, &sField);
+    }
+}
+
+
+template<class Type>
+void Foam::partialWrite::changeWriteOptions
+(
+    UPtrList<GeometricField<Type, fvPatchField, volMesh> >& vflds,
+    UPtrList<GeometricField<Type, fvsPatchField, surfaceMesh> >& sflds,
+    const IOobject::writeOption wOption
+) const
+{
+    forAll(vflds , i)
+    {
+        vflds[i].writeOpt() = wOption;
+    }
+
+    forAll(sflds , i)
+    {
+        sflds[i].writeOpt() = wOption;
+    }
+}
+
+
+// ************************************************************************* //

src/postProcessing/functionObjects/IO/removeRegisteredObject/IOremoveRegisteredObject.H

@@ -0,0 +1,49 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012 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/>.
+
+Typedef
+    Foam::IOremoveRegisteredObject
+
+Description
+    Instance of the generic IOOutputFilter for removeRegisteredObject.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef IOremoveRegisteredObject_H
+#define IOremoveRegisteredObject_H
+
+#include "removeRegisteredObject.H"
+#include "IOOutputFilter.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    typedef IOOutputFilter<removeRegisteredObject> IOremoveRegisteredObject;
+}
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/postProcessing/functionObjects/IO/removeRegisteredObject/removeRegisteredObject.C

@@ -0,0 +1,111 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013-2014 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "removeRegisteredObject.H"
+#include "dictionary.H"
+#include "Time.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+defineTypeNameAndDebug(removeRegisteredObject, 0);
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::removeRegisteredObject::removeRegisteredObject
+(
+    const word& name,
+    const objectRegistry& obr,
+    const dictionary& dict,
+    const bool loadFromFiles
+)
+:
+    name_(name),
+    obr_(obr),
+    objectNames_()
+{
+    read(dict);
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::removeRegisteredObject::~removeRegisteredObject()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+void Foam::removeRegisteredObject::read(const dictionary& dict)
+{
+    dict.lookup("objectNames") >> objectNames_;
+}
+
+
+void Foam::removeRegisteredObject::execute()
+{
+    forAll(objectNames_, i)
+    {
+        if (obr_.foundObject<regIOobject>(objectNames_[i]))
+        {
+            const regIOobject& obj =
+                obr_.lookupObject<regIOobject>(objectNames_[i]);
+
+            if (obj.ownedByRegistry())
+            {
+                Info<< type() << " " << name_ << " output:" << nl
+                    << "    removing object " << obj.name() << nl
+                    << endl;
+
+                const_cast<regIOobject&>(obj).release();
+                delete &obj;
+            }
+        }
+    }
+}
+
+
+void Foam::removeRegisteredObject::end()
+{
+    execute();
+}
+
+
+void Foam::removeRegisteredObject::timeSet()
+{
+    // Do nothing - only valid on execute
+}
+
+
+void Foam::removeRegisteredObject::write()
+{
+    // Do nothing - only valid on execute
+}
+
+
+// ************************************************************************* //

src/postProcessing/functionObjects/IO/removeRegisteredObject/removeRegisteredObject.H

@@ -0,0 +1,173 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 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/>.
+
+Class
+    Foam::removeRegisteredObject
+
+Group
+    grpIOFunctionObjects
+
+Description
+    This function object removes registered objects if present in the database
+
+    Example of function object specification:
+    \verbatim
+    removeRegisteredObject1
+    {
+        type        removeRegisteredObject;
+        functionObjectLibs ("libIOFunctionObjects.so");
+        ...
+        objectNames (obj1 obj2);
+    }
+    \endverbatim
+
+    \heading Function object usage
+    \table
+        Property     | Description             | Required    | Default value
+        type         | type name: removeRegisteredObject | yes |
+        objectNames  | objects to remove       | yes         |
+    \endtable
+
+SeeAlso
+    Foam::functionObject
+    Foam::OutputFilterFunctionObject
+
+SourceFiles
+    removeRegisteredObject.C
+    IOremoveRegisteredObject.H
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef removeRegisteredObject_H
+#define removeRegisteredObject_H
+
+#include "wordList.H"
+#include "runTimeSelectionTables.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// Forward declaration of classes
+class objectRegistry;
+class dictionary;
+class polyMesh;
+class mapPolyMesh;
+
+/*---------------------------------------------------------------------------*\
+                   Class removeRegisteredObject Declaration
+\*---------------------------------------------------------------------------*/
+
+class removeRegisteredObject
+{
+protected:
+
+    // Private data
+
+        //- Name of this set of removeRegisteredObject
+        word name_;
+
+        const objectRegistry& obr_;
+
+        // Read from dictionary
+
+            //- Names of objects to control
+            wordList objectNames_;
+
+
+    // Private Member Functions
+
+
+        //- Disallow default bitwise copy construct
+        removeRegisteredObject(const removeRegisteredObject&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const removeRegisteredObject&);
+
+
+public:
+
+    //- Runtime type information
+    TypeName("removeRegisteredObject");
+
+
+    // Constructors
+
+        //- Construct for given objectRegistry and dictionary.
+        //  Allow the possibility to load fields from files
+        removeRegisteredObject
+        (
+            const word& name,
+            const objectRegistry&,
+            const dictionary&,
+            const bool loadFromFiles = false
+        );
+
+
+    //- Destructor
+    virtual ~removeRegisteredObject();
+
+
+    // Member Functions
+
+        //- Return name of the removeRegisteredObject
+        virtual const word& name() const
+        {
+            return name_;
+        }
+
+        //- Read the removeRegisteredObject data
+        virtual void read(const dictionary&);
+
+        //- Execute, currently does nothing
+        virtual void execute();
+
+        //- Execute at the final time-loop, currently does nothing
+        virtual void end();
+
+        //- Called when time was set at the end of the Time::operator++
+        virtual void timeSet();
+
+        //- Write the removeRegisteredObject
+        virtual void write();
+
+        //- Update for changes of mesh
+        virtual void updateMesh(const mapPolyMesh&)
+        {}
+
+        //- Update for changes of mesh
+        virtual void movePoints(const polyMesh&)
+        {}
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/postProcessing/functionObjects/IO/removeRegisteredObject/removeRegisteredObjectFunctionObject.C

@@ -0,0 +1,46 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "removeRegisteredObjectFunctionObject.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineNamedTemplateTypeNameAndDebug
+    (
+        removeRegisteredObjectFunctionObject,
+        0
+    );
+
+    addToRunTimeSelectionTable
+    (
+        functionObject,
+        removeRegisteredObjectFunctionObject,
+        dictionary
+    );
+}
+
+// ************************************************************************* //

src/postProcessing/functionObjects/IO/removeRegisteredObject/removeRegisteredObjectFunctionObject.H

@@ -0,0 +1,54 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012 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/>.
+
+Typedef
+    Foam::removeRegisteredObjectFunctionObject
+
+Description
+    FunctionObject wrapper around removeRegisteredObject to allow them to be
+    created via the functions entry within controlDict.
+
+SourceFiles
+    removeRegisteredObjectFunctionObject.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef removeRegisteredObjectFunctionObject_H
+#define removeRegisteredObjectFunctionObject_H
+
+#include "removeRegisteredObject.H"
+#include "OutputFilterFunctionObject.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    typedef OutputFilterFunctionObject<removeRegisteredObject>
+        removeRegisteredObjectFunctionObject;
+}
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/postProcessing/functionObjects/IO/writeDictionary/IOwriteDictionary.H

@@ -0,0 +1,49 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012 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/>.
+
+Typedef
+    Foam::IOwriteDictionary
+
+Description
+    Instance of the generic IOOutputFilter for writeDictionary.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef IOwriteDictionary_H
+#define IOwriteDictionary_H
+
+#include "writeDictionary.H"
+#include "IOOutputFilter.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    typedef IOOutputFilter<writeDictionary> IOwriteDictionary;
+}
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/postProcessing/functionObjects/IO/writeDictionary/writeDictionary.C

@@ -0,0 +1,214 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013-2014 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "writeDictionary.H"
+#include "dictionary.H"
+#include "Time.H"
+#include "HashSet.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+defineTypeNameAndDebug(writeDictionary, 0);
+}
+
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+bool Foam::writeDictionary::tryDirectory
+(
+    const label dictI,
+    const word& location,
+    bool& firstDict
+)
+{
+    IOobject dictIO
+    (
+        dictNames_[dictI],
+        location,
+        obr_,
+        IOobject::MUST_READ,
+        IOobject::NO_WRITE,
+        false
+    );
+
+    if (dictIO.headerOk())
+    {
+        IOdictionary dict(dictIO);
+
+        if (dict.digest() != digests_[dictI])
+        {
+            if (firstDict)
+            {
+                Info<< type() << " " << name_ << " output:" << nl << endl;
+
+                IOobject::writeDivider(Info);
+                Info<< endl;
+                firstDict = false;
+            }
+
+            Info<< dict.dictName() << dict << nl;
+
+            IOobject::writeDivider(Info);
+
+            digests_[dictI] = dict.digest();
+        }
+
+        return true;
+    }
+
+    return false;
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::writeDictionary::writeDictionary
+(
+    const word& name,
+    const objectRegistry& obr,
+    const dictionary& dict,
+    const bool loadFromFiles
+)
+:
+    name_(name),
+    obr_(obr),
+    dictNames_(),
+    digests_()
+{
+    read(dict);
+
+    execute();
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::writeDictionary::~writeDictionary()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+void Foam::writeDictionary::read(const dictionary& dict)
+{
+    wordList dictNames(dict.lookup("dictNames"));
+    HashSet<word> uniqueNames(dictNames);
+    dictNames_ = uniqueNames.toc();
+
+    digests_.setSize(dictNames_.size(), SHA1Digest());
+
+    Info<< type() << " " << name_ << ": monitoring dictionaries:" << nl;
+    if (dictNames_.size())
+    {
+        forAll(dictNames_, i)
+        {
+            Info<< "    " << dictNames_[i] << endl;
+        }
+    }
+    else
+    {
+        Info<< "    none" << nl;
+    }
+    Info<< endl;
+}
+
+
+void Foam::writeDictionary::execute()
+{
+    bool firstDict = true;
+    forAll(dictNames_, i)
+    {
+        if (obr_.foundObject<dictionary>(dictNames_[i]))
+        {
+            const dictionary& dict =
+                obr_.lookupObject<dictionary>(dictNames_[i]);
+
+            if (dict.digest() != digests_[i])
+            {
+                if (firstDict)
+                {
+                    Info<< type() << " " << name_ << " output:" << nl << endl;
+
+                    IOobject::writeDivider(Info);
+                    Info<< endl;
+                    firstDict = false;
+                }
+
+                digests_[i] = dict.digest();
+
+                Info<< dict.dictName() << dict << nl;
+                IOobject::writeDivider(Info);
+                Info<< endl;
+            }
+        }
+        else
+        {
+            bool processed = tryDirectory(i, obr_.time().timeName(), firstDict);
+
+            if (!processed)
+            {
+                processed = tryDirectory(i, obr_.time().constant(), firstDict);
+            }
+
+            if (!processed)
+            {
+                processed = tryDirectory(i, obr_.time().system(), firstDict);
+            }
+
+            if (!processed)
+            {
+                Info<< "    Unable to locate dictionary " << dictNames_[i]
+                    << nl << endl;
+            }
+            else
+            {
+                Info<< endl;
+            }
+        }
+    }
+}
+
+
+void Foam::writeDictionary::end()
+{
+    execute();
+}
+
+
+void Foam::writeDictionary::timeSet()
+{
+    // do nothing
+}
+
+
+void Foam::writeDictionary::write()
+{
+    // do nothing
+}
+
+
+// ************************************************************************* //

src/postProcessing/functionObjects/IO/writeDictionary/writeDictionary.H

@@ -0,0 +1,161 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013-2014 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/>.
+
+Class
+    Foam::writeDictionary
+
+Group
+    grpUtilitiesFunctionObjects
+
+Description
+    This function object writes dictionaries on start-up, and on change
+
+SourceFiles
+    writeDictionary.C
+    IOwriteDictionary.H
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef writeDictionary_H
+#define writeDictionary_H
+
+#include "wordList.H"
+#include "runTimeSelectionTables.H"
+#include "SHA1Digest.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// Forward declaration of classes
+class objectRegistry;
+class dictionary;
+class polyMesh;
+class mapPolyMesh;
+
+/*---------------------------------------------------------------------------*\
+                       Class writeDictionary Declaration
+\*---------------------------------------------------------------------------*/
+
+class writeDictionary
+{
+protected:
+
+    // Private data
+
+        //- Name of this set of writeDictionary
+        word name_;
+
+        //- Reference to the database
+        const objectRegistry& obr_;
+
+        //- Names of dictionaries to monitor
+        wordList dictNames_;
+
+        //- List of changed dictionaries (only those registered to database)
+        List<SHA1Digest> digests_;
+
+
+    // Private Member Functions
+
+        //- Helper function to write the dictionary if found at location
+        bool tryDirectory
+        (
+            const label dictI,
+            const word& location,
+            bool& firstDict
+        );
+
+        //- Disallow default bitwise copy construct
+        writeDictionary(const writeDictionary&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const writeDictionary&);
+
+
+public:
+
+    //- Runtime type information
+    TypeName("writeDictionary");
+
+
+    // Constructors
+
+        //- Construct for given objectRegistry and dictionary.
+        //  Allow the possibility to load fields from files
+        writeDictionary
+        (
+            const word& name,
+            const objectRegistry&,
+            const dictionary&,
+            const bool loadFromFiles = false
+        );
+
+
+    //- Destructor
+    virtual ~writeDictionary();
+
+
+    // Member Functions
+
+        //- Return name of the writeDictionary
+        virtual const word& name() const
+        {
+            return name_;
+        }
+
+        //- Read the writeDictionary data
+        virtual void read(const dictionary&);
+
+        //- Execute, currently does nothing
+        virtual void execute();
+
+        //- Execute at the final time-loop, currently does nothing
+        virtual void end();
+
+        //- Called when time was set at the end of the Time::operator++
+        virtual void timeSet();
+
+        //- Write the writeDictionary
+        virtual void write();
+
+        //- Update for changes of mesh
+        virtual void updateMesh(const mapPolyMesh&)
+        {}
+
+        //- Update for changes of mesh
+        virtual void movePoints(const polyMesh&)
+        {}
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/postProcessing/functionObjects/IO/writeDictionary/writeDictionaryFunctionObject.C

@@ -0,0 +1,42 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "writeDictionaryFunctionObject.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineNamedTemplateTypeNameAndDebug(writeDictionaryFunctionObject, 0);
+
+    addToRunTimeSelectionTable
+    (
+        functionObject,
+        writeDictionaryFunctionObject,
+        dictionary
+    );
+}
+
+// ************************************************************************* //

src/postProcessing/functionObjects/IO/writeDictionary/writeDictionaryFunctionObject.H

@@ -0,0 +1,54 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012 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/>.
+
+Typedef
+    Foam::writeDictionaryFunctionObject
+
+Description
+    FunctionObject wrapper around writeDictionary to allow them to be
+    created via the functions entry within controlDict.
+
+SourceFiles
+    writeDictionaryFunctionObject.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef writeDictionaryFunctionObject_H
+#define writeDictionaryFunctionObject_H
+
+#include "writeDictionary.H"
+#include "OutputFilterFunctionObject.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    typedef OutputFilterFunctionObject<writeDictionary>
+        writeDictionaryFunctionObject;
+}
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/postProcessing/functionObjects/IO/writeRegisteredObject/IOwriteRegisteredObject.H

@@ -0,0 +1,49 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 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/>.
+
+Typedef
+    Foam::IOwriteRegisteredObject
+
+Description
+    Instance of the generic IOOutputFilter for writeRegisteredObject.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef IOwriteRegisteredObject_H
+#define IOwriteRegisteredObject_H
+
+#include "writeRegisteredObject.H"
+#include "IOOutputFilter.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    typedef IOOutputFilter<writeRegisteredObject> IOwriteRegisteredObject;
+}
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/postProcessing/functionObjects/IO/writeRegisteredObject/writeRegisteredObject.C

@@ -0,0 +1,133 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2013 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "writeRegisteredObject.H"
+#include "dictionary.H"
+#include "Time.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+defineTypeNameAndDebug(writeRegisteredObject, 0);
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::writeRegisteredObject::writeRegisteredObject
+(
+    const word& name,
+    const objectRegistry& obr,
+    const dictionary& dict,
+    const bool loadFromFiles
+)
+:
+    name_(name),
+    exclusiveWriting_(false),
+    obr_(obr),
+    objectNames_()
+{
+    read(dict);
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::writeRegisteredObject::~writeRegisteredObject()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+void Foam::writeRegisteredObject::read(const dictionary& dict)
+{
+    dict.lookup("objectNames") >> objectNames_;
+    dict.readIfPresent("exclusiveWriting", exclusiveWriting_);
+}
+
+
+void Foam::writeRegisteredObject::execute()
+{
+    // Do nothing - only valid on write
+}
+
+
+void Foam::writeRegisteredObject::end()
+{
+    // Do nothing - only valid on write
+}
+
+
+void Foam::writeRegisteredObject::timeSet()
+{
+    // Do nothing - only valid on write
+}
+
+
+void Foam::writeRegisteredObject::write()
+{
+    Info<< type() << " " << name_ << " output:" << nl;
+
+    DynamicList<word> allNames(obr_.toc().size());
+    forAll(objectNames_, i)
+    {
+        wordList names(obr_.names<regIOobject>(objectNames_[i]));
+
+        if (names.size())
+        {
+            allNames.append(names);
+        }
+        else
+        {
+            WarningIn("Foam::writeRegisteredObject::write()")
+                << "Object " << objectNames_[i] << " not found in "
+                << "database. Available objects:" << nl << obr_.sortedToc()
+                << endl;
+        }
+    }
+
+    forAll(allNames, i)
+    {
+        regIOobject& obj =
+            const_cast<regIOobject&>
+            (
+                obr_.lookupObject<regIOobject>(allNames[i])
+            );
+
+        if (exclusiveWriting_)
+        {
+            // Switch off automatic writing to prevent double write
+            obj.writeOpt() = IOobject::NO_WRITE;
+        }
+
+        Info<< "    writing object " << obj.name() << nl << endl;
+
+        obj.write();
+    }
+}
+
+
+// ************************************************************************* //

src/postProcessing/functionObjects/IO/writeRegisteredObject/writeRegisteredObject.H

@@ -0,0 +1,190 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2013 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/>.
+
+Class
+    Foam::writeRegisteredObject
+
+Group
+    grpIOFunctionObjects
+
+Description
+    This function object allows specification of different writing frequency
+    of objects registered to the database. It has similar functionality
+    as the main time database through the outputControl setting:
+        timeStep
+        outputTime
+        adjustableTime
+        runTime
+        clockTime
+        cpuTime
+
+    Example of function object specification:
+    \verbatim
+    writeRegisteredObject1
+    {
+        type        writeRegisteredObject;
+        functionObjectLibs ("libIOFunctionObjects.so");
+        exclusiveWriting     true;
+        ...
+        objectNames (obj1 obj2);
+    }
+    \endverbatim
+
+    \heading Function object usage
+    \table
+        Property     | Description             | Required    | Default value
+        type         | type name: writeRegisteredObject | yes |
+        objectNames  | objects to write        | yes         |
+        exclusiveWriting    | Takes over object writing | no | yes
+    \endtable
+
+    exclusiveWriting disables automatic writing (i.e through database) of the
+    objects to avoid duplicate writing.
+
+SeeAlso
+    Foam::functionObject
+    Foam::OutputFilterFunctionObject
+
+SourceFiles
+    writeRegisteredObject.C
+    IOwriteRegisteredObject.H
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef writeRegisteredObject_H
+#define writeRegisteredObject_H
+
+#include "wordReList.H"
+#include "runTimeSelectionTables.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// Forward declaration of classes
+class objectRegistry;
+class dictionary;
+class polyMesh;
+class mapPolyMesh;
+
+/*---------------------------------------------------------------------------*\
+                   Class writeRegisteredObject Declaration
+\*---------------------------------------------------------------------------*/
+
+class writeRegisteredObject
+{
+protected:
+
+    // Private data
+
+        //- Name of this set of writeRegisteredObject
+        word name_;
+
+        //- Takes over the writing from Db
+        bool exclusiveWriting_;
+
+        //- Refererence to Db
+        const objectRegistry& obr_;
+
+        // Read from dictionary
+
+            //- Names of objects to control
+            wordReList objectNames_;
+
+
+    // Private Member Functions
+
+
+        //- Disallow default bitwise copy construct
+        writeRegisteredObject(const writeRegisteredObject&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const writeRegisteredObject&);
+
+
+public:
+
+    //- Runtime type information
+    TypeName("writeRegisteredObject");
+
+
+    // Constructors
+
+        //- Construct for given objectRegistry and dictionary.
+        //  Allow the possibility to load fields from files
+        writeRegisteredObject
+        (
+            const word& name,
+            const objectRegistry&,
+            const dictionary&,
+            const bool loadFromFiles = false
+        );
+
+
+    //- Destructor
+    virtual ~writeRegisteredObject();
+
+
+    // Member Functions
+
+        //- Return name of the writeRegisteredObject
+        virtual const word& name() const
+        {
+            return name_;
+        }
+
+        //- Read the writeRegisteredObject data
+        virtual void read(const dictionary&);
+
+        //- Execute, currently does nothing
+        virtual void execute();
+
+        //- Execute at the final time-loop, currently does nothing
+        virtual void end();
+
+        //- Called when time was set at the end of the Time::operator++
+        virtual void timeSet();
+
+        //- Write the writeRegisteredObject
+        virtual void write();
+
+        //- Update for changes of mesh
+        virtual void updateMesh(const mapPolyMesh&)
+        {}
+
+        //- Update for changes of mesh
+        virtual void movePoints(const polyMesh&)
+        {}
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/postProcessing/functionObjects/IO/writeRegisteredObject/writeRegisteredObjectFunctionObject.C

@@ -0,0 +1,46 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "writeRegisteredObjectFunctionObject.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineNamedTemplateTypeNameAndDebug
+    (
+        writeRegisteredObjectFunctionObject,
+        0
+    );
+
+    addToRunTimeSelectionTable
+    (
+        functionObject,
+        writeRegisteredObjectFunctionObject,
+        dictionary
+    );
+}
+
+// ************************************************************************* //

src/postProcessing/functionObjects/IO/writeRegisteredObject/writeRegisteredObjectFunctionObject.H

@@ -0,0 +1,54 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 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/>.
+
+Typedef
+    Foam::writeRegisteredObjectFunctionObject
+
+Description
+    FunctionObject wrapper around writeRegisteredObject to allow them to be
+    created via the functions entry within controlDict.
+
+SourceFiles
+    writeRegisteredObjectFunctionObject.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef writeRegisteredObjectFunctionObject_H
+#define writeRegisteredObjectFunctionObject_H
+
+#include "writeRegisteredObject.H"
+#include "OutputFilterFunctionObject.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    typedef OutputFilterFunctionObject<writeRegisteredObject>
+        writeRegisteredObjectFunctionObject;
+}
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/postProcessing/functionObjects/cloud/Make/files

@@ -0,0 +1,4 @@
+cloudInfo/cloudInfo.C
+cloudInfo/cloudInfoFunctionObject.C
+
+LIB = $(FOAM_LIBBIN)/libcloudFunctionObjects

src/postProcessing/functionObjects/cloud/Make/options

@@ -0,0 +1,9 @@
+EXE_INC = \
+    -I$(LIB_SRC)/finiteVolume/lnInclude \
+    -I$(LIB_SRC)/lagrangian/basic/lnInclude \
+    -I$(LIB_SRC)/lagrangian/intermediate/lnInclude
+
+LIB_LIBS = \
+    -lfiniteVolume \
+    -llagrangian \
+    -llagrangianIntermediate

src/postProcessing/functionObjects/cloud/cloudFunctionObjectsDoc.H

@@ -0,0 +1,33 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012 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/>.
+
+\defgroup grpCloudFunctionObjects Cloud function objects
+@{
+    \ingroup grpFunctionObjects
+    This group contains cloud-based function objects.
+
+    Function objects in this group are packaged into the
+    libcloudFunctionObjects.so library.
+@}
+
+\*---------------------------------------------------------------------------*/

src/postProcessing/functionObjects/cloud/cloudInfo/IOcloudInfo.H

@@ -0,0 +1,49 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012 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/>.
+
+Typedef
+    Foam::IOcloudInfo
+
+Description
+    Instance of the generic IOOutputFilter for cloudInfo.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef IOcloudInfo_H
+#define IOcloudInfo_H
+
+#include "cloudInfo.H"
+#include "IOOutputFilter.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    typedef IOOutputFilter<cloudInfo> IOcloudInfo;
+}
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/postProcessing/functionObjects/cloud/cloudInfo/cloudInfo.C

@@ -0,0 +1,151 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012-2014 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "cloudInfo.H"
+#include "dictionary.H"
+#include "kinematicCloud.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+defineTypeNameAndDebug(cloudInfo, 0);
+}
+
+
+// * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
+
+void Foam::cloudInfo::writeFileHeader(const label i)
+{
+    writeHeader(file(), "Cloud information");
+    writeCommented(file(), "Time");
+    writeTabbed(file(), "nParcels");
+    writeTabbed(file(), "mass");
+    file() << endl;
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::cloudInfo::cloudInfo
+(
+    const word& name,
+    const objectRegistry& obr,
+    const dictionary& dict,
+    const bool loadFromFiles
+)
+:
+    functionObjectFile(obr, name),
+    name_(name),
+    obr_(obr),
+    active_(true)
+{
+    read(dict);
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::cloudInfo::~cloudInfo()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+void Foam::cloudInfo::read(const dictionary& dict)
+{
+    if (active_)
+    {
+        functionObjectFile::resetNames(dict.lookup("clouds"));
+
+        Info<< type() << " " << name_ << ": ";
+        if (names().size())
+        {
+            Info<< "applying to clouds:" << nl;
+            forAllConstIter(wordHashSet, names(), iter)
+            {
+                Info<< "    " << iter.key() << nl;
+            }
+            Info<< endl;
+        }
+        else
+        {
+            Info<< "no clouds to be processed" << nl << endl;
+        }
+    }
+}
+
+
+void Foam::cloudInfo::execute()
+{
+    // Do nothing
+}
+
+
+void Foam::cloudInfo::end()
+{
+    // Do nothing
+}
+
+
+void Foam::cloudInfo::timeSet()
+{
+    // Do nothing
+}
+
+
+void Foam::cloudInfo::write()
+{
+    if (active_)
+    {
+        functionObjectFile::write();
+
+        label i = 0;
+        forAllConstIter(wordHashSet, names(), iter)
+        {
+            const word& cloudName = iter.key();
+
+            const kinematicCloud& cloud =
+                obr_.lookupObject<kinematicCloud>(cloudName);
+
+            label nParcels = returnReduce(cloud.nParcels(), sumOp<label>());
+            scalar massInSystem =
+                returnReduce(cloud.massInSystem(), sumOp<scalar>());
+
+            if (Pstream::master())
+            {
+                file(i)
+                    << obr_.time().value() << token::TAB
+                    << nParcels << token::TAB
+                    << massInSystem << endl;
+            }
+
+            i++;
+        }
+    }
+}
+
+
+// ************************************************************************* //

src/postProcessing/functionObjects/cloud/cloudInfo/cloudInfo.H

@@ -0,0 +1,189 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012-2013 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/>.
+
+Class
+    Foam::cloudInfo
+
+Group
+    grpCloudFunctionObjects
+
+Description
+    This function object outputs Lagrangian cloud information to a file.  The
+    current outputs include:
+    - total current number of parcels
+    - total current mass of parcels
+
+    Example of function object specification:
+    \verbatim
+    cloudInfo1
+    {
+        type        cloudInfo;
+        functionObjectLibs ("libcloudFunctionObjects.so");
+        ...
+        clouds
+        (
+            kinematicCloud1
+            thermoCloud1
+        );
+    }
+    \endverbatim
+
+
+    \heading Function object usage
+
+    \table
+        Property     | Description             | Required    | Default value
+        type         | type name: cloudInfo    | yes         |
+        clouds       | list of clouds names to process |yes  |
+    \endtable
+
+    The output data of each cloud is written to a file named \<cloudName\>.dat
+
+SeeAlso
+    Foam::functionObject
+    Foam::OutputFilterFunctionObject
+
+SourceFiles
+    cloudInfo.C
+    IOcloudInfo.H
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef cloudInfo_H
+#define cloudInfo_H
+
+#include "functionObjectFile.H"
+#include "PtrList.H"
+#include "pointFieldFwd.H"
+#include "volFields.H"
+#include "surfaceFields.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// Forward declaration of classes
+class objectRegistry;
+class dictionary;
+class mapPolyMesh;
+
+/*---------------------------------------------------------------------------*\
+                         Class cloudInfo Declaration
+\*---------------------------------------------------------------------------*/
+
+class cloudInfo
+:
+    public functionObjectFile
+{
+protected:
+
+    // Protected data
+
+        //- Name of this set of cloudInfo object
+        word name_;
+
+        //- Reference to the database
+        const objectRegistry& obr_;
+
+        //- on/off switch
+        bool active_;
+
+
+    // Protected Member Functions
+
+        //- File header information
+        virtual void writeFileHeader(const label i);
+
+        //- Disallow default bitwise copy construct
+        cloudInfo(const cloudInfo&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const cloudInfo&);
+
+
+public:
+
+    //- Runtime type information
+    TypeName("cloudInfo");
+
+
+    // Constructors
+
+        //- Construct for given objectRegistry and dictionary.
+        //  Allow the possibility to load fields from files
+        cloudInfo
+        (
+            const word& name,
+            const objectRegistry&,
+            const dictionary&,
+            const bool loadFromFiles = false
+        );
+
+
+    //- Destructor
+    virtual ~cloudInfo();
+
+
+    // Member Functions
+
+        //- Return name of the cloudInfo object
+        virtual const word& name() const
+        {
+            return name_;
+        }
+
+        //- Read the field min/max data
+        virtual void read(const dictionary&);
+
+        //- Execute, currently does nothing
+        virtual void execute();
+
+        //- Execute at the final time-loop, currently does nothing
+        virtual void end();
+
+        //- Called when time was set at the end of the Time::operator++
+        virtual void timeSet();
+
+        //- Write
+        virtual void write();
+
+        //- Update for changes of mesh
+        virtual void updateMesh(const mapPolyMesh&)
+        {}
+
+        //- Update for changes of mesh
+        virtual void movePoints(const polyMesh&)
+        {}
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/postProcessing/functionObjects/cloud/cloudInfo/cloudInfoFunctionObject.C

@@ -0,0 +1,42 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "cloudInfoFunctionObject.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineNamedTemplateTypeNameAndDebug(cloudInfoFunctionObject, 0);
+
+    addToRunTimeSelectionTable
+    (
+        functionObject,
+        cloudInfoFunctionObject,
+        dictionary
+    );
+}
+
+// ************************************************************************* //

src/postProcessing/functionObjects/cloud/cloudInfo/cloudInfoFunctionObject.H

@@ -0,0 +1,54 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012 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/>.
+
+Typedef
+    Foam::cloudInfoFunctionObject
+
+Description
+    FunctionObject wrapper around cloudInfo to allow them to be created via
+    the functions entry within controlDict.
+
+SourceFiles
+    cloudInfoFunctionObject.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef cloudInfoFunctionObject_H
+#define cloudInfoFunctionObject_H
+
+#include "cloudInfo.H"
+#include "OutputFilterFunctionObject.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    typedef OutputFilterFunctionObject<cloudInfo>
+        cloudInfoFunctionObject;
+}
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/postProcessing/functionObjects/cloud/cloudInfo/postProcessingDict

@@ -0,0 +1,31 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  dev                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    object      postProcessingDict;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+functions
+{
+    cloudInfo1
+    {
+        type            cloudInfo;
+        functionObjectLibs ("libcloudFunctionObjects.so");
+        enabled         true;
+        outputControl   timeStep;
+        outputInterval  1;
+
+        clouds          (myCloud1);
+    }
+}
+
+// ************************************************************************* //

src/postProcessing/functionObjects/doc/functionObjects.dox

@@ -0,0 +1,94 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012-2014 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/>.
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+\page pagePostProcessing Post-processing
+
+\section secFunctionObjects Function objects
+
+OpenFOAM includes a collection of \ref grpFunctionObjects that offer users the
+opportunity to closely manage their computational analyses.  These objects can
+be applied to manipulate the workflow process, and provide a mechanism to
+extract predicted field and derived quantities at run-time.  Alternatively,
+the actions can be executed afterwards using the \c execFlowFunctionObjects
+utility.
+
+\linebreak
+The current range of features comprises of:
+- \ref grpCloudFunctionObjects
+- \ref grpFieldFunctionObjects
+- \ref grpForcesFunctionObjects
+- \ref grpFVFunctionObjects
+- \ref grpIOFunctionObjects
+- \ref grpJobControlFunctionObjects
+- \ref grpUtilitiesFunctionObjects
+
+\linebreak
+\subsection secFieldFunctionObjectUsage Using function objects
+
+Function objects are defined by additional entries in the
+$FOAM_CASE/system/controlDict input dictionary.  Each object is listed in a
+\c functions sub-dictionary entry, e.g. the following shows the input options
+applicable to `output' -type objects:
+
+\verbatim
+functions
+{
+    myFunctionObject    // user-defined name of function object entry
+    {
+        type                functionObjectType;
+        functionObjectLibs  ("libMyFunctionObjectlib.so");
+        region              defaultRegion;
+        enabled             yes;
+        timeStart           0;
+        timeEnd             10;
+        outputControl       outputTime;
+        outputInterval      1;
+        ...
+    }
+}
+\endverbatim
+
+Where:
+\table
+    Property | Description                           | Required | Default value
+    type     | type of function object               | yes      |
+    functionObjectLibs | libraries containing object implementation | yes |
+    region   | name of region for multi-region cases | no       |
+    enabled  | on/off switch                         | no       | yes
+    timeStart| start time                            | no       |
+    timeEnd  | end time                              | no       | 
+    outputControl | when to output: either 'outputTime' or 'timeStep'| no | timeStep
+    outputInterval| steps between output when outputControl=timeStep | no | 1
+\endtable
+
+The sub-dictionary name \c myFunctionObject is chosen by the user, and is
+typically used as the name of the output directory for any derived data.  The
+\c type entry defines the type of function object properties that follow.
+Since the function objects are packaged into separate libraries, the user must
+tell the code where to find the function object implementation, identified
+using the \c libs entry.  
+
+
+\*---------------------------------------------------------------------------*/

src/postProcessing/functionObjects/field/Make/files

@@ -0,0 +1,49 @@
+fieldAverage/fieldAverage/fieldAverage.C
+fieldAverage/fieldAverageItem/fieldAverageItem.C
+fieldAverage/fieldAverageItem/fieldAverageItemIO.C
+fieldAverage/fieldAverageFunctionObject/fieldAverageFunctionObject.C
+
+fieldCoordinateSystemTransform/fieldCoordinateSystemTransform.C
+fieldCoordinateSystemTransform/fieldCoordinateSystemTransformFunctionObject.C
+
+fieldMinMax/fieldMinMax.C
+fieldMinMax/fieldMinMaxFunctionObject.C
+
+fieldValues/fieldValue/fieldValue.C
+fieldValues/fieldValue/fieldValueNew.C
+fieldValues/fieldValueDelta/fieldValueDelta.C
+fieldValues/fieldValueDelta/fieldValueDeltaFunctionObject.C
+fieldValues/faceSource/faceSource.C
+fieldValues/faceSource/faceSourceFunctionObject.C
+fieldValues/cellSource/cellSource.C
+fieldValues/cellSource/cellSourceFunctionObject.C
+
+nearWallFields/nearWallFields.C
+nearWallFields/nearWallFieldsFunctionObject.C
+nearWallFields/findCellParticle.C
+nearWallFields/findCellParticleCloud.C
+
+processorField/processorField.C
+processorField/processorFieldFunctionObject.C
+
+readFields/readFields.C
+readFields/readFieldsFunctionObject.C
+
+streamLine/streamLine.C
+streamLine/streamLineParticle.C
+streamLine/streamLineParticleCloud.C
+streamLine/streamLineFunctionObject.C
+
+wallBoundedStreamLine/wallBoundedStreamLine.C
+wallBoundedStreamLine/wallBoundedStreamLineFunctionObject.C
+wallBoundedStreamLine/wallBoundedStreamLineParticle.C
+wallBoundedStreamLine/wallBoundedStreamLineParticleCloud.C
+wallBoundedStreamLine/wallBoundedParticle.C
+
+surfaceInterpolateFields/surfaceInterpolateFields.C
+surfaceInterpolateFields/surfaceInterpolateFieldsFunctionObject.C
+
+regionSizeDistribution/regionSizeDistribution.C
+regionSizeDistribution/regionSizeDistributionFunctionObject.C
+
+LIB = $(FOAM_LIBBIN)/libfieldFunctionObjects

src/postProcessing/functionObjects/field/Make/options

@@ -0,0 +1,16 @@
+EXE_INC = \
+    -I$(LIB_SRC)/finiteVolume/lnInclude \
+    -I$(LIB_SRC)/meshTools/lnInclude \
+    -I$(LIB_SRC)/lagrangian/basic/lnInclude \
+    -I$(LIB_SRC)/fileFormats/lnInclude \
+    -I$(LIB_SRC)/sampling/lnInclude \
+    -I$(LIB_SRC)/surfMesh/lnInclude
+
+LIB_LIBS = \
+    -lfiniteVolume \
+    -lmeshTools \
+    -lsurfMesh \
+    -llagrangian \
+    -lfileFormats \
+    -lsampling \
+    -lsurfMesh

src/postProcessing/functionObjects/field/fieldAverage/controlDict

@@ -0,0 +1,85 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  dev                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    object      controlDict;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+application     XXX;
+
+startFrom       latestTime;
+
+startTime       0;
+
+stopAt          endTime;
+
+endTime         0.1;
+
+deltaT          1e-05;
+
+writeControl    timeStep;
+
+writeInterval   10;
+
+purgeWrite      0;
+
+writeFormat     ascii;
+
+writePrecision  6;
+
+writeCompression off;
+
+timeFormat      general;
+
+timePrecision   6;
+
+runTimeModifiable true;
+
+functions
+{
+    fieldAverage1
+    {
+        // Type of functionObject
+        type            fieldAverage;
+
+        // Where to load it from (if not already in solver)
+        functionObjectLibs ("libfieldFunctionObjects.so");
+
+        // Function object enabled flag
+        enabled         true;
+
+        // When to output the average fields
+        outputControl   outputTime;
+
+        // Fields to be averaged - runTime modifiable
+        fields
+        (
+            U
+            {
+                mean        on;
+                prime2Mean  on;
+                base        time;
+                window      0.01; // optional averaging window
+            }
+
+            p
+            {
+                mean        on;
+                prime2Mean  on;
+                base        time;
+                window      0.01; // optional averaging window
+            }
+        );
+    }
+}
+
+// ************************************************************************* //

src/postProcessing/functionObjects/field/fieldAverage/fieldAverage/IOFieldAverage.H

@@ -0,0 +1,49 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 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/>.
+
+Typedef
+    Foam::IOfieldAverage
+
+Description
+    Instance of the generic IOOutputFilter for fieldAverage.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef IOfieldAverage_H
+#define IOfieldAverage_H
+
+#include "fieldAverage.H"
+#include "IOOutputFilter.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    typedef IOOutputFilter<fieldAverage> IOFieldAverage;
+}
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/postProcessing/functionObjects/field/fieldAverage/fieldAverage/fieldAverage.C

@@ -0,0 +1,374 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2014 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "fieldAverage.H"
+#include "volFields.H"
+#include "Time.H"
+
+#include "fieldAverageItem.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+defineTypeNameAndDebug(fieldAverage, 0);
+}
+
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+void Foam::fieldAverage::resetFields()
+{
+    forAll(faItems_, i)
+    {
+        if (faItems_[i].mean())
+        {
+            if (obr_.found(faItems_[i].meanFieldName()))
+            {
+                obr_.checkOut(*obr_[faItems_[i].meanFieldName()]);
+            }
+        }
+        if (faItems_[i].prime2Mean())
+        {
+            if (obr_.found(faItems_[i].prime2MeanFieldName()))
+            {
+                obr_.checkOut(*obr_[faItems_[i].prime2MeanFieldName()]);
+            }
+        }
+    }
+}
+
+
+void Foam::fieldAverage::initialize()
+{
+    resetFields();
+
+    Info<< type() << " " << name_ << ":" << nl;
+
+
+    // Add mean fields to the field lists
+    forAll(faItems_, fieldI)
+    {
+        addMeanField<scalar>(fieldI);
+        addMeanField<vector>(fieldI);
+        addMeanField<sphericalTensor>(fieldI);
+        addMeanField<symmTensor>(fieldI);
+        addMeanField<tensor>(fieldI);
+    }
+
+    // Add prime-squared mean fields to the field lists
+    forAll(faItems_, fieldI)
+    {
+        addPrime2MeanField<scalar, scalar>(fieldI);
+        addPrime2MeanField<vector, symmTensor>(fieldI);
+    }
+
+    forAll(faItems_, fieldI)
+    {
+        if (!faItems_[fieldI].active())
+        {
+            WarningIn("void Foam::fieldAverage::initialize()")
+                << "Field " << faItems_[fieldI].fieldName()
+                << " not found in database for averaging";
+        }
+    }
+
+    // ensure first averaging works unconditionally
+    prevTimeIndex_ = -1;
+
+    Info<< endl;
+
+    initialised_ = true;
+}
+
+
+void Foam::fieldAverage::calcAverages()
+{
+    if (!initialised_)
+    {
+        initialize();
+    }
+
+    const label currentTimeIndex =
+        static_cast<const fvMesh&>(obr_).time().timeIndex();
+
+    if (prevTimeIndex_ == currentTimeIndex)
+    {
+        return;
+    }
+    else
+    {
+        prevTimeIndex_ = currentTimeIndex;
+    }
+
+    Info<< type() << " " << name_ << " output:" << nl;
+
+    Info<< "    Calculating averages" << nl;
+
+    addMeanSqrToPrime2Mean<scalar, scalar>();
+    addMeanSqrToPrime2Mean<vector, symmTensor>();
+
+    calculateMeanFields<scalar>();
+    calculateMeanFields<vector>();
+    calculateMeanFields<sphericalTensor>();
+    calculateMeanFields<symmTensor>();
+    calculateMeanFields<tensor>();
+
+    calculatePrime2MeanFields<scalar, scalar>();
+    calculatePrime2MeanFields<vector, symmTensor>();
+
+    forAll(faItems_, fieldI)
+    {
+        totalIter_[fieldI]++;
+        totalTime_[fieldI] += obr_.time().deltaTValue();
+    }
+}
+
+
+void Foam::fieldAverage::writeAverages() const
+{
+    Info<< "    Writing average fields" << endl;
+
+    writeFields<scalar>();
+    writeFields<vector>();
+    writeFields<sphericalTensor>();
+    writeFields<symmTensor>();
+    writeFields<tensor>();
+}
+
+
+void Foam::fieldAverage::writeAveragingProperties() const
+{
+    IOdictionary propsDict
+    (
+        IOobject
+        (
+            "fieldAveragingProperties",
+            obr_.time().timeName(),
+            "uniform",
+            obr_,
+            IOobject::NO_READ,
+            IOobject::NO_WRITE,
+            false
+        )
+    );
+
+    forAll(faItems_, fieldI)
+    {
+        const word& fieldName = faItems_[fieldI].fieldName();
+        propsDict.add(fieldName, dictionary());
+        propsDict.subDict(fieldName).add("totalIter", totalIter_[fieldI]);
+        propsDict.subDict(fieldName).add("totalTime", totalTime_[fieldI]);
+    }
+
+    propsDict.regIOobject::write();
+}
+
+
+void Foam::fieldAverage::readAveragingProperties()
+{
+    totalIter_.clear();
+    totalIter_.setSize(faItems_.size(), 1);
+
+    totalTime_.clear();
+    totalTime_.setSize(faItems_.size(), obr_.time().deltaTValue());
+
+    if (resetOnRestart_)
+    {
+        Info<< "    Starting averaging at time " << obr_.time().timeName()
+            << nl;
+    }
+    else
+    {
+        IOobject propsDictHeader
+        (
+            "fieldAveragingProperties",
+            obr_.time().timeName(obr_.time().startTime().value()),
+            "uniform",
+            obr_,
+            IOobject::MUST_READ_IF_MODIFIED,
+            IOobject::NO_WRITE,
+            false
+        );
+
+        if (!propsDictHeader.headerOk())
+        {
+            Info<< "    Starting averaging at time " << obr_.time().timeName()
+                << nl;
+            return;
+        }
+
+        IOdictionary propsDict(propsDictHeader);
+
+        Info<< "    Restarting averaging for fields:" << nl;
+        forAll(faItems_, fieldI)
+        {
+            const word& fieldName = faItems_[fieldI].fieldName();
+            if (propsDict.found(fieldName))
+            {
+                dictionary fieldDict(propsDict.subDict(fieldName));
+
+                totalIter_[fieldI] = readLabel(fieldDict.lookup("totalIter"));
+                totalTime_[fieldI] = readScalar(fieldDict.lookup("totalTime"));
+                Info<< "        " << fieldName
+                    << " iters = " << totalIter_[fieldI]
+                    << " time = " << totalTime_[fieldI] << nl;
+            }
+        }
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::fieldAverage::fieldAverage
+(
+    const word& name,
+    const objectRegistry& obr,
+    const dictionary& dict,
+    const bool loadFromFiles
+)
+:
+    name_(name),
+    obr_(obr),
+    active_(true),
+    prevTimeIndex_(-1),
+    resetOnRestart_(false),
+    resetOnOutput_(false),
+    initialised_(false),
+    faItems_(),
+    totalIter_(),
+    totalTime_()
+{
+    // Only active if a fvMesh is available
+    if (isA<fvMesh>(obr_))
+    {
+        read(dict);
+    }
+    else
+    {
+        active_ = false;
+        WarningIn
+        (
+            "fieldAverage::fieldAverage"
+            "("
+                "const word&, "
+                "const objectRegistry&, "
+                "const dictionary&, "
+                "const bool "
+            ")"
+        )   << "No fvMesh available, deactivating " << name_ << nl
+            << endl;
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::fieldAverage::~fieldAverage()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+void Foam::fieldAverage::read(const dictionary& dict)
+{
+    if (active_)
+    {
+        initialised_ = false;
+
+        Info<< type() << " " << name_ << ":" << nl;
+
+        dict.readIfPresent("resetOnRestart", resetOnRestart_);
+        dict.readIfPresent("resetOnOutput", resetOnOutput_);
+        dict.lookup("fields") >> faItems_;
+
+        readAveragingProperties();
+
+        Info<< endl;
+    }
+}
+
+
+void Foam::fieldAverage::execute()
+{
+    if (active_)
+    {
+        calcAverages();
+        Info<< endl;
+    }
+}
+
+
+void Foam::fieldAverage::end()
+{
+    if (active_)
+    {
+        calcAverages();
+        Info<< endl;
+    }
+}
+
+
+void Foam::fieldAverage::timeSet()
+{}
+
+
+void Foam::fieldAverage::write()
+{
+    if (active_)
+    {
+        writeAverages();
+        writeAveragingProperties();
+
+        if (resetOnOutput_)
+        {
+            Info<< "    Restarting averaging at time " << obr_.time().timeName()
+                << nl << endl;
+
+            initialize();
+
+            // ensure first averaging works unconditionally
+            prevTimeIndex_ = -1;
+        }
+
+        Info<< endl;
+    }
+}
+
+
+void Foam::fieldAverage::updateMesh(const mapPolyMesh&)
+{
+    // Do nothing
+}
+
+
+void Foam::fieldAverage::movePoints(const polyMesh&)
+{
+    // Do nothing
+}
+
+
+// ************************************************************************* //

src/postProcessing/functionObjects/field/fieldAverage/fieldAverage/fieldAverage.H

@@ -0,0 +1,335 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2013 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/>.
+
+Class
+    Foam::fieldAverage
+
+Group
+    grpFieldFunctionObjects
+
+Description
+    This function object calculates average quantities for a user-specified
+    selection of volumetric and surface fields.  Fields are entered as a list
+    of sub-dictionaries, which indicate the type of averages to perform, and
+    can be updated during the calculation.  The current options include:
+    - \c mean: arithmetic mean:
+        \f[
+            \overline{x} = \frac{1}{N}\displaystyle\sum\limits_{i=0}^N x_i
+        \f]
+    - \c prime2Mean: prime-squared mean
+        \f[
+            \overline{x'}^2 = \frac{1}{N}\displaystyle\sum\limits_{i=0}^N
+            (x_i - \overline{x})^2
+        \f]
+    - base: average over 'time', or 'iteration' (\f$N\f$ in the above)
+    - window: optional averaging window, specified in 'base' units
+
+    Average field names are constructed by concatenating the base field with
+    the averaging type, e.g. when averaging field 'U', the resultant fields
+    are:
+    - arithmetic mean field, UMean
+    - prime-squared field, UPrime2Mean
+
+    Information regarding the number of averaging steps, and total averaging
+    time are written on a per-field basis to the
+    \c fieldAveragingProperties dictionary, located in \<time\>/uniform
+
+    When restarting form a previous calculation, the averaging is continuous.
+    However, the averaging process can be restarted using the \c resetOnRestart
+    option.
+
+    To restart the averaging process after each calculation output time, use
+    the \c resetOnOutput option.
+
+    Example of function object specification:
+    \verbatim
+    fieldAverage1
+    {
+        type fieldAverage;
+        functionObjectLibs ("libfieldFunctionObjects.so");
+        ...
+        resetOnRestart true;
+        resetOnOutput false;
+        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         |
+        resetOnRestart | flag to reset the averaging on restart | yes  |
+        resetOnOutput| flag to reset the averaging on output | yes |
+        fields       | list of fields and averaging options | yes |
+    \endtable
+
+
+Note
+    To employ the \c prime2Mean option, the \c mean option must be selecetd.
+
+SeeAlso
+    Foam::functionObject
+    Foam::OutputFilterFunctionObject
+
+SourceFiles
+    fieldAverage.C
+    fieldAverageTemplates.C
+    fieldAverageItem.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef fieldAverage_H
+#define fieldAverage_H
+
+#include "volFieldsFwd.H"
+#include "Switch.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// Forward declaration of classes
+class objectRegistry;
+class dictionary;
+class fieldAverageItem;
+template<class Type>
+class List;
+class polyMesh;
+class mapPolyMesh;
+
+/*---------------------------------------------------------------------------*\
+                        Class fieldAverage Declaration
+\*---------------------------------------------------------------------------*/
+
+class fieldAverage
+{
+protected:
+
+    // Protected data
+
+        //- Name of this set of field averages.
+        word name_;
+
+        //- Database this class is registered to
+        const objectRegistry& obr_;
+
+        //- On/off switch
+        bool active_;
+
+        //- Time at last call, prevents repeated averaging
+        label prevTimeIndex_;
+
+        //- Reset the averaging process on restart flag
+        Switch resetOnRestart_;
+
+        //- Reset the averaging process on output flag
+        Switch resetOnOutput_;
+
+        //- Initialised flag
+        bool initialised_;
+
+        //- List of field average items, describing what averages to be
+        //  calculated and output
+        List<fieldAverageItem> faItems_;
+
+        // Counters
+
+            //- Iteration steps counter
+            List<label> totalIter_;
+
+            //- Total time counter
+            List<scalar> totalTime_;
+
+
+    // Private Member Functions
+
+        // Initialisation routines
+
+            //- Checkout fields (causes deletion) from the database
+            //  and reset lists
+            void resetFields();
+
+            //- Reset lists (clear existing values) and initialize averaging.
+            //  Check requested field averages are valid, populate field lists
+            void initialize();
+
+            //- Add mean average field to database
+            template<class Type>
+            void addMeanFieldType(const label fieldI);
+
+            //- Add mean average field to database
+            template<class Type>
+            void addMeanField(const label fieldI);
+
+            //- Add prime-squared average field to database
+            template<class Type1, class Type2>
+            void addPrime2MeanFieldType(const label fieldI);
+
+            //- Add prime-squared average field to database
+            template<class Type1, class Type2>
+            void addPrime2MeanField(const label fieldI);
+
+
+        // Calculation functions
+
+            //- Main calculation routine
+            virtual void calcAverages();
+
+            //- Calculate mean average fields
+            template<class Type>
+            void calculateMeanFieldType(const label fieldI) const;
+
+            //- Calculate mean average fields
+            template<class Type>
+            void calculateMeanFields() const;
+
+            //- Calculate prime-squared average fields
+            template<class Type1, class Type2>
+            void calculatePrime2MeanFieldType(const label fieldI) const;
+
+            //- Calculate prime-squared average fields
+            template<class Type1, class Type2>
+            void calculatePrime2MeanFields() const;
+
+            //- Add mean-squared field value to prime-squared mean field
+            template<class Type1, class Type2>
+            void addMeanSqrToPrime2MeanType(const label fieldI) const;
+
+            //- Add mean-squared field value to prime-squared mean field
+            template<class Type1, class Type2>
+            void addMeanSqrToPrime2Mean() const;
+
+
+        // I-O
+
+            //- Write averages
+            virtual void writeAverages() const;
+
+            //- Write fields
+            template<class Type>
+            void writeFieldType(const word& fieldName) const;
+
+            //- Write fields
+            template<class Type>
+            void writeFields() const;
+
+            //- Write averaging properties - steps and time
+            void writeAveragingProperties() const;
+
+            //- Read averaging properties - steps and time
+            void readAveragingProperties();
+
+
+        //- Disallow default bitwise copy construct
+        fieldAverage(const fieldAverage&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const fieldAverage&);
+
+
+public:
+
+    //- Runtime type information
+    TypeName("fieldAverage");
+
+
+    // Constructors
+
+        //- Construct for given objectRegistry and dictionary.
+        //  Allow the possibility to load fields from files
+        fieldAverage
+        (
+            const word& name,
+            const objectRegistry&,
+            const dictionary&,
+            const bool loadFromFiles = false
+        );
+
+
+    //- Destructor
+    virtual ~fieldAverage();
+
+
+    // Member Functions
+
+        //- Return name of the set of field averages
+        virtual const word& name() const
+        {
+            return name_;
+        }
+
+        //- Read the field average data
+        virtual void read(const dictionary&);
+
+        //- Execute the averaging
+        virtual void execute();
+
+        //- Execute the averaging at the final time-loop, currently does nothing
+        virtual void end();
+
+        //- Called when time was set at the end of the Time::operator++
+        virtual void timeSet();
+
+        //- Calculate the field average data and write
+        virtual void write();
+
+        //- Update mesh
+        virtual void updateMesh(const mapPolyMesh&);
+
+        //- Move points
+        virtual void movePoints(const polyMesh&);
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+#   include "fieldAverageTemplates.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/postProcessing/functionObjects/field/fieldAverage/fieldAverage/fieldAverageTemplates.C

@@ -0,0 +1,383 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2013 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "fieldAverageItem.H"
+#include "volFields.H"
+#include "surfaceFields.H"
+#include "OFstream.H"
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+template<class Type>
+void Foam::fieldAverage::addMeanFieldType(const label fieldI)
+{
+    faItems_[fieldI].active() = true;
+
+    const word& fieldName = faItems_[fieldI].fieldName();
+    const word& meanFieldName = faItems_[fieldI].meanFieldName();
+
+    Info<< "    Reading/initialising field " << meanFieldName << endl;
+
+    if (obr_.foundObject<Type>(meanFieldName))
+    {
+       // do nothing
+    }
+    else if (obr_.found(meanFieldName))
+    {
+        Info<< "    Cannot allocate average field " << meanFieldName
+            << " since an object with that name already exists."
+            << " Disabling averaging for field." << endl;
+
+        faItems_[fieldI].mean() = false;
+    }
+    else
+    {
+        const Type& baseField = obr_.lookupObject<Type>(fieldName);
+
+        // Store on registry
+        obr_.store
+        (
+            new Type
+            (
+                IOobject
+                (
+                    meanFieldName,
+                    obr_.time().timeName(obr_.time().startTime().value()),
+                    obr_,
+                    IOobject::READ_IF_PRESENT,
+                    IOobject::NO_WRITE
+                ),
+                1*baseField
+            )
+        );
+    }
+}
+
+
+template<class Type>
+void Foam::fieldAverage::addMeanField(const label fieldI)
+{
+    if (faItems_[fieldI].mean())
+    {
+        typedef GeometricField<Type, fvPatchField, volMesh> volFieldType;
+        typedef GeometricField<Type, fvsPatchField, surfaceMesh> surfFieldType;
+
+        const word& fieldName = faItems_[fieldI].fieldName();
+
+        if (obr_.foundObject<volFieldType>(fieldName))
+        {
+            addMeanFieldType<volFieldType>(fieldI);
+        }
+        else if (obr_.foundObject<surfFieldType>(fieldName))
+        {
+            addMeanFieldType<surfFieldType>(fieldI);
+        }
+    }
+}
+
+
+template<class Type1, class Type2>
+void Foam::fieldAverage::addPrime2MeanFieldType(const label fieldI)
+{
+    const word& fieldName = faItems_[fieldI].fieldName();
+    const word& meanFieldName = faItems_[fieldI].meanFieldName();
+    const word& prime2MeanFieldName = faItems_[fieldI].prime2MeanFieldName();
+
+    Info<< "    Reading/initialising field " << prime2MeanFieldName << nl;
+
+    if (obr_.foundObject<Type2>(prime2MeanFieldName))
+    {
+        // do nothing
+    }
+    else if (obr_.found(prime2MeanFieldName))
+    {
+        Info<< "    Cannot allocate average field " << prime2MeanFieldName
+            << " since an object with that name already exists."
+            << " Disabling averaging for field." << nl;
+
+        faItems_[fieldI].prime2Mean() = false;
+    }
+    else
+    {
+        const Type1& baseField = obr_.lookupObject<Type1>(fieldName);
+        const Type1& meanField = obr_.lookupObject<Type1>(meanFieldName);
+
+        obr_.store
+        (
+            new Type2
+            (
+                IOobject
+                (
+                    prime2MeanFieldName,
+                    obr_.time().timeName(obr_.time().startTime().value()),
+                    obr_,
+                    IOobject::READ_IF_PRESENT,
+                    IOobject::NO_WRITE
+                ),
+                sqr(baseField) - sqr(meanField)
+            )
+        );
+    }
+}
+
+
+template<class Type1, class Type2>
+void Foam::fieldAverage::addPrime2MeanField(const label fieldI)
+{
+    typedef GeometricField<Type1, fvPatchField, volMesh> volFieldType1;
+    typedef GeometricField<Type1, fvsPatchField, surfaceMesh> surfFieldType1;
+
+    typedef GeometricField<Type2, fvPatchField, volMesh> volFieldType2;
+    typedef GeometricField<Type2, fvsPatchField, surfaceMesh> surfFieldType2;
+
+    if (faItems_[fieldI].prime2Mean())
+    {
+        const word& fieldName = faItems_[fieldI].fieldName();
+
+        if (!faItems_[fieldI].mean())
+        {
+            FatalErrorIn
+            (
+                "void Foam::fieldAverage::addPrime2MeanField(const label) const"
+            )
+                << "To calculate the prime-squared average, the "
+                << "mean average must also be selected for field "
+                << fieldName << nl << exit(FatalError);
+        }
+
+        if (obr_.foundObject<volFieldType1>(fieldName))
+        {
+            addPrime2MeanFieldType<volFieldType1, volFieldType2>(fieldI);
+        }
+        else if (obr_.foundObject<surfFieldType1>(fieldName))
+        {
+            addPrime2MeanFieldType<surfFieldType1, surfFieldType2>(fieldI);
+        }
+    }
+}
+
+
+template<class Type>
+void Foam::fieldAverage::calculateMeanFieldType(const label fieldI) const
+{
+    const word& fieldName = faItems_[fieldI].fieldName();
+
+    if (obr_.foundObject<Type>(fieldName))
+    {
+        const Type& baseField = obr_.lookupObject<Type>(fieldName);
+
+        Type& meanField = const_cast<Type&>
+        (
+            obr_.lookupObject<Type>(faItems_[fieldI].meanFieldName())
+        );
+
+        scalar dt = obr_.time().deltaTValue();
+        scalar Dt = totalTime_[fieldI];
+
+        if (faItems_[fieldI].iterBase())
+        {
+            dt = 1.0;
+            Dt = scalar(totalIter_[fieldI]);
+        }
+
+        scalar alpha = (Dt - dt)/Dt;
+        scalar beta = dt/Dt;
+
+        if (faItems_[fieldI].window() > 0)
+        {
+            const scalar w = faItems_[fieldI].window();
+
+            if (Dt - dt >= w)
+            {
+                alpha = (w - dt)/w;
+                beta = dt/w;
+            }
+        }
+
+        meanField = alpha*meanField + beta*baseField;
+    }
+}
+
+
+template<class Type>
+void Foam::fieldAverage::calculateMeanFields() const
+{
+    typedef GeometricField<Type, fvPatchField, volMesh> volFieldType;
+    typedef GeometricField<Type, fvsPatchField, surfaceMesh> surfFieldType;
+
+    forAll(faItems_, i)
+    {
+        if (faItems_[i].mean())
+        {
+            calculateMeanFieldType<volFieldType>(i);
+            calculateMeanFieldType<surfFieldType>(i);
+        }
+    }
+}
+
+
+template<class Type1, class Type2>
+void Foam::fieldAverage::calculatePrime2MeanFieldType(const label fieldI) const
+{
+    const word& fieldName = faItems_[fieldI].fieldName();
+
+    if (obr_.foundObject<Type1>(fieldName))
+    {
+        const Type1& baseField = obr_.lookupObject<Type1>(fieldName);
+        const Type1& meanField =
+            obr_.lookupObject<Type1>(faItems_[fieldI].meanFieldName());
+
+        Type2& prime2MeanField = const_cast<Type2&>
+        (
+            obr_.lookupObject<Type2>(faItems_[fieldI].prime2MeanFieldName())
+        );
+
+        scalar dt = obr_.time().deltaTValue();
+        scalar Dt = totalTime_[fieldI];
+
+        if (faItems_[fieldI].iterBase())
+        {
+            dt = 1.0;
+            Dt = scalar(totalIter_[fieldI]);
+        }
+
+        scalar alpha = (Dt - dt)/Dt;
+        scalar beta = dt/Dt;
+
+        if (faItems_[fieldI].window() > 0)
+        {
+            const scalar w = faItems_[fieldI].window();
+
+            if (Dt - dt >= w)
+            {
+                alpha = (w - dt)/w;
+                beta = dt/w;
+            }
+        }
+
+        prime2MeanField =
+            alpha*prime2MeanField
+          + beta*sqr(baseField)
+          - sqr(meanField);
+    }
+}
+
+
+template<class Type1, class Type2>
+void Foam::fieldAverage::calculatePrime2MeanFields() const
+{
+    typedef GeometricField<Type1, fvPatchField, volMesh> volFieldType1;
+    typedef GeometricField<Type1, fvsPatchField, surfaceMesh> surfFieldType1;
+
+    typedef GeometricField<Type2, fvPatchField, volMesh> volFieldType2;
+    typedef GeometricField<Type2, fvsPatchField, surfaceMesh> surfFieldType2;
+
+    forAll(faItems_, i)
+    {
+        if (faItems_[i].prime2Mean())
+        {
+            calculatePrime2MeanFieldType<volFieldType1, volFieldType2>(i);
+            calculatePrime2MeanFieldType<surfFieldType1, surfFieldType2>(i);
+        }
+    }
+}
+
+
+template<class Type1, class Type2>
+void Foam::fieldAverage::addMeanSqrToPrime2MeanType(const label fieldI) const
+{
+    const word& fieldName = faItems_[fieldI].fieldName();
+
+    if (obr_.foundObject<Type1>(fieldName))
+    {
+        const Type1& meanField =
+            obr_.lookupObject<Type1>(faItems_[fieldI].meanFieldName());
+
+        Type2& prime2MeanField = const_cast<Type2&>
+        (
+            obr_.lookupObject<Type2>(faItems_[fieldI].prime2MeanFieldName())
+        );
+
+        prime2MeanField += sqr(meanField);
+    }
+}
+
+
+template<class Type1, class Type2>
+void Foam::fieldAverage::addMeanSqrToPrime2Mean() const
+{
+    typedef GeometricField<Type1, fvPatchField, volMesh> volFieldType1;
+    typedef GeometricField<Type1, fvsPatchField, surfaceMesh> surfFieldType1;
+
+    typedef GeometricField<Type2, fvPatchField, volMesh> volFieldType2;
+    typedef GeometricField<Type2, fvsPatchField, surfaceMesh> surfFieldType2;
+
+    forAll(faItems_, i)
+    {
+        if (faItems_[i].prime2Mean())
+        {
+            addMeanSqrToPrime2MeanType<volFieldType1, volFieldType2>(i);
+            addMeanSqrToPrime2MeanType<surfFieldType1, surfFieldType2>(i);
+        }
+    }
+}
+
+
+template<class Type>
+void Foam::fieldAverage::writeFieldType(const word& fieldName) const
+{
+    if (obr_.foundObject<Type>(fieldName))
+    {
+        const Type& f = obr_.lookupObject<Type>(fieldName);
+        f.write();
+    }
+}
+
+
+template<class Type>
+void Foam::fieldAverage::writeFields() const
+{
+    typedef GeometricField<Type, fvPatchField, volMesh> volFieldType;
+    typedef GeometricField<Type, fvsPatchField, surfaceMesh> surfFieldType;
+
+    forAll(faItems_, i)
+    {
+        if (faItems_[i].mean())
+        {
+            const word& fieldName = faItems_[i].meanFieldName();
+            writeFieldType<volFieldType>(fieldName);
+            writeFieldType<surfFieldType>(fieldName);
+        }
+        if (faItems_[i].prime2Mean())
+        {
+            const word& fieldName = faItems_[i].prime2MeanFieldName();
+            writeFieldType<volFieldType>(fieldName);
+            writeFieldType<surfFieldType>(fieldName);
+        }
+    }
+}
+
+
+// ************************************************************************* //

src/postProcessing/functionObjects/field/fieldAverage/fieldAverageFunctionObject/fieldAverageFunctionObject.C

@@ -0,0 +1,42 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "fieldAverageFunctionObject.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineNamedTemplateTypeNameAndDebug(fieldAverageFunctionObject, 0);
+
+    addToRunTimeSelectionTable
+    (
+        functionObject,
+        fieldAverageFunctionObject,
+        dictionary
+    );
+}
+
+// ************************************************************************* //

src/postProcessing/functionObjects/field/fieldAverage/fieldAverageFunctionObject/fieldAverageFunctionObject.H

@@ -0,0 +1,54 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 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/>.
+
+Typedef
+    Foam::fieldAverageFunctionObject
+
+Description
+    FunctionObject wrapper around fieldAverage to allow them to be created
+    via the functions entry within controlDict.
+
+SourceFiles
+    fieldAverageFunctionObject.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef fieldAverageFunctionObject_H
+#define fieldAverageFunctionObject_H
+
+#include "fieldAverage.H"
+#include "OutputFilterFunctionObject.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    typedef OutputFilterFunctionObject<fieldAverage>
+        fieldAverageFunctionObject;
+}
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/postProcessing/functionObjects/field/fieldAverage/fieldAverageItem/fieldAverageItem.C

@@ -0,0 +1,115 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2013 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "fieldAverageItem.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    const word fieldAverageItem::EXT_MEAN = "Mean";
+    const word fieldAverageItem::EXT_PRIME2MEAN = "Prime2Mean";
+
+    template<>
+    const char* Foam::NamedEnum
+    <
+        Foam::fieldAverageItem::baseType,
+        2
+    >::names[] =
+    {
+        "iteration",
+        "time"
+    };
+}
+
+
+const Foam::NamedEnum<Foam::fieldAverageItem::baseType, 2>
+    Foam::fieldAverageItem::baseTypeNames_;
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::fieldAverageItem::fieldAverageItem()
+:
+    active_(false),
+    fieldName_("unknown"),
+    mean_(0),
+    meanFieldName_("unknown"),
+    prime2Mean_(0),
+    prime2MeanFieldName_("unknown"),
+    base_(ITER),
+    window_(-1.0),
+    windowName_("")
+{}
+
+
+Foam::fieldAverageItem::fieldAverageItem(const fieldAverageItem& faItem)
+:
+    active_(faItem.active_),
+    fieldName_(faItem.fieldName_),
+    mean_(faItem.mean_),
+    meanFieldName_(faItem.meanFieldName_),
+    prime2Mean_(faItem.prime2Mean_),
+    prime2MeanFieldName_(faItem.prime2MeanFieldName_),
+    base_(faItem.base_),
+    window_(faItem.window_),
+    windowName_(faItem.windowName_)
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::fieldAverageItem::~fieldAverageItem()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
+
+void Foam::fieldAverageItem::operator=(const fieldAverageItem& rhs)
+{
+    // Check for assignment to self
+    if (this == &rhs)
+    {
+        FatalErrorIn
+        (
+            "Foam::fieldAverageItem::operator=(const Foam::fieldAverageItem&)"
+        )   << "Attempted assignment to self" << nl
+            << abort(FatalError);
+    }
+
+    // Set updated values
+    active_ = rhs.active_;
+    fieldName_ = rhs.fieldName_;
+    mean_ = rhs.mean_;
+    meanFieldName_ = rhs.meanFieldName_;
+    prime2Mean_ = rhs.prime2Mean_;
+    prime2MeanFieldName_ = rhs.prime2MeanFieldName_;
+    base_ = rhs.base_;
+    window_ = rhs.window_;
+    windowName_ = rhs.windowName_;
+}
+
+
+// ************************************************************************* //

src/postProcessing/functionObjects/field/fieldAverage/fieldAverageItem/fieldAverageItem.H

@@ -0,0 +1,286 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2013 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/>.
+
+Class
+    Foam::fieldAverageItem
+
+Description
+    Helper class to describe what form of averaging to apply.  A set will be
+    applied to each base field in Foam::fieldAverage, of the form:
+
+    \verbatim
+    {
+        mean            on;
+        prime2Mean      on;
+        base            time; // iteration
+        window          200;  // optional averaging window
+        windowName      w1;   // optional window name (default = "")
+    }
+    \endverbatim
+
+    The averaging window corresponds to the averaging interval (iters or time)
+    If not specified, the averaging is over 'all iters/time'
+
+SourceFiles
+    fieldAverageItem.C
+    fieldAverageItemIO.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef fieldAverageItem_H
+#define fieldAverageItem_H
+
+#include "NamedEnum.H"
+#include "Switch.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// Forward declaration of classes
+class Istream;
+class Ostream;
+
+// Forward declaration of friend functions and operators
+class fieldAverageItem;
+Istream& operator>>(Istream&, fieldAverageItem&);
+Ostream& operator<<(Ostream&, const fieldAverageItem&);
+
+
+/*---------------------------------------------------------------------------*\
+                      Class fieldAverageItem Declaration
+\*---------------------------------------------------------------------------*/
+
+class fieldAverageItem
+{
+public:
+
+    // Public data
+
+        // File and field name extensions
+
+            //- Mean average
+            static const word EXT_MEAN;
+
+            //- Prime-squared average
+            static const word EXT_PRIME2MEAN;
+
+        //- Enumeration defining the averaging base type
+        enum baseType
+        {
+            ITER,
+            TIME
+        };
+
+
+private:
+
+    // Private data
+
+        //- Active flag
+        Switch active_;
+
+        //- Field name
+        word fieldName_;
+
+        //- Compute mean flag
+        Switch mean_;
+
+        //- Name of mean field
+        word meanFieldName_;
+
+        //- Compute prime-squared mean flag
+        Switch prime2Mean_;
+
+        //- Name of prime-squared mean field
+        word prime2MeanFieldName_;
+
+        //- Averaging base type names
+        static const NamedEnum<baseType, 2> baseTypeNames_;
+
+        //- Averaging base type
+        baseType base_;
+
+        //- Averaging window - defaults to -1 for 'all iters/time'
+        scalar window_;
+
+        //- Averaging window name - defaults to 'window'
+        word windowName_;
+
+
+public:
+
+    // Constructors
+
+        //- Construct null
+        fieldAverageItem();
+
+        //- Construct from Istream
+        fieldAverageItem(Istream&);
+
+        //- Construct as copy
+        fieldAverageItem(const fieldAverageItem&);
+
+
+    //- Destructor
+    ~fieldAverageItem();
+
+
+    // Member Functions
+
+        // Access
+
+            //- Return const access to the active flag
+            const Switch& active() const
+            {
+                return active_;
+            }
+
+            //- Return non-const access to the active flag
+            Switch& active()
+            {
+                return active_;
+            }
+
+            //- Return const access to the field name
+            const word& fieldName() const
+            {
+                return fieldName_;
+            }
+
+            //- Return const access to the mean flag
+            const Switch& mean() const
+            {
+                return mean_;
+            }
+
+            //- Return non-const access to the mean flag
+            Switch& mean()
+            {
+                return mean_;
+            }
+
+            //- Return const access to the mean field name
+            const word& meanFieldName() const
+            {
+                return meanFieldName_;
+            }
+
+            //- Return const access to the prime-squared mean flag
+            const Switch& prime2Mean() const
+            {
+                return prime2Mean_;
+            }
+
+            //- Return non-const access to the prime-squared mean flag
+            Switch& prime2Mean()
+            {
+                return prime2Mean_;
+            }
+
+            //- Return const access to the prime-squared mean field name
+            const word& prime2MeanFieldName() const
+            {
+                return prime2MeanFieldName_;
+            }
+
+            //- Return averaging base type name
+            const word base() const
+            {
+                return baseTypeNames_[base_];
+            }
+
+            //- Return true if base is ITER
+            Switch iterBase() const
+            {
+                return base_ == ITER;
+            }
+
+            //- Return true if base is time
+            Switch timeBase() const
+            {
+                return base_ == TIME;
+            }
+
+            scalar window() const
+            {
+                return window_;
+            }
+
+            const word& windowName() const
+            {
+                return windowName_;
+            }
+
+
+    // Member Operators
+
+        void operator=(const fieldAverageItem&);
+
+
+    // Friend Operators
+
+        friend bool operator==
+        (
+            const fieldAverageItem& a,
+            const fieldAverageItem& b
+        )
+        {
+            return
+                a.fieldName_ == b.fieldName_
+             && a.mean_ == b.mean_
+             && a.meanFieldName_ == b.meanFieldName_
+             && a.prime2Mean_ == b.prime2Mean_
+             && a.prime2MeanFieldName_ == b.prime2MeanFieldName_
+             && a.base_ == b.base_
+             && a.window_ == b.window_
+             && a.windowName_ == b.windowName_;
+        }
+
+        friend bool operator!=
+        (
+            const fieldAverageItem& a,
+            const fieldAverageItem& b
+        )
+        {
+            return !(a == b);
+        }
+
+
+    // IOstream Operators
+
+        friend Istream& operator>>(Istream&, fieldAverageItem&);
+        friend Ostream& operator<<(Ostream&, const fieldAverageItem&);
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/postProcessing/functionObjects/field/fieldAverage/fieldAverageItem/fieldAverageItemIO.C

@@ -0,0 +1,139 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2013 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "fieldAverageItem.H"
+#include "IOstreams.H"
+#include "dictionaryEntry.H"
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::fieldAverageItem::fieldAverageItem(Istream& is)
+:
+    active_(false),
+    fieldName_("unknown"),
+    mean_(0),
+    meanFieldName_("unknown"),
+    prime2Mean_(0),
+    prime2MeanFieldName_("unknown"),
+    base_(ITER),
+    window_(-1.0)
+{
+    is.check("Foam::fieldAverageItem::fieldAverageItem(Foam::Istream&)");
+
+    const dictionaryEntry entry(dictionary::null, is);
+
+    fieldName_ = entry.keyword();
+    entry.lookup("mean") >> mean_;
+    entry.lookup("prime2Mean") >> prime2Mean_;
+    base_ = baseTypeNames_[entry.lookup("base")];
+    window_ = entry.lookupOrDefault<scalar>("window", -1.0);
+    windowName_ = entry.lookupOrDefault<word>("windowName", "");
+
+    meanFieldName_ = fieldName_ + EXT_MEAN;
+    prime2MeanFieldName_ = fieldName_ + EXT_PRIME2MEAN;
+    if ((window_ > 0) && (windowName_ != ""))
+    {
+        meanFieldName_ = meanFieldName_ + "_" + windowName_;
+        prime2MeanFieldName_ = prime2MeanFieldName_ + "_" + windowName_;
+    }
+}
+
+
+// * * * * * * * * * * * * * * * IOstream Operators  * * * * * * * * * * * * //
+
+Foam::Istream& Foam::operator>>(Istream& is, fieldAverageItem& faItem)
+{
+    is.check
+    (
+        "Foam::Istream& Foam::operator>>"
+        "(Foam::Istream&, Foam::fieldAverageItem&)"
+    );
+
+    const dictionaryEntry entry(dictionary::null, is);
+
+    faItem.active_ = false;
+    faItem.fieldName_ = entry.keyword();
+    entry.lookup("mean") >> faItem.mean_;
+    entry.lookup("prime2Mean") >> faItem.prime2Mean_;
+    faItem.base_ = faItem.baseTypeNames_[entry.lookup("base")];
+    faItem.window_ = entry.lookupOrDefault<scalar>("window", -1.0);
+    faItem.windowName_ = entry.lookupOrDefault<word>("windowName", "");
+
+    faItem.meanFieldName_ = faItem.fieldName_ + fieldAverageItem::EXT_MEAN;
+    faItem.prime2MeanFieldName_ =
+        faItem.fieldName_ + fieldAverageItem::EXT_PRIME2MEAN;
+
+    if ((faItem.window_ > 0) && (faItem.windowName_ != ""))
+    {
+        faItem.meanFieldName_ =
+            faItem.meanFieldName_ + "_" + faItem.windowName_;
+
+        faItem.prime2MeanFieldName_ =
+            faItem.prime2MeanFieldName_ + "_" + faItem.windowName_;
+    }
+    return is;
+}
+
+
+Foam::Ostream& Foam::operator<<(Ostream& os, const fieldAverageItem& faItem)
+{
+    os.check
+    (
+        "Foam::Ostream& Foam::operator<<"
+        "(Foam::Ostream&, const Foam::fieldAverageItem&)"
+    );
+
+    os  << faItem.fieldName_ << nl << token::BEGIN_BLOCK << nl;
+    os.writeKeyword("mean") << faItem.mean_ << token::END_STATEMENT << nl;
+    os.writeKeyword("prime2Mean") << faItem.mean_
+        << token::END_STATEMENT << nl;
+    os.writeKeyword("base") << faItem.baseTypeNames_[faItem.base_]
+        << token::END_STATEMENT << nl;
+
+    if (faItem.window_ > 0)
+    {
+        os.writeKeyword("window") << faItem.window_
+            << token::END_STATEMENT << nl;
+
+        if (faItem.windowName_ != "")
+        {
+            os.writeKeyword("windowName") << faItem.windowName_
+                << token::END_STATEMENT << nl;
+        }
+    }
+
+    os  << token::END_BLOCK << nl;
+
+    os.check
+    (
+        "Foam::Ostream& Foam::operator<<"
+        "(Foam::Ostream&, const Foam::fieldAverageItem&)"
+    );
+
+    return os;
+}
+
+
+// ************************************************************************* //

src/postProcessing/functionObjects/field/fieldCoordinateSystemTransform/IOfieldCoordinateSystemTransform.H

@@ -0,0 +1,50 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 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/>.
+
+Typedef
+    Foam::IOfieldCoordinateSystemTransform
+
+Description
+    Instance of the generic IOOutputFilter for fieldCoordinateSystemTransform.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef IOfieldCoordinateSystemTransform_H
+#define IOfieldCoordinateSystemTransform_H
+
+#include "fieldCoordinateSystemTransform.H"
+#include "IOOutputFilter.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    typedef IOOutputFilter<fieldCoordinateSystemTransform>
+        IOfieldCoordinateSystemTransform;
+}
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/postProcessing/functionObjects/field/fieldCoordinateSystemTransform/fieldCoordinateSystemTransform.C

@@ -0,0 +1,154 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2014 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "fieldCoordinateSystemTransform.H"
+#include "dictionary.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+defineTypeNameAndDebug(fieldCoordinateSystemTransform, 0);
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::fieldCoordinateSystemTransform::fieldCoordinateSystemTransform
+(
+    const word& name,
+    const objectRegistry& obr,
+    const dictionary& dict,
+    const bool loadFromFiles
+)
+:
+    name_(name),
+    obr_(obr),
+    active_(true),
+    fieldSet_(),
+    coordSys_(obr, dict)
+{
+    // Check if the available mesh is an fvMesh otherise deactivate
+    if (isA<fvMesh>(obr_))
+    {
+        read(dict);
+
+        Info<< type() << " " << name_ << ":" << nl
+            << "   Applying transformation from global Cartesian to local "
+            << coordSys_ << nl << endl;
+    }
+    else
+    {
+        active_ = false;
+        WarningIn
+        (
+            "fieldCoordinateSystemTransform::fieldCoordinateSystemTransform"
+            "("
+                "const word&, "
+                "const objectRegistry&, "
+                "const dictionary&, "
+                "const bool"
+            ")"
+        )   << "No fvMesh available, deactivating " << name_
+            << endl;
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::fieldCoordinateSystemTransform::~fieldCoordinateSystemTransform()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+void Foam::fieldCoordinateSystemTransform::read(const dictionary& dict)
+{
+    if (active_)
+    {
+        dict.lookup("fields") >> fieldSet_;
+    }
+}
+
+
+void Foam::fieldCoordinateSystemTransform::execute()
+{
+    if (active_)
+    {
+        Info<< type() << " " << name_ << " output:" << nl;
+
+        forAll(fieldSet_, fieldI)
+        {
+            // If necessary load field
+            transform<scalar>(fieldSet_[fieldI]);
+            transform<vector>(fieldSet_[fieldI]);
+            transform<sphericalTensor>(fieldSet_[fieldI]);
+            transform<symmTensor>(fieldSet_[fieldI]);
+            transform<tensor>(fieldSet_[fieldI]);
+        }
+    }
+}
+
+
+void Foam::fieldCoordinateSystemTransform::end()
+{
+    if (active_)
+    {
+        execute();
+    }
+}
+
+
+void Foam::fieldCoordinateSystemTransform::timeSet()
+{
+    // Do nothing
+}
+
+
+void Foam::fieldCoordinateSystemTransform::write()
+{
+    if (active_)
+    {
+        Info<< type() << " " << name_ << " output:" << nl;
+
+        forAll(fieldSet_, fieldI)
+        {
+            const word fieldName = fieldSet_[fieldI] + ":Transformed";
+
+            const regIOobject& field =
+                obr_.lookupObject<regIOobject>(fieldName);
+
+            Info<< "    writing field " << field.name() << nl;
+
+            field.write();
+        }
+
+        Info<< endl;
+    }
+}
+
+
+// ************************************************************************* //

src/postProcessing/functionObjects/field/fieldCoordinateSystemTransform/fieldCoordinateSystemTransform.H

@@ -0,0 +1,206 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2013 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/>.
+
+Class
+    Foam::fieldCoordinateSystemTransform
+
+Group
+    grpFieldFunctionObjects
+
+Description
+    This function object transforms a user-specified selection of fields from
+    global Cartesian co-ordinates to a local co-ordinate system.  The fields
+    are run-time modifiable.
+
+    Example of function object specification:
+    \verbatim
+    fieldCoordinateSystemTransform1
+    {
+        type        fieldCoordinateSystemTransform;
+        functionObjectLibs ("libfieldFunctionObjects.so");
+        ...
+        fields
+        (
+            U
+            UMean
+            UPrime2Mean
+        );
+        coordinateSystem
+        {
+            origin  (0.001  0       0);
+            e1      (1      0.15    0);
+            e3      (0      0      -1);
+        }
+    }
+    \endverbatim
+
+    \heading Function object usage
+    \table
+        Property     | Description             | Required    | Default value
+        type         | type name: fieldCoordinateSystemTransform | yes |
+        fields       | list of fields to be transformed |yes |
+        coordinateSystem | local co-ordinate system | yes    |
+    \endtable
+
+SeeAlso
+    Foam::functionObject
+    Foam::OutputFilterFunctionObject
+    Foam::coordinateSystem
+
+SourceFiles
+    fieldCoordinateSystemTransform.C
+    fieldCoordinateSystemTransformTemplates.C
+    IOfieldCoordinateSystemTransform.H
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef fieldCoordinateSystemTransform_H
+#define fieldCoordinateSystemTransform_H
+
+#include "OFstream.H"
+#include "volFields.H"
+#include "surfaceFields.H"
+#include "coordinateSystem.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// Forward declaration of classes
+class objectRegistry;
+class dictionary;
+class polyMesh;
+class mapPolyMesh;
+
+/*---------------------------------------------------------------------------*\
+               Class fieldCoordinateSystemTransform Declaration
+\*---------------------------------------------------------------------------*/
+
+class fieldCoordinateSystemTransform
+{
+protected:
+
+    // Protected data
+
+        //- Name
+        word name_;
+
+        const objectRegistry& obr_;
+
+        //- on/off switch
+        bool active_;
+
+        //- Fields to transform
+        wordList fieldSet_;
+
+        //- Co-ordinate system to transform to
+        coordinateSystem coordSys_;
+
+
+    // Protected Member Functions
+
+        //- Disallow default bitwise copy construct
+        fieldCoordinateSystemTransform(const fieldCoordinateSystemTransform&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const fieldCoordinateSystemTransform&);
+
+        template<class Type>
+        void transform(const word& fieldName) const;
+
+        template<class Type>
+        void transformField(const Type& field) const;
+
+
+public:
+
+    //- Runtime type information
+    TypeName("fieldCoordinateSystemTransform");
+
+
+    // Constructors
+
+        //- Construct for given objectRegistry and dictionary.
+        //  Allow the possibility to load fields from files
+        fieldCoordinateSystemTransform
+        (
+            const word& name,
+            const objectRegistry&,
+            const dictionary&,
+            const bool loadFromFiles = false
+        );
+
+
+    //- Destructor
+    virtual ~fieldCoordinateSystemTransform();
+
+
+    // Member Functions
+
+        //- Return name of the fieldCoordinateSystemTransform object
+        virtual const word& name() const
+        {
+            return name_;
+        }
+
+        //- Read the input data
+        virtual void read(const dictionary&);
+
+        //- Execute, currently does nothing
+        virtual void execute();
+
+        //- Execute at the final time-loop, currently does nothing
+        virtual void end();
+
+        //- Called when time was set at the end of the Time::operator++
+        virtual void timeSet();
+
+        //- Write
+        virtual void write();
+
+        //- Update for changes of mesh
+        virtual void updateMesh(const mapPolyMesh&)
+        {}
+
+        //- Update for changes of mesh
+        virtual void movePoints(const polyMesh&)
+        {}
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+#   include "fieldCoordinateSystemTransformTemplates.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/postProcessing/functionObjects/field/fieldCoordinateSystemTransform/fieldCoordinateSystemTransformFunctionObject.C

@@ -0,0 +1,45 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "fieldCoordinateSystemTransformFunctionObject.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineNamedTemplateTypeNameAndDebug
+    (
+        fieldCoordinateSystemTransformFunctionObject, 0
+    );
+
+    addToRunTimeSelectionTable
+    (
+        functionObject,
+        fieldCoordinateSystemTransformFunctionObject,
+        dictionary
+    );
+}
+
+// ************************************************************************* //

src/postProcessing/functionObjects/field/fieldCoordinateSystemTransform/fieldCoordinateSystemTransformFunctionObject.H

@@ -0,0 +1,54 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 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/>.
+
+Typedef
+    Foam::fieldCoordinateSystemTransformFunctionObject
+
+Description
+    FunctionObject wrapper around fieldCoordinateSystemTransform to allow
+    them to be created via the functions entry within controlDict.
+
+SourceFiles
+    fieldCoordinateSystemTransformFunctionObject.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef fieldCoordinateSystemTransformFunctionObject_H
+#define fieldCoordinateSystemTransformFunctionObject_H
+
+#include "fieldCoordinateSystemTransform.H"
+#include "OutputFilterFunctionObject.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    typedef OutputFilterFunctionObject<fieldCoordinateSystemTransform>
+        fieldCoordinateSystemTransformFunctionObject;
+}
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/postProcessing/functionObjects/field/fieldCoordinateSystemTransform/fieldCoordinateSystemTransformTemplates.C

@@ -0,0 +1,148 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2013 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "fieldCoordinateSystemTransform.H"
+#include "volFields.H"
+#include "surfaceFields.H"
+#include "Time.H"
+#include "transformGeometricField.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+template<class Type>
+void Foam::fieldCoordinateSystemTransform::transformField
+(
+    const Type& field
+) const
+{
+    const word& fieldName = field.name() + ":Transformed";
+
+    if (!obr_.foundObject<Type>(fieldName))
+    {
+        obr_.store
+        (
+            new Type
+            (
+                IOobject
+                (
+                    fieldName,
+                    obr_.time().timeName(),
+                    obr_,
+                    IOobject::READ_IF_PRESENT,
+                    IOobject::NO_WRITE
+                ),
+                field
+            )
+        );
+    }
+
+    Type& transField =
+        const_cast<Type&>(obr_.lookupObject<Type>(fieldName));
+
+    transField == field;
+
+    dimensionedTensor R("R", field.dimensions(), coordSys_.R().R());
+
+    Foam::transform(transField, R, transField);
+
+    Info<< "    writing field " << transField.name() << nl << endl;
+
+    transField.write();
+}
+
+
+template<class Type>
+void Foam::fieldCoordinateSystemTransform::transform
+(
+    const word& fieldName
+) const
+{
+    typedef GeometricField<Type, fvPatchField, volMesh> vfType;
+    typedef GeometricField<Type, fvsPatchField, surfaceMesh> sfType;
+
+    if (obr_.foundObject<vfType>(fieldName))
+    {
+        if (debug)
+        {
+            Info<< type() << ": Field " << fieldName << " already in database"
+                << endl;
+        }
+
+        transformField<vfType>(obr_.lookupObject<vfType>(fieldName));
+    }
+    else if (obr_.foundObject<sfType>(fieldName))
+    {
+        if (debug)
+        {
+            Info<< type() << ": Field " << fieldName << " already in database"
+                << endl;
+        }
+
+        transformField<sfType>(obr_.lookupObject<sfType>(fieldName));
+    }
+    else
+    {
+        IOobject fieldHeader
+        (
+            fieldName,
+            obr_.time().timeName(),
+            obr_,
+            IOobject::MUST_READ,
+            IOobject::NO_WRITE
+        );
+
+        if
+        (
+            fieldHeader.headerOk()
+         && fieldHeader.headerClassName() == vfType::typeName
+        )
+        {
+            if (debug)
+            {
+                Info<< type() << ": Field " << fieldName << " read from file"
+                    << endl;
+            }
+
+            transformField<vfType>(obr_.lookupObject<vfType>(fieldName));
+        }
+        else if
+        (
+            fieldHeader.headerOk()
+         && fieldHeader.headerClassName() == sfType::typeName
+        )
+        {
+            if (debug)
+            {
+                Info<< type() << ": Field " << fieldName << " read from file"
+                    << endl;
+            }
+
+            transformField<sfType>(obr_.lookupObject<sfType>(fieldName));
+        }
+    }
+}
+
+
+// ************************************************************************* //

src/postProcessing/functionObjects/field/fieldCoordinateSystemTransform/postProcessingDict

@@ -0,0 +1,50 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  dev                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    object      postProcessingDict;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+functions
+{
+    fieldCoordinateSystemTransform1
+    {
+        // Type of functionObject
+        type            fieldCoordinateSystemTransform;
+
+        // Where to load it from (if not already in solver)
+        functionObjectLibs ("libfieldFunctionObjects.so");
+
+        // Function object enabled flag
+        enabled         true;
+
+        // When to output the average fields
+        outputControl   outputTime;
+
+        // Fields to be transformed - runTime modifiable
+        fields
+        (
+            U
+            UMean
+            UPrime2Mean
+        );
+
+        coordinateSystem
+        {
+            origin  (0.001  0       0);
+            e1      (1      0.15    0);
+            e3      (0      0      -1);
+        }
+    }
+}
+
+// ************************************************************************* //

src/postProcessing/functionObjects/field/fieldFunctionObjectsDoc.H

@@ -0,0 +1,33 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012 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/>.
+
+\defgroup grpFieldFunctionObjects Field function objects
+@{
+    \ingroup grpFunctionObjects
+    This group contains field-based function objects
+
+    Function objects in this group are packaged into the
+    libfieldFunctionObjects.so library.
+@}
+
+\*---------------------------------------------------------------------------*/

src/postProcessing/functionObjects/field/fieldMinMax/IOfieldMinMax.H

@@ -0,0 +1,49 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 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/>.
+
+Typedef
+    Foam::IOfieldMinMax
+
+Description
+    Instance of the generic IOOutputFilter for fieldMinMax.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef IOfieldMinMax_H
+#define IOfieldMinMax_H
+
+#include "fieldMinMax.H"
+#include "IOOutputFilter.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    typedef IOOutputFilter<fieldMinMax> IOfieldMinMax;
+}
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/postProcessing/functionObjects/field/fieldMinMax/controlDict

@@ -0,0 +1,75 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  dev                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    object      controlDict;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+application     XXX;
+
+startFrom       latestTime;
+
+startTime       0;
+
+stopAt          endTime;
+
+endTime         0.1;
+
+deltaT          1e-05;
+
+writeControl    timeStep;
+
+writeInterval   10;
+
+purgeWrite      0;
+
+writeFormat     ascii;
+
+writePrecision  6;
+
+writeCompression off;
+
+timeFormat      general;
+
+timePrecision   6;
+
+runTimeModifiable true;
+
+functions
+{
+    minMax
+    {
+        // Type of functionObject
+        type            fieldMinMax;
+
+        // Where to load it from (if not already in solver)
+        functionObjectLibs ("libfieldFunctionObjects.so");
+
+        // Function object enabled flag
+        enabled         true;
+
+        // Log to output (default: false)
+        log             false;
+
+        // Write information to file (default: true)
+        write           true;
+
+        // Fields to be monitored - runTime modifiable
+        fields
+        (
+            U
+            p
+        );
+    }
+}
+
+// ************************************************************************* //

src/postProcessing/functionObjects/field/fieldMinMax/fieldMinMax.C

@@ -0,0 +1,179 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2014 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "fieldMinMax.H"
+#include "volFields.H"
+#include "dictionary.H"
+#include "Time.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(fieldMinMax, 0);
+
+    template<>
+    const char* NamedEnum
+    <
+        fieldMinMax::modeType,
+        2
+    >::names[] =
+    {
+        "magnitude",
+        "component"
+    };
+}
+
+
+const Foam::NamedEnum<Foam::fieldMinMax::modeType, 2>
+Foam::fieldMinMax::modeTypeNames_;
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::fieldMinMax::fieldMinMax
+(
+    const word& name,
+    const objectRegistry& obr,
+    const dictionary& dict,
+    const bool loadFromFiles
+)
+:
+    functionObjectFile(obr, name, typeName),
+    name_(name),
+    obr_(obr),
+    active_(true),
+    log_(true),
+    mode_(mdMag),
+    fieldSet_()
+{
+    // Check if the available mesh is an fvMesh otherise deactivate
+    if (!isA<fvMesh>(obr_))
+    {
+        active_ = false;
+        WarningIn
+        (
+            "fieldMinMax::fieldMinMax"
+            "("
+                "const word&, "
+                "const objectRegistry&, "
+                "const dictionary&, "
+                "const bool"
+            ")"
+        )   << "No fvMesh available, deactivating " << name_
+            << endl;
+    }
+
+    read(dict);
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::fieldMinMax::~fieldMinMax()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+void Foam::fieldMinMax::read(const dictionary& dict)
+{
+    if (active_)
+    {
+        log_ = dict.lookupOrDefault<Switch>("log", true);
+
+        mode_ = modeTypeNames_[dict.lookupOrDefault<word>("mode", "magnitude")];
+        dict.lookup("fields") >> fieldSet_;
+    }
+}
+
+
+void Foam::fieldMinMax::writeFileHeader(const label i)
+{
+    writeHeader(file(), "Field minima and maxima");
+    writeCommented(file(), "Time");
+    writeTabbed(file(), "field");
+    writeTabbed(file(), "min");
+    writeTabbed(file(), "position(min)");
+
+    if (Pstream::parRun())
+    {
+        writeTabbed(file(), "processor");
+    }
+
+    writeTabbed(file(), "max");
+    writeTabbed(file(), "position(max)");
+
+    if (Pstream::parRun())
+    {
+        writeTabbed(file(), "processor");
+    }
+
+    file() << endl;
+}
+
+
+void Foam::fieldMinMax::execute()
+{
+    // Do nothing - only valid on write
+}
+
+
+void Foam::fieldMinMax::end()
+{
+    // Do nothing - only valid on write
+}
+
+
+void Foam::fieldMinMax::timeSet()
+{
+    // Do nothing - only valid on write
+}
+
+
+void Foam::fieldMinMax::write()
+{
+    if (active_)
+    {
+        functionObjectFile::write();
+
+        Info(log_)<< type() << " " << name_ <<  " output:" << nl;
+
+        forAll(fieldSet_, fieldI)
+        {
+            calcMinMaxFields<scalar>(fieldSet_[fieldI], mdCmpt);
+            calcMinMaxFields<vector>(fieldSet_[fieldI], mode_);
+            calcMinMaxFields<sphericalTensor>(fieldSet_[fieldI], mode_);
+            calcMinMaxFields<symmTensor>(fieldSet_[fieldI], mode_);
+            calcMinMaxFields<tensor>(fieldSet_[fieldI], mode_);
+        }
+
+        Info(log_)<< endl;
+    }
+}
+
+
+
+// ************************************************************************* //

src/postProcessing/functionObjects/field/fieldMinMax/fieldMinMax.H

@@ -0,0 +1,244 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2014 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/>.
+
+Class
+    Foam::fieldMinMax
+
+Group
+    grpFieldFunctionObjects
+
+Description
+    This function object calculates the value and position of scalar minimim
+    and maximum for a list of user-specified fields.  For variables with a rank
+    greater than zero, either the min/max of a component value or the magnitude
+    is reported.  When operating in parallel, the processor owning the value
+    is also given.
+
+    Example of function object specification:
+    \verbatim
+    fieldMinMax1
+    {
+        type        fieldMinMax;
+        functionObjectLibs ("libfieldFunctionObjects.so");
+        ...
+        write       yes;
+        log         yes;
+        mode        magnitude;
+        fields
+        (
+            U
+            p
+        );
+    }
+    \endverbatim
+
+    \heading Function object usage
+    \table
+        Property     | Description             | Required    | Default value
+        type         | type name: fieldMinMax  | yes         |
+        write        | write min/max data to file |  no      | yes
+        log          | write min/max data to standard output | no | no
+        mode         | calculation mode: magnitude or component | no | magnitude
+    \endtable
+
+    Output data is written to the file \<timeDir\>/fieldMinMax.dat
+
+SeeAlso
+    Foam::functionObject
+    Foam::OutputFilterFunctionObject
+
+SourceFiles
+    fieldMinMax.C
+    IOfieldMinMax.H
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef fieldMinMax_H
+#define fieldMinMax_H
+
+#include "functionObjectFile.H"
+#include "primitiveFieldsFwd.H"
+#include "volFieldsFwd.H"
+#include "HashSet.H"
+#include "OFstream.H"
+#include "Switch.H"
+#include "NamedEnum.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// Forward declaration of classes
+class objectRegistry;
+class dictionary;
+class polyMesh;
+class mapPolyMesh;
+
+/*---------------------------------------------------------------------------*\
+                       Class fieldMinMax Declaration
+\*---------------------------------------------------------------------------*/
+
+class fieldMinMax
+:
+    public functionObjectFile
+{
+public:
+
+    enum modeType
+    {
+        mdMag,
+        mdCmpt
+    };
+
+protected:
+
+    // Protected data
+
+        //- Mode type names
+        static const NamedEnum<modeType, 2> modeTypeNames_;
+
+        //- Name of this set of field min/max
+        //  Also used as the name of the output directory
+        word name_;
+
+        const objectRegistry& obr_;
+
+        //- on/off switch
+        bool active_;
+
+        //- Switch to send output to Info as well
+        Switch log_;
+
+        //- Mode for min/max - only applicable for ranks > 0
+        modeType mode_;
+
+        //- Fields to assess min/max
+        wordList fieldSet_;
+
+
+    // Private Member Functions
+
+        //- Helper function to write the output
+        template<class Type>
+        void output
+        (
+            const word& fieldName,
+            const word& outputName,
+            const vector& minC,
+            const vector& maxC,
+            const label minProcI,
+            const label maxProcI,
+            const Type& minValue,
+            const Type& maxValue
+        );
+
+        //- Disallow default bitwise copy construct
+        fieldMinMax(const fieldMinMax&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const fieldMinMax&);
+
+        //- Output file header information
+        virtual void writeFileHeader(const label i);
+
+
+public:
+
+    //- Runtime type information
+    TypeName("fieldMinMax");
+
+
+    // Constructors
+
+        //- Construct for given objectRegistry and dictionary.
+        //  Allow the possibility to load fields from files
+        fieldMinMax
+        (
+            const word& name,
+            const objectRegistry&,
+            const dictionary&,
+            const bool loadFromFiles = false
+        );
+
+
+    //- Destructor
+    virtual ~fieldMinMax();
+
+
+    // Member Functions
+
+        //- Return name of the set of field min/max
+        virtual const word& name() const
+        {
+            return name_;
+        }
+
+        //- Read the field min/max data
+        virtual void read(const dictionary&);
+
+        //- Execute, currently does nothing
+        virtual void execute();
+
+        //- Execute at the final time-loop, currently does nothing
+        virtual void end();
+
+        //- Called when time was set at the end of the Time::operator++
+        virtual void timeSet();
+
+        //- Calculate the field min/max
+        template<class Type>
+        void calcMinMaxFields
+        (
+            const word& fieldName,
+            const modeType& mode
+        );
+
+        //- Write the fieldMinMax
+        virtual void write();
+
+        //- Update for changes of mesh
+        virtual void updateMesh(const mapPolyMesh&)
+        {}
+
+        //- Update for changes of mesh
+        virtual void movePoints(const polyMesh&)
+        {}
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+#   include "fieldMinMaxTemplates.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/postProcessing/functionObjects/field/fieldMinMax/fieldMinMaxFunctionObject.C

@@ -0,0 +1,42 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "fieldMinMaxFunctionObject.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineNamedTemplateTypeNameAndDebug(fieldMinMaxFunctionObject, 0);
+
+    addToRunTimeSelectionTable
+    (
+        functionObject,
+        fieldMinMaxFunctionObject,
+        dictionary
+    );
+}
+
+// ************************************************************************* //

src/postProcessing/functionObjects/field/fieldMinMax/fieldMinMaxFunctionObject.H

@@ -0,0 +1,54 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 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/>.
+
+Typedef
+    Foam::fieldMinMaxFunctionObject
+
+Description
+    FunctionObject wrapper around fieldMinMax to allow them to be created via
+    the functions entry within controlDict.
+
+SourceFiles
+    fieldMinMaxFunctionObject.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef fieldMinMaxFunctionObject_H
+#define fieldMinMaxFunctionObject_H
+
+#include "fieldMinMax.H"
+#include "OutputFilterFunctionObject.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    typedef OutputFilterFunctionObject<fieldMinMax>
+        fieldMinMaxFunctionObject;
+}
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/postProcessing/functionObjects/field/fieldMinMax/fieldMinMaxTemplates.C

@@ -0,0 +1,275 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2014 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "fieldMinMax.H"
+#include "volFields.H"
+#include "dictionary.H"
+#include "Time.H"
+#include "ListOps.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+template<class Type>
+void Foam::fieldMinMax::output
+(
+    const word& fieldName,
+    const word& outputName,
+    const vector& minC,
+    const vector& maxC,
+    const label minProcI,
+    const label maxProcI,
+    const Type& minValue,
+    const Type& maxValue
+)
+{
+    file()<< obr_.time().value();
+    writeTabbed(file(), fieldName);
+
+    file()
+        << token::TAB << minValue
+        << token::TAB << minC;
+
+    if (Pstream::parRun())
+    {
+        file()<< token::TAB << minProcI;
+    }
+
+    file()
+        << token::TAB << maxValue
+        << token::TAB << maxC;
+
+    if (Pstream::parRun())
+    {
+        file()<< token::TAB << maxProcI;
+    }
+
+    file() << endl;
+
+    Info(log_)<< "    min(" << outputName << ") = "
+        << minValue << " at position " << minC;
+
+    if (Pstream::parRun())
+    {
+        Info(log_)<< " on processor " << minProcI;
+    }
+
+    Info(log_)<< nl << "    max(" << outputName << ") = "
+        << maxValue << " at position " << maxC;
+
+    if (Pstream::parRun())
+    {
+        Info(log_)<< " on processor " << maxProcI;
+    }
+
+    Info(log_)<< endl;
+}
+
+
+template<class Type>
+void Foam::fieldMinMax::calcMinMaxFields
+(
+    const word& fieldName,
+    const modeType& mode
+)
+{
+    typedef GeometricField<Type, fvPatchField, volMesh> fieldType;
+
+    if (obr_.foundObject<fieldType>(fieldName))
+    {
+        const label procI = Pstream::myProcNo();
+
+        const fieldType& field = obr_.lookupObject<fieldType>(fieldName);
+        const fvMesh& mesh = field.mesh();
+
+        const volVectorField::GeometricBoundaryField& CfBoundary =
+            mesh.C().boundaryField();
+
+        switch (mode)
+        {
+            case mdMag:
+            {
+                const volScalarField magField(mag(field));
+                const volScalarField::GeometricBoundaryField& magFieldBoundary =
+                    magField.boundaryField();
+
+                scalarList minVs(Pstream::nProcs());
+                List<vector> minCs(Pstream::nProcs());
+                label minProcI = findMin(magField);
+                minVs[procI] = magField[minProcI];
+                minCs[procI] = field.mesh().C()[minProcI];
+
+
+                labelList maxIs(Pstream::nProcs());
+                scalarList maxVs(Pstream::nProcs());
+                List<vector> maxCs(Pstream::nProcs());
+                label maxProcI = findMax(magField);
+                maxVs[procI] = magField[maxProcI];
+                maxCs[procI] = field.mesh().C()[maxProcI];
+
+                forAll(magFieldBoundary, patchI)
+                {
+                    const scalarField& mfp = magFieldBoundary[patchI];
+                    if (mfp.size())
+                    {
+                        const vectorField& Cfp = CfBoundary[patchI];
+
+                        label minPI = findMin(mfp);
+                        if (mfp[minPI] < minVs[procI])
+                        {
+                            minVs[procI] = mfp[minPI];
+                            minCs[procI] = Cfp[minPI];
+                        }
+
+                        label maxPI = findMax(mfp);
+                        if (mfp[maxPI] > maxVs[procI])
+                        {
+                            maxVs[procI] = mfp[maxPI];
+                            maxCs[procI] = Cfp[maxPI];
+                        }
+                    }
+                }
+
+                Pstream::gatherList(minVs);
+                Pstream::gatherList(minCs);
+
+                Pstream::gatherList(maxVs);
+                Pstream::gatherList(maxCs);
+
+                if (Pstream::master())
+                {
+                    label minI = findMin(minVs);
+                    scalar minValue = minVs[minI];
+                    const vector& minC = minCs[minI];
+
+                    label maxI = findMax(maxVs);
+                    scalar maxValue = maxVs[maxI];
+                    const vector& maxC = maxCs[maxI];
+
+                    output
+                    (
+                        fieldName,
+                        word("mag(" + fieldName + ")"),
+                        minC,
+                        maxC,
+                        minI,
+                        maxI,
+                        minValue,
+                        maxValue
+                    );
+                }
+                break;
+            }
+            case mdCmpt:
+            {
+                const typename fieldType::GeometricBoundaryField&
+                    fieldBoundary = field.boundaryField();
+
+                List<Type> minVs(Pstream::nProcs());
+                List<vector> minCs(Pstream::nProcs());
+                label minProcI = findMin(field);
+                minVs[procI] = field[minProcI];
+                minCs[procI] = field.mesh().C()[minProcI];
+
+                Pstream::gatherList(minVs);
+                Pstream::gatherList(minCs);
+
+                List<Type> maxVs(Pstream::nProcs());
+                List<vector> maxCs(Pstream::nProcs());
+                label maxProcI = findMax(field);
+                maxVs[procI] = field[maxProcI];
+                maxCs[procI] = field.mesh().C()[maxProcI];
+
+                forAll(fieldBoundary, patchI)
+                {
+                    const Field<Type>& fp = fieldBoundary[patchI];
+                    if (fp.size())
+                    {
+                        const vectorField& Cfp = CfBoundary[patchI];
+
+                        label minPI = findMin(fp);
+                        if (fp[minPI] < minVs[procI])
+                        {
+                            minVs[procI] = fp[minPI];
+                            minCs[procI] = Cfp[minPI];
+                        }
+
+                        label maxPI = findMax(fp);
+                        if (fp[maxPI] > maxVs[procI])
+                        {
+                            maxVs[procI] = fp[maxPI];
+                            maxCs[procI] = Cfp[maxPI];
+                        }
+                    }
+                }
+
+                Pstream::gatherList(minVs);
+                Pstream::gatherList(minCs);
+
+                Pstream::gatherList(maxVs);
+                Pstream::gatherList(maxCs);
+
+                if (Pstream::master())
+                {
+                    label minI = findMin(minVs);
+                    Type minValue = minVs[minI];
+                    const vector& minC = minCs[minI];
+
+                    label maxI = findMax(maxVs);
+                    Type maxValue = maxVs[maxI];
+                    const vector& maxC = maxCs[maxI];
+
+                    output
+                    (
+                        fieldName,
+                        fieldName,
+                        minC,
+                        maxC,
+                        minI,
+                        maxI,
+                        minValue,
+                        maxValue
+                    );
+                }
+                break;
+            }
+            default:
+            {
+                FatalErrorIn
+                (
+                    "Foam::fieldMinMax::calcMinMaxFields"
+                    "("
+                        "const word&, "
+                        "const modeType&"
+                    ")"
+                )
+                    << "Unknown min/max mode: " << modeTypeNames_[mode_]
+                    << exit(FatalError);
+            }
+        }
+    }
+}
+
+
+// ************************************************************************* //

src/postProcessing/functionObjects/field/fieldValues/cellSource/IOcellSource.H

@@ -0,0 +1,50 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 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/>.
+
+Typedef
+    Foam::IOcellSource
+
+
+Description
+    Instance of the generic IOOutputFilter for cellSource.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef IOcellSource_H
+#define IOcellSource_H
+
+#include "cellSource.H"
+#include "IOOutputFilter.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    typedef IOOutputFilter<cellSource> IOcellSource;
+}
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/postProcessing/functionObjects/field/fieldValues/cellSource/cellSource.C

@@ -0,0 +1,253 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2014 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "cellSource.H"
+#include "fvMesh.H"
+#include "volFields.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    template<>
+    const char* NamedEnum<fieldValues::cellSource::sourceType, 2>::names[] =
+    {
+        "cellZone",
+        "all"
+    };
+
+
+    template<>
+    const char* NamedEnum<fieldValues::cellSource::operationType, 9>::names[] =
+    {
+        "none",
+        "sum",
+        "average",
+        "weightedAverage",
+        "volAverage",
+        "volIntegrate",
+        "min",
+        "max",
+        "CoV"
+    };
+
+    namespace fieldValues
+    {
+        defineTypeNameAndDebug(cellSource, 0);
+        addToRunTimeSelectionTable(fieldValue, cellSource, dictionary);
+    }
+}
+
+
+const Foam::NamedEnum<Foam::fieldValues::cellSource::sourceType, 2>
+    Foam::fieldValues::cellSource::sourceTypeNames_;
+
+const Foam::NamedEnum<Foam::fieldValues::cellSource::operationType, 9>
+    Foam::fieldValues::cellSource::operationTypeNames_;
+
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+void Foam::fieldValues::cellSource::setCellZoneCells()
+{
+    switch (source_)
+    {
+        case stCellZone:
+        {
+            label zoneId = mesh().cellZones().findZoneID(sourceName_);
+
+            if (zoneId < 0)
+            {
+                FatalErrorIn("cellSource::cellSource::setCellZoneCells()")
+                    << "Unknown cell zone name: " << sourceName_
+                    << ". Valid cell zones are: " << mesh().cellZones().names()
+                    << nl << exit(FatalError);
+            }
+
+            cellId_ = mesh().cellZones()[zoneId];
+            nCells_ = returnReduce(cellId_.size(), sumOp<label>());
+            break;
+        }
+
+        case stAll:
+        {
+            cellId_ = identity(mesh().nCells());
+            nCells_ = returnReduce(cellId_.size(), sumOp<label>());
+            break;
+        }
+
+        default:
+        {
+            FatalErrorIn("cellSource::setCellZoneCells()")
+               << "Unknown source type. Valid source types are:"
+                << sourceTypeNames_ << nl << exit(FatalError);
+        }
+    }
+
+    if (debug)
+    {
+        Pout<< "Selected source size = " << cellId_.size() << endl;
+    }
+}
+
+
+// * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
+
+void Foam::fieldValues::cellSource::initialise(const dictionary& dict)
+{
+    setCellZoneCells();
+
+    if (nCells_ == 0)
+    {
+        WarningIn
+        (
+            "Foam::fieldValues::cellSource::initialise(const dictionary&)"
+        )
+            << type() << " " << name_ << ": "
+            << sourceTypeNames_[source_] << "(" << sourceName_ << "):" << nl
+            << "    Source has no cells - deactivating" << endl;
+
+        active_ = false;
+        return;
+    }
+
+    Info<< type() << " " << name_ << ":"
+        << sourceTypeNames_[source_] << "(" << sourceName_ << "):" << nl
+        << "    total cells  = " << nCells_ << nl
+        << "    total volume = " << gSum(filterField(mesh().V()))
+        << nl << endl;
+
+    if (dict.readIfPresent("weightField", weightFieldName_))
+    {
+        Info<< "    weight field = " << weightFieldName_;
+    }
+
+    Info<< nl << endl;
+}
+
+
+void Foam::fieldValues::cellSource::writeFileHeader(const label i)
+{
+    file()
+        << "# Source : " << sourceTypeNames_[source_] << " "
+        << sourceName_ <<  nl << "# Cells  : " << nCells_ << nl
+        << "# Time" << tab << "sum(V)";
+
+    forAll(fields_, i)
+    {
+        file()
+            << tab << operationTypeNames_[operation_]
+            << "(" << fields_[i] << ")";
+    }
+
+    file() << endl;
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::fieldValues::cellSource::cellSource
+(
+    const word& name,
+    const objectRegistry& obr,
+    const dictionary& dict,
+    const bool loadFromFiles
+)
+:
+    fieldValue(name, obr, dict, typeName, loadFromFiles),
+    source_(sourceTypeNames_.read(dict.lookup("source"))),
+    operation_(operationTypeNames_.read(dict.lookup("operation"))),
+    nCells_(0),
+    cellId_(),
+    weightFieldName_("none")
+{
+    read(dict);
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::fieldValues::cellSource::~cellSource()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+void Foam::fieldValues::cellSource::read(const dictionary& dict)
+{
+    fieldValue::read(dict);
+
+    if (active_)
+    {
+        // no additional info to read
+        initialise(dict);
+    }
+}
+
+
+void Foam::fieldValues::cellSource::write()
+{
+    fieldValue::write();
+
+    if (active_)
+    {
+        scalar totalVolume = gSum(filterField(mesh().V()));
+        if (Pstream::master())
+        {
+            file() << obr_.time().value() << tab << totalVolume;
+        }
+
+        forAll(fields_, i)
+        {
+            const word& fieldName = fields_[i];
+            bool processed = false;
+
+            processed = processed || writeValues<scalar>(fieldName);
+            processed = processed || writeValues<vector>(fieldName);
+            processed = processed || writeValues<sphericalTensor>(fieldName);
+            processed = processed || writeValues<symmTensor>(fieldName);
+            processed = processed || writeValues<tensor>(fieldName);
+
+            if (!processed)
+            {
+                WarningIn("void Foam::fieldValues::cellSource::write()")
+                    << "Requested field " << fieldName
+                    << " not found in database and not processed"
+                    << endl;
+            }
+        }
+
+        if (Pstream::master())
+        {
+            file()<< endl;
+        }
+
+        Info(log_)<< endl;
+    }
+}
+
+
+// ************************************************************************* //

src/postProcessing/functionObjects/field/fieldValues/cellSource/cellSource.H

@@ -0,0 +1,288 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2012 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/>.
+
+Class
+    Foam::fieldValues::cellSource
+
+Group
+    grpFieldFunctionObjects
+
+Description
+    This function object provides a 'cell source' variant of the fieldValues
+    function object.  Given a list of user-specified fields and a selection
+    of mesh cells, a number of operations can be performed, such as sums,
+    averages and integrations.
+
+
+    Example of function object specification:
+    \verbatim
+    cellSource1
+    {
+        type            cellSource;
+        functionObjectLibs ("libfieldFunctionObjects.so");
+        ...
+        log             true;
+        valueOutput     true;
+        source          cellZone;
+        sourceName      c0;
+        operation       volAverage;
+        weightField     alpha1;
+        fields
+        (
+            p
+            U
+        );
+    }
+    \endverbatim
+
+    \heading Function object usage
+    \table
+        Property     | Description             | Required    | Default value
+        type         | type name: cellSource   | yes         |
+        log          | write data to standard output | no    | no
+        valueOutput  | write the raw output values | yes     |
+        source       | cell source: see below  | yes         |
+        sourceName   | name of cell source if required  | no |
+        operation    | operation to perform    | yes         |
+        weightField  | name of field to apply weighting | no |
+        fields       | list of fields to operate on | yes    |
+    \endtable
+
+    \linebreak
+    Where \c source is defined by
+    \plaintable
+        cellZone     | requires a 'sourceName' entry to specify the cellZone
+        all          | all cells
+    \endplaintable
+
+    \linebreak
+    The \c operation is one of:
+    \plaintable
+       none          | no operation
+       sum           | sum
+       average       | ensemble average
+       weightedAverage | weighted average
+       volAverage    | volume weighted average
+       volIntegrate  | volume integral
+       min           | minimum
+       max           | maximum
+       CoV           | coefficient of variation: standard deviation/mean
+    \endplaintable
+
+SeeAlso
+    Foam::fieldValues
+    Foam::functionObject
+    Foam::OutputFilterFunctionObject
+
+SourceFiles
+    cellSource.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef cellSource_H
+#define cellSource_H
+
+#include "NamedEnum.H"
+#include "fieldValue.H"
+#include "labelList.H"
+#include "volFieldsFwd.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace fieldValues
+{
+
+/*---------------------------------------------------------------------------*\
+                         Class cellSource Declaration
+\*---------------------------------------------------------------------------*/
+
+class cellSource
+:
+    public fieldValue
+{
+
+public:
+
+    // Public data types
+
+        //- Source type enumeration
+        enum sourceType
+        {
+            stCellZone,
+            stAll
+        };
+
+        //- Source type names
+        static const NamedEnum<sourceType, 2> sourceTypeNames_;
+
+
+        //- Operation type enumeration
+        enum operationType
+        {
+            opNone,
+            opSum,
+            opAverage,
+            opWeightedAverage,
+            opVolAverage,
+            opVolIntegrate,
+            opMin,
+            opMax,
+            opCoV
+        };
+
+        //- Operation type names
+        static const NamedEnum<operationType, 9> operationTypeNames_;
+
+
+private:
+
+    // Private Member Functions
+
+        //- Set cells to evaluate based on a cell zone
+        void setCellZoneCells();
+
+        //- Set cells to evaluate based on a patch
+        void setPatchCells();
+
+
+protected:
+
+    // Protected data
+
+        //- Source type
+        sourceType source_;
+
+        //- Operation to apply to values
+        operationType operation_;
+
+        //- Global number of cells
+        label nCells_;
+
+        //- Local list of cell IDs
+        labelList cellId_;
+
+        //- Weight field name - only used for opWeightedAverage mode
+        word weightFieldName_;
+
+
+    // Protected Member Functions
+
+        //- Initialise, e.g. cell addressing
+        void initialise(const dictionary& dict);
+
+        //- Return true if the field name is valid
+        template<class Type>
+        bool validField(const word& fieldName) const;
+
+        //- Insert field values into values list
+        template<class Type>
+        tmp<Field<Type> > setFieldValues
+        (
+            const word& fieldName,
+            const bool mustGet = false
+        ) const;
+
+        //- Apply the 'operation' to the values
+        template<class Type>
+        Type processValues
+        (
+            const Field<Type>& values,
+            const scalarField& V,
+            const scalarField& weightField
+        ) const;
+
+        //- Output file header information
+        virtual void writeFileHeader(const label i);
+
+
+public:
+
+    //- Run-time type information
+    TypeName("cellSource");
+
+
+    //- Construct from components
+    cellSource
+    (
+        const word& name,
+        const objectRegistry& obr,
+        const dictionary& dict,
+        const bool loadFromFiles = false
+    );
+
+
+    //- Destructor
+    virtual ~cellSource();
+
+
+    // Public Member Functions
+
+        // Access
+
+            //- Return the source type
+            inline const sourceType& source() const;
+
+            //- Return the local list of cell IDs
+            inline const labelList& cellId() const;
+
+
+        // Function object functions
+
+            //- Read from dictionary
+            virtual void read(const dictionary&);
+
+            //- Calculate and write
+            virtual void write();
+
+            //- Templated helper function to output field values
+            template<class Type>
+            bool writeValues(const word& fieldName);
+
+            //- Filter a field according to cellIds
+            template<class Type>
+            tmp<Field<Type> > filterField(const Field<Type>& field) const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace fieldValues
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#include "cellSourceI.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+    #include "cellSourceTemplates.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/postProcessing/functionObjects/field/fieldValues/cellSource/cellSourceFunctionObject.C

@@ -0,0 +1,46 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "cellSourceFunctionObject.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineNamedTemplateTypeNameAndDebug
+    (
+        cellSourceFunctionObject,
+        0
+    );
+
+    addToRunTimeSelectionTable
+    (
+        functionObject,
+        cellSourceFunctionObject,
+        dictionary
+    );
+}
+
+// ************************************************************************* //

src/postProcessing/functionObjects/field/fieldValues/cellSource/cellSourceFunctionObject.H

@@ -0,0 +1,54 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 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/>.
+
+Typedef
+    Foam::cellSourceFunctionObject
+
+Description
+    FunctionObject wrapper around cellSource to allow it to be
+    created via the functions entry within controlDict.
+
+SourceFiles
+    cellSourceFunctionObject.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef cellSourceFunctionObject_H
+#define cellSourceFunctionObject_H
+
+#include "cellSource.H"
+#include "OutputFilterFunctionObject.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    typedef OutputFilterFunctionObject<fieldValues::cellSource>
+        cellSourceFunctionObject;
+}
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/postProcessing/functionObjects/field/fieldValues/cellSource/cellSourceI.H

@@ -0,0 +1,45 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "cellSource.H"
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+inline const Foam::fieldValues::cellSource::sourceType&
+Foam::fieldValues::cellSource::source() const
+{
+    return source_;
+}
+
+
+inline const Foam::labelList&
+Foam::fieldValues::cellSource::cellId() const
+{
+    return cellId_;
+}
+
+
+// ************************************************************************* //
+

src/postProcessing/functionObjects/field/fieldValues/cellSource/cellSourceTemplates.C

@@ -0,0 +1,224 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2014 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "cellSource.H"
+#include "volFields.H"
+
+// * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
+
+template<class Type>
+bool Foam::fieldValues::cellSource::validField(const word& fieldName) const
+{
+    typedef GeometricField<Type, fvPatchField, volMesh> vf;
+
+    if (obr_.foundObject<vf>(fieldName))
+    {
+        return true;
+    }
+
+    return false;
+}
+
+
+template<class Type>
+Foam::tmp<Foam::Field<Type> > Foam::fieldValues::cellSource::setFieldValues
+(
+    const word& fieldName,
+    const bool mustGet
+) const
+{
+    typedef GeometricField<Type, fvPatchField, volMesh> vf;
+
+    if (obr_.foundObject<vf>(fieldName))
+    {
+        return filterField(obr_.lookupObject<vf>(fieldName));
+    }
+
+    if (mustGet)
+    {
+        FatalErrorIn
+        (
+            "Foam::tmp<Foam::Field<Type> > "
+            "Foam::fieldValues::cellSource::setFieldValues"
+            "("
+                "const word&, "
+                "const bool"
+            ") const"
+        )   << "Field " << fieldName << " not found in database"
+            << abort(FatalError);
+    }
+
+    return tmp<Field<Type> >(new Field<Type>(0.0));
+}
+
+
+template<class Type>
+Type Foam::fieldValues::cellSource::processValues
+(
+    const Field<Type>& values,
+    const scalarField& V,
+    const scalarField& weightField
+) const
+{
+    Type result = pTraits<Type>::zero;
+    switch (operation_)
+    {
+        case opSum:
+        {
+            result = sum(values);
+            break;
+        }
+        case opAverage:
+        {
+            result = sum(values)/values.size();
+            break;
+        }
+        case opWeightedAverage:
+        {
+            result = sum(values)/sum(weightField);
+            break;
+        }
+        case opVolAverage:
+        {
+            result = sum(values*V)/sum(V);
+            break;
+        }
+        case opVolIntegrate:
+        {
+            result = sum(values*V);
+            break;
+        }
+        case opMin:
+        {
+            result = min(values);
+            break;
+        }
+        case opMax:
+        {
+            result = max(values);
+            break;
+        }
+        case opCoV:
+        {
+            Type meanValue = sum(values*V)/sum(V);
+
+            const label nComp = pTraits<Type>::nComponents;
+
+            for (direction d=0; d<nComp; ++d)
+            {
+                scalarField vals(values.component(d));
+                scalar mean = component(meanValue, d);
+                scalar& res = setComponent(result, d);
+
+                res = sqrt(sum(V*sqr(vals - mean))/sum(V))/mean;
+            }
+
+            break;
+        }
+        default:
+        {
+            // Do nothing
+        }
+    }
+
+    return result;
+}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+template<class Type>
+bool Foam::fieldValues::cellSource::writeValues(const word& fieldName)
+{
+    const bool ok = validField<Type>(fieldName);
+
+    if (ok)
+    {
+        Field<Type> values(setFieldValues<Type>(fieldName));
+        scalarField V(filterField(mesh().V()));
+        scalarField weightField(values.size(), 1.0);
+
+        if (weightFieldName_ != "none")
+        {
+            weightField = setFieldValues<scalar>(weightFieldName_, true);
+        }
+
+        // Combine onto master
+        combineFields(values);
+        combineFields(V);
+        combineFields(weightField);
+
+        // apply weight field
+        values *= weightField;
+
+        if (Pstream::master())
+        {
+            Type result = processValues(values, V, weightField);
+
+            // add to result dictionary, over-writing any previous entry
+            resultDict_.add(fieldName, result, true);
+
+            if (valueOutput_)
+            {
+                IOField<Type>
+                (
+                    IOobject
+                    (
+                        fieldName + "_" + sourceTypeNames_[source_] + "-"
+                            + sourceName_,
+                        obr_.time().timeName(),
+                        obr_,
+                        IOobject::NO_READ,
+                        IOobject::NO_WRITE
+                    ),
+                    values
+                ).write();
+            }
+
+
+            file()<< tab << result;
+
+            Info(log_)<< "    " << operationTypeNames_[operation_]
+                << "(" << sourceName_ << ") for " << fieldName
+                <<  " = " << result << endl;
+        }
+    }
+
+    return ok;
+}
+
+
+template<class Type>
+Foam::tmp<Foam::Field<Type> > Foam::fieldValues::cellSource::filterField
+(
+    const Field<Type>& field
+) const
+{
+    return tmp<Field<Type> >(new Field<Type>(field, cellId_));
+}
+
+
+// ************************************************************************* //
+

src/postProcessing/functionObjects/field/fieldValues/controlDict

@@ -0,0 +1,129 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  dev                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    object      controlDict;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+application     icoFoam;
+
+startFrom       startTime;
+
+startTime       0;
+
+stopAt          endTime;
+
+endTime         0.5;
+
+deltaT          0.005;
+
+writeControl    timeStep;
+
+writeInterval   20;
+
+purgeWrite      0;
+
+writeFormat     ascii;
+
+writePrecision  6;
+
+writeCompression off;
+
+timeFormat      general;
+
+timePrecision   6;
+
+runTimeModifiable true;
+
+functions
+{
+    faceObj1
+    {
+        type            faceSource;
+        functionObjectLibs ("libfieldFunctionObjects.so");
+
+        enabled         true;
+        outputControl   outputTime;
+
+        // Output to log&file (true) or to file only
+        log             true;
+
+        // Output field values as well
+        valueOutput     true;
+
+        // Type of source: patch/faceZone/sampledSurface
+        source          patch;
+
+        // if patch or faceZone: name of patch or faceZone
+        sourceName      movingWall;
+
+        //// if sampledSurface: dictionary with a sampledSurface
+        //// Note: will not sample surface fields.
+        //sampledSurfaceDict
+        //{
+        //    // Sampling on triSurface
+        //    type        sampledTriSurfaceMesh;
+        //    surface     integrationPlane.stl;
+        //    source      cells;  // sample cells or boundaryFaces
+        //    interpolate true;
+        //}
+
+        // Operation: areaAverage/sum/weightedAverage ...
+        operation       areaAverage;
+
+        fields
+        (
+            p
+            phi         // surface fields not supported for sampledSurface
+            U
+        );
+    }
+
+    faceObj2
+    {
+        type            faceSource;
+        functionObjectLibs ("libfieldFunctionObjects.so");
+        enabled         true;
+        outputControl   outputTime;
+        log             true;
+        valueOutput     true;
+        source          faceZone;
+        sourceName      f0;
+        operation       sum;
+
+        fields
+        (
+            phi
+        );
+    }
+
+    cellObj1
+    {
+        type            cellSource;
+        functionObjectLibs ("libfieldFunctionObjects.so");
+        enabled         true;
+        outputControl   outputTime;
+        log             true;
+        valueOutput     true;
+        source          cellZone;
+        sourceName      c0;
+        operation       volAverage;
+
+        fields
+        (
+            p
+            U
+        );
+    }
+}
+
+// ************************************************************************* //

src/postProcessing/functionObjects/field/fieldValues/faceSource/IOfaceSource.H

@@ -0,0 +1,50 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 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/>.
+
+Typedef
+    Foam::IOfaceSource
+
+
+Description
+    Instance of the generic IOOutputFilter for faceSource.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef IOfaceSource_H
+#define IOfaceSource_H
+
+#include "faceSource.H"
+#include "IOOutputFilter.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    typedef IOOutputFilter<faceSource> IOfaceSource;
+}
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/postProcessing/functionObjects/field/fieldValues/faceSource/faceSource.C

@@ -0,0 +1,730 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2014 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "faceSource.H"
+#include "fvMesh.H"
+#include "cyclicPolyPatch.H"
+#include "emptyPolyPatch.H"
+#include "coupledPolyPatch.H"
+#include "sampledSurface.H"
+#include "mergePoints.H"
+#include "indirectPrimitivePatch.H"
+#include "PatchTools.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    template<>
+    const char* NamedEnum<fieldValues::faceSource::sourceType, 3>::names[] =
+    {
+        "faceZone",
+        "patch",
+        "sampledSurface"
+    };
+
+
+    template<>
+    const char* NamedEnum<fieldValues::faceSource::operationType, 14>::names[] =
+    {
+        "none",
+        "sum",
+        "sumMag",
+        "sumDirection",
+        "sumDirectionBalance",
+        "average",
+        "weightedAverage",
+        "areaAverage",
+        "areaIntegrate",
+        "min",
+        "max",
+        "CoV",
+        "areaNormalAverage",
+        "areaNormalIntegrate"
+    };
+
+    namespace fieldValues
+    {
+        defineTypeNameAndDebug(faceSource, 0);
+        addToRunTimeSelectionTable(fieldValue, faceSource, dictionary);
+    }
+}
+
+
+const Foam::NamedEnum<Foam::fieldValues::faceSource::sourceType, 3>
+    Foam::fieldValues::faceSource::sourceTypeNames_;
+
+const Foam::NamedEnum<Foam::fieldValues::faceSource::operationType, 14>
+    Foam::fieldValues::faceSource::operationTypeNames_;
+
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+void Foam::fieldValues::faceSource::setFaceZoneFaces()
+{
+    label zoneId = mesh().faceZones().findZoneID(sourceName_);
+
+    if (zoneId < 0)
+    {
+        FatalErrorIn("faceSource::faceSource::setFaceZoneFaces()")
+            << type() << " " << name_ << ": "
+            << sourceTypeNames_[source_] << "(" << sourceName_ << "):" << nl
+            << "    Unknown face zone name: " << sourceName_
+            << ". Valid face zones are: " << mesh().faceZones().names()
+            << nl << exit(FatalError);
+    }
+
+    const faceZone& fZone = mesh().faceZones()[zoneId];
+
+    DynamicList<label> faceIds(fZone.size());
+    DynamicList<label> facePatchIds(fZone.size());
+    DynamicList<label> faceSigns(fZone.size());
+
+    forAll(fZone, i)
+    {
+        label faceI = fZone[i];
+
+        label faceId = -1;
+        label facePatchId = -1;
+        if (mesh().isInternalFace(faceI))
+        {
+            faceId = faceI;
+            facePatchId = -1;
+        }
+        else
+        {
+            facePatchId = mesh().boundaryMesh().whichPatch(faceI);
+            const polyPatch& pp = mesh().boundaryMesh()[facePatchId];
+            if (isA<coupledPolyPatch>(pp))
+            {
+                if (refCast<const coupledPolyPatch>(pp).owner())
+                {
+                    faceId = pp.whichFace(faceI);
+                }
+                else
+                {
+                    faceId = -1;
+                }
+            }
+            else if (!isA<emptyPolyPatch>(pp))
+            {
+                faceId = faceI - pp.start();
+            }
+            else
+            {
+                faceId = -1;
+                facePatchId = -1;
+            }
+        }
+
+        if (faceId >= 0)
+        {
+            if (fZone.flipMap()[i])
+            {
+                faceSigns.append(-1);
+            }
+            else
+            {
+                faceSigns.append(1);
+            }
+            faceIds.append(faceId);
+            facePatchIds.append(facePatchId);
+        }
+    }
+
+    faceId_.transfer(faceIds);
+    facePatchId_.transfer(facePatchIds);
+    faceSign_.transfer(faceSigns);
+    nFaces_ = returnReduce(faceId_.size(), sumOp<label>());
+
+    if (debug)
+    {
+        Pout<< "Original face zone size = " << fZone.size()
+            << ", new size = " << faceId_.size() << endl;
+    }
+}
+
+
+void Foam::fieldValues::faceSource::setPatchFaces()
+{
+    const label patchId = mesh().boundaryMesh().findPatchID(sourceName_);
+
+    if (patchId < 0)
+    {
+        FatalErrorIn("faceSource::constructFaceAddressing()")
+            << type() << " " << name_ << ": "
+            << sourceTypeNames_[source_] << "(" << sourceName_ << "):" << nl
+            << "    Unknown patch name: " << sourceName_
+            << ". Valid patch names are: "
+            << mesh().boundaryMesh().names() << nl
+            << exit(FatalError);
+    }
+
+    const polyPatch& pp = mesh().boundaryMesh()[patchId];
+
+    label nFaces = pp.size();
+    if (isA<emptyPolyPatch>(pp))
+    {
+        nFaces = 0;
+    }
+
+    faceId_.setSize(nFaces);
+    facePatchId_.setSize(nFaces);
+    faceSign_.setSize(nFaces);
+    nFaces_ = returnReduce(faceId_.size(), sumOp<label>());
+
+    forAll(faceId_, faceI)
+    {
+        faceId_[faceI] = faceI;
+        facePatchId_[faceI] = patchId;
+        faceSign_[faceI] = 1;
+    }
+}
+
+
+void Foam::fieldValues::faceSource::sampledSurfaceFaces(const dictionary& dict)
+{
+    surfacePtr_ = sampledSurface::New
+    (
+        name_,
+        mesh(),
+        dict.subDict("sampledSurfaceDict")
+    );
+    surfacePtr_().update();
+    nFaces_ = returnReduce(surfacePtr_().faces().size(), sumOp<label>());
+}
+
+
+void Foam::fieldValues::faceSource::combineMeshGeometry
+(
+    faceList& faces,
+    pointField& points
+) const
+{
+    List<faceList> allFaces(Pstream::nProcs());
+    List<pointField> allPoints(Pstream::nProcs());
+
+    labelList globalFacesIs(faceId_);
+    forAll(globalFacesIs, i)
+    {
+        if (facePatchId_[i] != -1)
+        {
+            label patchI = facePatchId_[i];
+            globalFacesIs[i] += mesh().boundaryMesh()[patchI].start();
+        }
+    }
+
+    // Add local faces and points to the all* lists
+    indirectPrimitivePatch pp
+    (
+        IndirectList<face>(mesh().faces(), globalFacesIs),
+        mesh().points()
+    );
+    allFaces[Pstream::myProcNo()] = pp.localFaces();
+    allPoints[Pstream::myProcNo()] = pp.localPoints();
+
+    Pstream::gatherList(allFaces);
+    Pstream::gatherList(allPoints);
+
+    // Renumber and flatten
+    label nFaces = 0;
+    label nPoints = 0;
+    forAll(allFaces, procI)
+    {
+        nFaces += allFaces[procI].size();
+        nPoints += allPoints[procI].size();
+    }
+
+    faces.setSize(nFaces);
+    points.setSize(nPoints);
+
+    nFaces = 0;
+    nPoints = 0;
+
+    // My own data first
+    {
+        const faceList& fcs = allFaces[Pstream::myProcNo()];
+        forAll(fcs, i)
+        {
+            const face& f = fcs[i];
+            face& newF = faces[nFaces++];
+            newF.setSize(f.size());
+            forAll(f, fp)
+            {
+                newF[fp] = f[fp] + nPoints;
+            }
+        }
+
+        const pointField& pts = allPoints[Pstream::myProcNo()];
+        forAll(pts, i)
+        {
+            points[nPoints++] = pts[i];
+        }
+    }
+
+    // Other proc data follows
+    forAll(allFaces, procI)
+    {
+        if (procI != Pstream::myProcNo())
+        {
+            const faceList& fcs = allFaces[procI];
+            forAll(fcs, i)
+            {
+                const face& f = fcs[i];
+                face& newF = faces[nFaces++];
+                newF.setSize(f.size());
+                forAll(f, fp)
+                {
+                    newF[fp] = f[fp] + nPoints;
+                }
+            }
+
+            const pointField& pts = allPoints[procI];
+            forAll(pts, i)
+            {
+                points[nPoints++] = pts[i];
+            }
+        }
+    }
+
+    // Merge
+    labelList oldToNew;
+    pointField newPoints;
+    bool hasMerged = mergePoints
+    (
+        points,
+        SMALL,
+        false,
+        oldToNew,
+        newPoints
+    );
+
+    if (hasMerged)
+    {
+        if (debug)
+        {
+            Pout<< "Merged from " << points.size()
+                << " down to " << newPoints.size() << " points" << endl;
+        }
+
+        points.transfer(newPoints);
+        forAll(faces, i)
+        {
+            inplaceRenumber(oldToNew, faces[i]);
+        }
+    }
+}
+
+
+void Foam::fieldValues::faceSource::combineSurfaceGeometry
+(
+    faceList& faces,
+    pointField& points
+) const
+{
+    if (surfacePtr_.valid())
+    {
+        const sampledSurface& s = surfacePtr_();
+
+        if (Pstream::parRun())
+        {
+            // dimension as fraction of mesh bounding box
+            scalar mergeDim = 1e-10*mesh().bounds().mag();
+
+            labelList pointsMap;
+
+            PatchTools::gatherAndMerge
+            (
+                mergeDim,
+                primitivePatch
+                (
+                    SubList<face>(s.faces(), s.faces().size()),
+                    s.points()
+                ),
+                points,
+                faces,
+                pointsMap
+            );
+        }
+        else
+        {
+            faces = s.faces();
+            points = s.points();
+        }
+    }
+}
+
+
+// * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
+
+void Foam::fieldValues::faceSource::initialise(const dictionary& dict)
+{
+    switch (source_)
+    {
+        case stFaceZone:
+        {
+            setFaceZoneFaces();
+            break;
+        }
+        case stPatch:
+        {
+            setPatchFaces();
+            break;
+        }
+        case stSampledSurface:
+        {
+            sampledSurfaceFaces(dict);
+            break;
+        }
+        default:
+        {
+            FatalErrorIn("faceSource::initialise()")
+                << type() << " " << name_ << ": "
+                << sourceTypeNames_[source_] << "(" << sourceName_ << "):"
+                << nl << "    Unknown source type. Valid source types are:"
+                << sourceTypeNames_.sortedToc() << nl << exit(FatalError);
+        }
+    }
+
+    if (nFaces_ == 0)
+    {
+        WarningIn
+        (
+            "Foam::fieldValues::faceSource::initialise(const dictionary&)"
+        )
+            << type() << " " << name_ << ": "
+            << sourceTypeNames_[source_] << "(" << sourceName_ << "):" << nl
+            << "    Source has no faces - deactivating" << endl;
+
+        active_ = false;
+        return;
+    }
+
+    scalar totalArea;
+
+    if (surfacePtr_.valid())
+    {
+        surfacePtr_().update();
+        totalArea = gSum(surfacePtr_().magSf());
+    }
+    else
+    {
+        totalArea = gSum(filterField(mesh().magSf(), false));
+    }
+
+    Info<< type() << " " << name_ << ":" << nl
+        << "    total faces  = " << nFaces_
+        << nl
+        << "    total area   = " << totalArea
+        << nl;
+
+    if (dict.readIfPresent("weightField", weightFieldName_))
+    {
+        Info<< "    weight field = " << weightFieldName_ << nl;
+
+        if (source_ == stSampledSurface)
+        {
+            FatalIOErrorIn
+            (
+                "void Foam::fieldValues::faceSource::initialise"
+                "("
+                    "const dictionary&"
+                ")",
+                dict
+            )
+                << "Cannot use weightField for a sampledSurface"
+                << exit(FatalIOError);
+        }
+    }
+
+    if (dict.found("orientedWeightField"))
+    {
+        if (weightFieldName_ == "none")
+        {
+            dict.lookup("orientedWeightField") >>  weightFieldName_;
+            Info<< "    weight field = " << weightFieldName_ << nl;
+            orientWeightField_ = true;
+        }
+        else
+        {
+            FatalIOErrorIn
+            (
+                "void Foam::fieldValues::faceSource::initialise"
+                "("
+                    "const dictionary&"
+                ")",
+                dict
+            )
+                << "Either weightField or orientedWeightField can be supplied, "
+                << "but not both"
+                << exit(FatalIOError);
+        }
+    }
+
+    List<word> orientedFields;
+    if (dict.readIfPresent("orientedFields", orientedFields))
+    {
+        orientedFieldsStart_ = fields_.size();
+        fields_.append(orientedFields);
+    }
+
+    if (dict.readIfPresent("scaleFactor", scaleFactor_))
+    {
+        Info<< "    scale factor = " << scaleFactor_ << nl;
+    }
+
+    Info<< nl << endl;
+
+    if (valueOutput_)
+    {
+        const word surfaceFormat(dict.lookup("surfaceFormat"));
+
+        surfaceWriterPtr_.reset
+        (
+            surfaceWriter::New
+            (
+                surfaceFormat,
+                dict.subOrEmptyDict("formatOptions").
+                    subOrEmptyDict(surfaceFormat)
+            ).ptr()
+        );
+    }
+}
+
+
+void Foam::fieldValues::faceSource::writeFileHeader(const label i)
+{
+    file()
+        << "# Source : " << sourceTypeNames_[source_] << " "
+        << sourceName_ <<  nl << "# Faces  : " << nFaces_ << nl
+        << "# Time" << tab << "sum(magSf)";
+
+    forAll(fields_, i)
+    {
+        file()
+            << tab << operationTypeNames_[operation_]
+            << "(" << fields_[i] << ")";
+    }
+
+    file() << endl;
+}
+
+
+template<>
+Foam::scalar Foam::fieldValues::faceSource::processValues
+(
+    const Field<scalar>& values,
+    const vectorField& Sf,
+    const scalarField& weightField
+) const
+{
+    switch (operation_)
+    {
+        case opSumDirection:
+        {
+            vector n(dict_.lookup("direction"));
+            return sum(pos(values*(Sf & n))*mag(values));
+        }
+        case opSumDirectionBalance:
+        {
+            vector n(dict_.lookup("direction"));
+            const scalarField nv(values*(Sf & n));
+
+            return sum(pos(nv)*mag(values) - neg(nv)*mag(values));
+        }
+        default:
+        {
+            // Fall through to other operations
+            return processSameTypeValues(values, Sf, weightField);
+        }
+    }
+}
+
+
+template<>
+Foam::vector Foam::fieldValues::faceSource::processValues
+(
+    const Field<vector>& values,
+    const vectorField& Sf,
+    const scalarField& weightField
+) const
+{
+    switch (operation_)
+    {
+        case opSumDirection:
+        {
+            vector n(dict_.lookup("direction"));
+            n /= mag(n) + ROOTVSMALL;
+            const scalarField nv(n & values);
+
+            return sum(pos(nv)*n*(nv));
+        }
+        case opSumDirectionBalance:
+        {
+            vector n(dict_.lookup("direction"));
+            n /= mag(n) + ROOTVSMALL;
+            const scalarField nv(n & values);
+
+            return sum(pos(nv)*n*(nv));
+        }
+        case opAreaNormalAverage:
+        {
+            scalar result = sum(values & Sf)/sum(mag(Sf));
+            return vector(result, 0.0, 0.0);
+        }
+        case opAreaNormalIntegrate:
+        {
+            scalar result = sum(values & Sf);
+            return vector(result, 0.0, 0.0);
+        }
+        default:
+        {
+            // Fall through to other operations
+            return processSameTypeValues(values, Sf, weightField);
+        }
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::fieldValues::faceSource::faceSource
+(
+    const word& name,
+    const objectRegistry& obr,
+    const dictionary& dict,
+    const bool loadFromFiles
+)
+:
+    fieldValue(name, obr, dict, typeName, loadFromFiles),
+    surfaceWriterPtr_(NULL),
+    source_(sourceTypeNames_.read(dict.lookup("source"))),
+    operation_(operationTypeNames_.read(dict.lookup("operation"))),
+    weightFieldName_("none"),
+    orientWeightField_(false),
+    orientedFieldsStart_(labelMax),
+    scaleFactor_(1.0),
+    nFaces_(0),
+    faceId_(),
+    facePatchId_(),
+    faceSign_()
+{
+    read(dict);
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::fieldValues::faceSource::~faceSource()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+void Foam::fieldValues::faceSource::read(const dictionary& dict)
+{
+    fieldValue::read(dict);
+
+    if (active_)
+    {
+        initialise(dict);
+    }
+}
+
+
+void Foam::fieldValues::faceSource::write()
+{
+    fieldValue::write();
+
+    if (active_)
+    {
+        scalar totalArea;
+
+        if (surfacePtr_.valid())
+        {
+            surfacePtr_().update();
+            totalArea = gSum(surfacePtr_().magSf());
+        }
+        else
+        {
+            totalArea = gSum(filterField(mesh().magSf(), false));
+        }
+
+        if (Pstream::master())
+        {
+            file() << obr_.time().value() << tab << totalArea;
+        }
+
+        // construct weight field. Note: zero size means weight = 1
+        scalarField weightField;
+        if (weightFieldName_ != "none")
+        {
+            weightField =
+                getFieldValues<scalar>
+                (
+                    weightFieldName_,
+                    true,
+                    orientWeightField_
+                );
+        }
+
+        // Combine onto master
+        combineFields(weightField);
+
+        // process the fields
+        forAll(fields_, i)
+        {
+            const word& fieldName = fields_[i];
+            bool ok = false;
+
+            bool orient = i >= orientedFieldsStart_;
+            ok = ok || writeValues<scalar>(fieldName, weightField, orient);
+            ok = ok || writeValues<vector>(fieldName, weightField, orient);
+            ok = ok
+              || writeValues<sphericalTensor>(fieldName, weightField, orient);
+            ok = ok || writeValues<symmTensor>(fieldName, weightField, orient);
+            ok = ok || writeValues<tensor>(fieldName, weightField, orient);
+
+            if (!ok)
+            {
+                WarningIn("void Foam::fieldValues::faceSource::write()")
+                    << "Requested field " << fieldName
+                    << " not found in database and not processed"
+                    << endl;
+            }
+        }
+
+        if (Pstream::master())
+        {
+            file()<< endl;
+        }
+
+        Info(log_)<< endl;
+    }
+}
+
+
+// ************************************************************************* //

src/postProcessing/functionObjects/field/fieldValues/faceSource/faceSource.H

@@ -0,0 +1,433 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2014 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/>.
+
+Class
+    Foam::fieldValues::faceSource
+
+Group
+    grpFieldFunctionObjects
+
+Description
+    This function object provides a 'face source' variant of the fieldValues
+    function object.  Given a list of user-specified fields and a selection
+    of mesh (or general surface) faces, a number of operations can be
+    performed, such as sums, averages and integrations.
+
+    \linebreak
+    For example, to calculate the volumetric or mass flux across a patch,
+    apply the 'sum' operator to the flux field (typically \c phi)
+
+    Example of function object specification:
+    \verbatim
+    faceSource1
+    {
+        type            faceSource;
+        functionObjectLibs ("libfieldFunctionObjects.so");
+        ...
+        log             yes;
+        valueOutput     true;
+        surfaceFormat   none;
+        source          faceZone;
+        sourceName      f0;
+        operation       sum;
+        weightField     alpha1;
+        fields
+        (
+            p
+            phi
+            U
+        );
+    }
+    \endverbatim
+
+    \heading Function object usage
+    \table
+        Property     | Description             | Required    | Default value
+        type         | type name: faceSource   | yes         |
+        log          | write data to standard output | no    | no
+        valueOutput  | write the output values | yes         |
+        surfaceFormat | output value format    | no          |
+        source       | face source: see below  | yes         |
+        sourceName   | name of face source if required  | no |
+        operation    | operation to perform    | yes         |
+        weightField  | name of field to apply weighting | no |
+        orientedWeightField  | name of oriented field to apply weighting | no |
+        scaleFactor  | scale factor            | no          | 1
+        fields       | list of fields to operate on | yes    |
+        orientedFields | list of oriented fields to operate on | no |
+    \endtable
+
+    \linebreak
+    Where \c source is defined by
+    \plaintable
+        faceZone     | requires a 'sourceName' entry to specify the faceZone
+        patch        | requires a 'sourceName' entry to specify the patch
+        sampledSurface | requires a 'sampledSurfaceDict' sub-dictionary
+    \endplaintable
+
+    \linebreak
+    The \c operation is one of:
+    \plaintable
+       none          | no operation
+       sum           | sum
+       sumMag        | sum of component magnitudes
+       sumDirection  | sum values which are positive in given direction
+       sumDirectionBalance | sum of balance of values in given direction
+       average       | ensemble average
+       weightedAverage | weighted average
+       areaAverage   | area weighted average
+       areaIntegrate | area integral
+       min           | minimum
+       max           | maximum
+       CoV           | coefficient of variation: standard deviation/mean
+       areaNormalAverage| area weighted average in face normal direction
+       areaNormalIntegrate | area weighted integral in face normal directon
+    \endplaintable
+
+Note
+    - The values reported by the areaNormalAverage and areaNormalIntegrate
+      operations are written as the first component of a field with the same
+      rank as the input field.
+    - faces on empty patches get ignored
+    - if the field is a volField the \c faceZone can only consist of boundary
+      faces
+    - the `oriented' entries relate to mesh-oriented fields, such as the
+      flux, phi.  These fields will be oriented according to the face normals.
+    - using \c sampledSurfaces:
+        - not available for surface fields
+        - if interpolate=true they use \c interpolationCellPoint
+          otherwise they use cell values
+        - each triangle in \c sampledSurface is logically only in one cell
+          so interpolation will be wrong when triangles are larger than
+          cells.  This can only happen for sampling on a \c triSurfaceMesh
+        - take care when using isoSurfaces - these might have duplicate
+          triangles and so integration might be wrong
+
+SeeAlso
+    Foam::fieldValues
+    Foam::functionObject
+    Foam::OutputFilterFunctionObject
+
+SourceFiles
+    faceSource.C
+    faceSourceTemplates.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef faceSource_H
+#define faceSource_H
+
+#include "NamedEnum.H"
+#include "fieldValue.H"
+#include "surfaceFieldsFwd.H"
+#include "volFieldsFwd.H"
+#include "surfaceWriter.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+class sampledSurface;
+
+namespace fieldValues
+{
+
+/*---------------------------------------------------------------------------*\
+                         Class faceSource Declaration
+\*---------------------------------------------------------------------------*/
+
+class faceSource
+:
+    public fieldValue
+{
+
+public:
+
+    // Public data types
+
+        //- Source type enumeration
+        enum sourceType
+        {
+            stFaceZone,
+            stPatch,
+            stSampledSurface
+        };
+
+        //- Source type names
+        static const NamedEnum<sourceType, 3> sourceTypeNames_;
+
+
+        //- Operation type enumeration
+        enum operationType
+        {
+            opNone,
+            opSum,
+            opSumMag,
+            opSumDirection,
+            opSumDirectionBalance,
+            opAverage,
+            opWeightedAverage,
+            opAreaAverage,
+            opAreaIntegrate,
+            opMin,
+            opMax,
+            opCoV,
+            opAreaNormalAverage,
+            opAreaNormalIntegrate
+        };
+
+        //- Operation type names
+        static const NamedEnum<operationType, 14> operationTypeNames_;
+
+
+private:
+
+    // Private Member Functions
+
+        //- Set faces to evaluate based on a face zone
+        void setFaceZoneFaces();
+
+        //- Set faces to evaluate based on a patch
+        void setPatchFaces();
+
+        //- Set faces according to sampledSurface
+        void sampledSurfaceFaces(const dictionary&);
+
+        //- Combine mesh faces and points from multiple processors 
+        void combineMeshGeometry
+        (
+            faceList& faces,
+            pointField& points
+        ) const;
+
+        //- Combine surface faces and points from multiple processors 
+        void combineSurfaceGeometry
+        (
+            faceList& faces,
+            pointField& points
+        ) const;
+
+
+protected:
+
+    // Protected data
+
+        //- Surface writer
+        autoPtr<surfaceWriter> surfaceWriterPtr_;
+
+        //- Source type
+        sourceType source_;
+
+        //- Operation to apply to values
+        operationType operation_;
+
+        //- Weight field name - optional
+        word weightFieldName_;
+
+        //- Flag to indicate if flipMap should be applied to the weight field
+        bool orientWeightField_;
+
+        //- Start index of fields that require application of flipMap
+        label orientedFieldsStart_;
+
+        //- Scale factor - optional
+        scalar scaleFactor_;
+
+        //- Global number of faces
+        label nFaces_;
+
+
+        // If operating on mesh faces (faceZone, patch)
+
+            //- Local list of face IDs
+            labelList faceId_;
+
+            //- Local list of patch ID per face
+            labelList facePatchId_;
+
+            //- List of +1/-1 representing face flip map
+            //  (1 use as is, -1 negate)
+            labelList faceSign_;
+
+
+        // If operating on sampledSurface
+
+            //- underlying sampledSurface
+            autoPtr<sampledSurface> surfacePtr_;
+
+
+    // Protected Member Functions
+
+        //- Initialise, e.g. face addressing
+        void initialise(const dictionary& dict);
+
+        //- Return true if the field name is valid
+        template<class Type>
+        bool validField(const word& fieldName) const;
+
+        //- Return field values by looking up field name
+        template<class Type>
+        tmp<Field<Type> > getFieldValues
+        (
+            const word& fieldName,
+            const bool mustGet = false,
+            const bool applyOrientation = false
+        ) const;
+
+        //- Apply the 'operation' to the values. Operation has to
+        //  preserve Type.
+        template<class Type>
+        Type processSameTypeValues
+        (
+            const Field<Type>& values,
+            const vectorField& Sf,
+            const scalarField& weightField
+        ) const;
+
+        //- Apply the 'operation' to the values. Wrapper around
+        //  processSameTypeValues. See also template specialisation below.
+        template<class Type>
+        Type processValues
+        (
+            const Field<Type>& values,
+            const vectorField& Sf,
+            const scalarField& weightField
+        ) const;
+
+        //- Output file header information
+        virtual void writeFileHeader(const label i);
+
+
+public:
+
+    //- Run-time type information
+    TypeName("faceSource");
+
+
+    //- Construct from components
+    faceSource
+    (
+        const word& name,
+        const objectRegistry& obr,
+        const dictionary& dict,
+        const bool loadFromFiles = false
+    );
+
+
+    //- Destructor
+    virtual ~faceSource();
+
+
+    // Public Member Functions
+
+        // Access
+
+            //- Return the source type
+            inline const sourceType& source() const;
+
+            //- Return the local list of face IDs
+            inline const labelList& faceId() const;
+
+            //- Return the local list of patch ID per face
+            inline const labelList& facePatch() const;
+
+            //- Return the list of +1/-1 representing face flip map
+            inline const labelList& faceSign() const;
+
+
+        // Function object functions
+
+            //- Read from dictionary
+            virtual void read(const dictionary&);
+
+            //- Calculate and write
+            virtual void write();
+
+            //- Templated helper function to output field values
+            template<class Type>
+            bool writeValues
+            (
+                const word& fieldName,
+                const scalarField& weightField,
+                const bool orient
+            );
+
+            //- Filter a surface field according to faceIds
+            template<class Type>
+            tmp<Field<Type> > filterField
+            (
+                const GeometricField<Type, fvsPatchField, surfaceMesh>& field,
+                const bool applyOrientation
+            ) const;
+
+            //- Filter a volume field according to faceIds
+            template<class Type>
+            tmp<Field<Type> > filterField
+            (
+                const GeometricField<Type, fvPatchField, volMesh>& field,
+                const bool applyOrientation
+            ) const;
+};
+
+
+//- Specialisation of processing scalars
+template<>
+scalar faceSource::processValues
+(
+    const Field<scalar>& values,
+    const vectorField& Sf,
+    const scalarField& weightField
+) const;
+
+
+//- Specialisation of processing vectors
+template<>
+vector faceSource::processValues
+(
+    const Field<vector>& values,
+    const vectorField& Sf,
+    const scalarField& weightField
+) const;
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace fieldValues
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#include "faceSourceI.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+    #include "faceSourceTemplates.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/postProcessing/functionObjects/field/fieldValues/faceSource/faceSourceFunctionObject.C

@@ -0,0 +1,46 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "faceSourceFunctionObject.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineNamedTemplateTypeNameAndDebug
+    (
+        faceSourceFunctionObject,
+        0
+    );
+
+    addToRunTimeSelectionTable
+    (
+        functionObject,
+        faceSourceFunctionObject,
+        dictionary
+    );
+}
+
+// ************************************************************************* //

src/postProcessing/functionObjects/field/fieldValues/faceSource/faceSourceFunctionObject.H

@@ -0,0 +1,54 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 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/>.
+
+Typedef
+    Foam::faceSourceFunctionObject
+
+Description
+    FunctionObject wrapper around faceSource to allow it to be
+    created via the functions entry within controlDict.
+
+SourceFiles
+    faceSourceFunctionObject.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef faceSourceFunctionObject_H
+#define faceSourceFunctionObject_H
+
+#include "faceSource.H"
+#include "OutputFilterFunctionObject.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    typedef OutputFilterFunctionObject<fieldValues::faceSource>
+        faceSourceFunctionObject;
+}
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/postProcessing/functionObjects/field/fieldValues/faceSource/faceSourceI.H

@@ -0,0 +1,59 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "faceSource.H"
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+inline const Foam::fieldValues::faceSource::sourceType&
+Foam::fieldValues::faceSource::source() const
+{
+    return source_;
+}
+
+
+inline const Foam::labelList&
+Foam::fieldValues::faceSource::faceId() const
+{
+    return faceId_;
+}
+
+
+inline const Foam::labelList&
+Foam::fieldValues::faceSource::facePatch() const
+{
+    return facePatchId_;
+}
+
+
+inline const Foam::labelList&
+Foam::fieldValues::faceSource::faceSign() const
+{
+    return faceSign_;
+}
+
+
+// ************************************************************************* //
+

src/postProcessing/functionObjects/field/fieldValues/faceSource/faceSourceTemplates.C

@@ -0,0 +1,450 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2014 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "faceSource.H"
+#include "surfaceFields.H"
+#include "volFields.H"
+#include "sampledSurface.H"
+#include "interpolationCellPoint.H"
+
+// * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
+
+template<class Type>
+bool Foam::fieldValues::faceSource::validField(const word& fieldName) const
+{
+    typedef GeometricField<Type, fvsPatchField, surfaceMesh> sf;
+    typedef GeometricField<Type, fvPatchField, volMesh> vf;
+
+    if (source_ != stSampledSurface && obr_.foundObject<sf>(fieldName))
+    {
+        return true;
+    }
+    else if (obr_.foundObject<vf>(fieldName))
+    {
+        return true;
+    }
+
+    return false;
+}
+
+
+template<class Type>
+Foam::tmp<Foam::Field<Type> > Foam::fieldValues::faceSource::getFieldValues
+(
+    const word& fieldName,
+    const bool mustGet,
+    const bool applyOrientation
+) const
+{
+    typedef GeometricField<Type, fvsPatchField, surfaceMesh> sf;
+    typedef GeometricField<Type, fvPatchField, volMesh> vf;
+
+    if (source_ != stSampledSurface && obr_.foundObject<sf>(fieldName))
+    {
+        return filterField(obr_.lookupObject<sf>(fieldName), applyOrientation);
+    }
+    else if (obr_.foundObject<vf>(fieldName))
+    {
+        const vf& fld = obr_.lookupObject<vf>(fieldName);
+
+        if (surfacePtr_.valid())
+        {
+            if (surfacePtr_().interpolate())
+            {
+                const interpolationCellPoint<Type> interp(fld);
+                tmp<Field<Type> > tintFld(surfacePtr_().interpolate(interp));
+                const Field<Type>& intFld = tintFld();
+
+                // Average
+                const faceList& faces = surfacePtr_().faces();
+                tmp<Field<Type> > tavg
+                (
+                    new Field<Type>(faces.size(), pTraits<Type>::zero)
+                );
+                Field<Type>& avg = tavg();
+
+                forAll(faces, faceI)
+                {
+                    const face& f = faces[faceI];
+                    forAll(f, fp)
+                    {
+                        avg[faceI] += intFld[f[fp]];
+                    }
+                    avg[faceI] /= f.size();
+                }
+
+                return tavg;
+            }
+            else
+            {
+                return surfacePtr_().sample(fld);
+            }
+        }
+        else
+        {
+            return filterField(fld, applyOrientation);
+        }
+    }
+
+    if (mustGet)
+    {
+        FatalErrorIn
+        (
+            "Foam::tmp<Foam::Field<Type> > "
+            "Foam::fieldValues::faceSource::getFieldValues"
+            "("
+                "const word&, "
+                "const bool, "
+                "const bool"
+            ") const"
+        )   << "Field " << fieldName << " not found in database"
+            << abort(FatalError);
+    }
+
+    return tmp<Field<Type> >(new Field<Type>(0));
+}
+
+
+template<class Type>
+Type Foam::fieldValues::faceSource::processSameTypeValues
+(
+    const Field<Type>& values,
+    const vectorField& Sf,
+    const scalarField& weightField
+) const
+{
+    Type result = pTraits<Type>::zero;
+    switch (operation_)
+    {
+        case opSum:
+        {
+            result = sum(values);
+            break;
+        }
+        case opSumMag:
+        {
+            result = sum(cmptMag(values));
+            break;
+        }
+        case opSumDirection:
+        {
+            FatalErrorIn
+            (
+                "template<class Type>"
+                "Type Foam::fieldValues::faceSource::processSameTypeValues"
+                "("
+                    "const Field<Type>&, "
+                    "const vectorField&, "
+                    "const scalarField&"
+                ") const"
+            )
+                << "Operation " << operationTypeNames_[operation_]
+                << " not available for values of type "
+                << pTraits<Type>::typeName
+                << exit(FatalError);
+
+            result = pTraits<Type>::zero;
+            break;
+        }
+        case opSumDirectionBalance:
+        {
+            FatalErrorIn
+            (
+                "template<class Type>"
+                "Type Foam::fieldValues::faceSource::processSameTypeValues"
+                "("
+                    "const Field<Type>&, "
+                    "const vectorField&, "
+                    "const scalarField&"
+                ") const"
+            )
+                << "Operation " << operationTypeNames_[operation_]
+                << " not available for values of type "
+                << pTraits<Type>::typeName
+                << exit(FatalError);
+
+            result = pTraits<Type>::zero;
+            break;
+        }
+        case opAverage:
+        {
+            result = sum(values)/values.size();
+            break;
+        }
+        case opWeightedAverage:
+        {
+            if (weightField.size())
+            {
+                result = sum(values)/sum(weightField);
+            }
+            else
+            {
+                result = sum(values)/values.size();
+            }
+            break;
+        }
+        case opAreaAverage:
+        {
+            const scalarField magSf(mag(Sf));
+
+            result = sum(values*magSf)/sum(magSf);
+            break;
+        }
+        case opAreaIntegrate:
+        {
+            const scalarField magSf(mag(Sf));
+
+            result = sum(values*magSf);
+            break;
+        }
+        case opMin:
+        {
+            result = min(values);
+            break;
+        }
+        case opMax:
+        {
+            result = max(values);
+            break;
+        }
+        case opCoV:
+        {
+            const scalarField magSf(mag(Sf));
+
+            Type meanValue = sum(values*magSf)/sum(magSf);
+
+            const label nComp = pTraits<Type>::nComponents;
+
+            for (direction d=0; d<nComp; ++d)
+            {
+                scalarField vals(values.component(d));
+                scalar mean = component(meanValue, d);
+                scalar& res = setComponent(result, d);
+
+                res = sqrt(sum(magSf*sqr(vals - mean))/sum(magSf))/mean;
+            }
+
+            break;
+        }
+        default:
+        {
+            // Do nothing
+        }
+    }
+
+    return result;
+}
+
+
+template<class Type>
+Type Foam::fieldValues::faceSource::processValues
+(
+    const Field<Type>& values,
+    const vectorField& Sf,
+    const scalarField& weightField
+) const
+{
+    return processSameTypeValues(values, Sf, weightField);
+}
+
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+template<class Type>
+bool Foam::fieldValues::faceSource::writeValues
+(
+    const word& fieldName,
+    const scalarField& weightField,
+    const bool orient
+)
+{
+    const bool ok = validField<Type>(fieldName);
+
+    if (ok)
+    {
+        Field<Type> values(getFieldValues<Type>(fieldName, true, orient));
+
+        vectorField Sf;
+        if (surfacePtr_.valid())
+        {
+            // Get oriented Sf
+            Sf = surfacePtr_().Sf();
+        }
+        else
+        {
+            // Get oriented Sf
+            Sf = filterField(mesh().Sf(), true);
+        }
+
+        // Combine onto master
+        combineFields(values);
+        combineFields(Sf);
+
+        // Write raw values on surface if specified
+        if (surfaceWriterPtr_.valid())
+        {
+            faceList faces;
+            pointField points;
+
+            if (surfacePtr_.valid())
+            {
+                combineSurfaceGeometry(faces, points);
+            }
+            else
+            {
+                combineMeshGeometry(faces, points);
+            }
+
+            if (Pstream::master())
+            {
+                fileName outputDir =
+                    baseFileDir()/name_/"surface"/obr_.time().timeName();
+
+                surfaceWriterPtr_->write
+                (
+                    outputDir,
+                    word(sourceTypeNames_[source_]) + "_" + sourceName_,
+                    points,
+                    faces,
+                    fieldName,
+                    values,
+                    false
+                );
+            }
+        }
+
+
+        // apply scale factor and weight field
+        values *= scaleFactor_;
+        if (weightField.size())
+        {
+            values *= weightField;
+        }
+
+        if (Pstream::master())
+        {
+            Type result = processValues(values, Sf, weightField);
+
+            // add to result dictionary, over-writing any previous entry
+            resultDict_.add(fieldName, result, true);
+
+            file()<< tab << result;
+
+            Info(log_)<< "    " << operationTypeNames_[operation_]
+                << "(" << sourceName_ << ") for " << fieldName
+                <<  " = " << result << endl;
+        }
+    }
+
+    return ok;
+}
+
+
+template<class Type>
+Foam::tmp<Foam::Field<Type> > Foam::fieldValues::faceSource::filterField
+(
+    const GeometricField<Type, fvPatchField, volMesh>& field,
+    const bool applyOrientation
+) const
+{
+    tmp<Field<Type> > tvalues(new Field<Type>(faceId_.size()));
+    Field<Type>& values = tvalues();
+
+    forAll(values, i)
+    {
+        label faceI = faceId_[i];
+        label patchI = facePatchId_[i];
+        if (patchI >= 0)
+        {
+            values[i] = field.boundaryField()[patchI][faceI];
+        }
+        else
+        {
+            FatalErrorIn
+            (
+                "fieldValues::faceSource::filterField"
+                "("
+                    "const GeometricField<Type, fvPatchField, volMesh>&, "
+                    "const bool"
+                ") const"
+            )   << type() << " " << name_ << ": "
+                << sourceTypeNames_[source_] << "(" << sourceName_ << "):"
+                << nl
+                << "    Unable to process internal faces for volume field "
+                << field.name() << nl << abort(FatalError);
+        }
+    }
+
+    if (applyOrientation)
+    {
+        forAll(values, i)
+        {
+            values[i] *= faceSign_[i];
+        }
+    }
+
+    return tvalues;
+}
+
+
+template<class Type>
+Foam::tmp<Foam::Field<Type> > Foam::fieldValues::faceSource::filterField
+(
+    const GeometricField<Type, fvsPatchField, surfaceMesh>& field,
+    const bool applyOrientation
+) const
+{
+    tmp<Field<Type> > tvalues(new Field<Type>(faceId_.size()));
+    Field<Type>& values = tvalues();
+
+    forAll(values, i)
+    {
+        label faceI = faceId_[i];
+        label patchI = facePatchId_[i];
+        if (patchI >= 0)
+        {
+            values[i] = field.boundaryField()[patchI][faceI];
+        }
+        else
+        {
+            values[i] = field[faceI];
+        }
+    }
+
+    if (applyOrientation)
+    {
+        forAll(values, i)
+        {
+            values[i] *= faceSign_[i];
+        }
+    }
+
+    return tvalues;
+}
+
+
+// ************************************************************************* //
+

src/postProcessing/functionObjects/field/fieldValues/fieldValue/fieldValue.C

@@ -0,0 +1,149 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2014 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "fieldValue.H"
+#include "fvMesh.H"
+#include "Time.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(fieldValue, 0);
+    defineRunTimeSelectionTable(fieldValue, dictionary);
+}
+
+
+// * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
+
+void Foam::fieldValue::read(const dictionary& dict)
+{
+    if (active_)
+    {
+        dict_ = dict;
+
+        log_ = dict.lookupOrDefault<Switch>("log", true);
+        dict.lookup("fields") >> fields_;
+        dict.lookup("valueOutput") >> valueOutput_;
+    }
+}
+
+
+void Foam::fieldValue::write()
+{
+    if (active_)
+    {
+        functionObjectFile::write();
+
+        Info(log_)<< type() << " " << name_ << " output:" << nl;
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::fieldValue::fieldValue
+(
+    const word& name,
+    const objectRegistry& obr,
+    const dictionary& dict,
+    const word& valueType,
+    const bool loadFromFiles
+)
+:
+    functionObjectFile(obr, name, valueType),
+    name_(name),
+    obr_(obr),
+    dict_(dict),
+    active_(true),
+    log_(true),
+    sourceName_(dict.lookupOrDefault<word>("sourceName", "sampledSurface")),
+    fields_(dict.lookup("fields")),
+    valueOutput_(dict.lookup("valueOutput")),
+    resultDict_(fileName("name"), dictionary::null)
+{
+    // Only active if obr is an fvMesh
+    if (isA<fvMesh>(obr_))
+    {
+        read(dict);
+    }
+    else
+    {
+        WarningIn
+        (
+            "fieldValue::fieldValue"
+            "("
+                "const word&, "
+                "const objectRegistry&, "
+                "const dictionary&, "
+                "const bool"
+            ")"
+        )   << "No fvMesh available, deactivating " << name << nl
+            << endl;
+        active_ = false;
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::fieldValue::~fieldValue()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+void Foam::fieldValue::execute()
+{
+    // Do nothing
+}
+
+
+void Foam::fieldValue::end()
+{
+    // Do nothing
+}
+
+
+void Foam::fieldValue::timeSet()
+{
+    // Do nothing
+}
+
+
+void Foam::fieldValue::updateMesh(const mapPolyMesh&)
+{
+    // Do nothing
+}
+
+
+void Foam::fieldValue::movePoints(const polyMesh&)
+{
+    // Do nothing
+}
+
+
+// ************************************************************************* //

src/postProcessing/functionObjects/field/fieldValues/fieldValue/fieldValue.H

@@ -0,0 +1,231 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2013 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/>.
+
+Class
+    Foam::fieldValue
+
+Group
+    grpFieldFunctionObjects
+
+Description
+    Base class for field value -based function objects.
+
+SourceFiles
+    fieldValue.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef fieldValue_H
+#define fieldValue_H
+
+#include "functionObjectFile.H"
+#include "Switch.H"
+#include "OFstream.H"
+#include "dictionary.H"
+#include "Field.H"
+#include "runTimeSelectionTables.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// Forward declaration of classes
+class objectRegistry;
+class fvMesh;
+class polyMesh;
+class mapPolyMesh;
+
+/*---------------------------------------------------------------------------*\
+                       Class fieldValue Declaration
+\*---------------------------------------------------------------------------*/
+
+class fieldValue
+:
+    public functionObjectFile
+{
+
+protected:
+
+    // Protected data
+
+        //- Name of this fieldValue object
+        word name_;
+
+        //- Database this class is registered to
+        const objectRegistry& obr_;
+
+        //- Construction dictionary
+        dictionary dict_;
+
+        //- Active flag
+        bool active_;
+
+        //- Switch to send output to Info as well as to file
+        Switch log_;
+
+        //- Name of source object
+        word sourceName_;
+
+        //- List of field names to operate on
+        wordList fields_;
+
+        //- Output field values flag
+        Switch valueOutput_;
+
+        //- Results dictionary for external access of results
+        dictionary resultDict_;
+
+
+public:
+
+    //- Run-time type information
+    TypeName("fieldValue");
+
+    // Declare runtime constructor selection table
+
+        declareRunTimeSelectionTable
+        (
+            autoPtr,
+            fieldValue,
+            dictionary,
+            (
+                const word& name,
+                const objectRegistry& obr,
+                const dictionary& dict,
+                const bool loadFromFiles
+            ),
+            (name, obr, dict, loadFromFiles)
+        );
+
+    //- Construct from components
+    fieldValue
+    (
+        const word& name,
+        const objectRegistry& obr,
+        const dictionary& dict,
+        const word& valueType,
+        const bool loadFromFiles = false
+    );
+
+    //- Return a reference to the selected fieldValue
+    static autoPtr<fieldValue> New
+    (
+        const word& name,
+        const objectRegistry& obr,
+        const dictionary& dict,
+        const bool loadFromFiles = false,
+        const bool output = true
+    );
+
+    //- Destructor
+    virtual ~fieldValue();
+
+
+    // Public Member Functions
+
+        // Access
+
+            //- Return the name of the geometric source
+            inline const word& name() const;
+
+            //- Return the reference to the object registry
+            inline const objectRegistry& obr() const;
+
+            //- Return the reference to the construction dictionary
+            inline const dictionary& dict() const;
+
+            //- Return the active flag
+            inline bool active() const;
+
+            //- Return the switch to send output to Info as well as to file
+            inline const Switch& log() const;
+
+            //- Return the source name
+            inline const word& sourceName() const;
+
+            //- Return the list of field names
+            inline const wordList& fields() const;
+
+            //- Return the output field values flag
+            inline const Switch& valueOutput() const;
+
+            //- Helper function to return the reference to the mesh
+            inline const fvMesh& mesh() const;
+
+            //- Return access to the latest set of results
+            inline const dictionary& resultDict() const;
+
+
+        // Function object functions
+
+            //- Read from dictionary
+            virtual void read(const dictionary& dict);
+
+            //- Write to screen/file
+            virtual void write();
+
+            //- Execute
+            virtual void execute();
+
+            //- Execute the at the final time-loop, currently does nothing
+            virtual void end();
+
+            //- Called when time was set at the end of the Time::operator++
+            virtual void timeSet();
+
+            //- Update mesh
+            virtual void updateMesh(const mapPolyMesh&);
+
+            //- Move points
+            virtual void movePoints(const polyMesh&);
+
+            //- Combine fields from all processor domains into single field
+            template<class Type>
+            void combineFields(Field<Type>& field);
+
+            //- Combine fields from all processor domains into single field
+            template<class Type>
+            void combineFields(tmp<Field<Type> >&);
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#include "fieldValueI.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+    #include "fieldValueTemplates.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/postProcessing/functionObjects/field/fieldValues/fieldValue/fieldValueI.H

@@ -0,0 +1,91 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2013 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "fieldValue.H"
+#include "fvMesh.H"
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+inline const Foam::word& Foam::fieldValue::name() const
+{
+    return name_;
+}
+
+
+inline const Foam::objectRegistry& Foam::fieldValue::obr() const
+{
+    return obr_;
+}
+
+
+inline const Foam::dictionary& Foam::fieldValue::dict() const
+{
+    return dict_;
+}
+
+
+inline bool Foam::fieldValue::active() const
+{
+    return active_;
+}
+
+
+inline const Foam::Switch& Foam::fieldValue::log() const
+{
+    return log_;
+}
+
+
+inline const Foam::word& Foam::fieldValue::sourceName() const
+{
+    return sourceName_;
+}
+
+
+inline const Foam::wordList& Foam::fieldValue::fields() const
+{
+    return fields_;
+}
+
+
+inline const Foam::Switch& Foam::fieldValue::valueOutput() const
+{
+    return valueOutput_;
+}
+
+
+inline const Foam::fvMesh& Foam::fieldValue::mesh() const
+{
+    return refCast<const fvMesh>(obr_);
+}
+
+
+inline const Foam::dictionary& Foam::fieldValue::resultDict() const
+{
+    return resultDict_;
+}
+
+
+// ************************************************************************* //

src/postProcessing/functionObjects/field/fieldValues/fieldValue/fieldValueNew.C

@@ -0,0 +1,80 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "fieldValue.H"
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+Foam::autoPtr<Foam::fieldValue> Foam::fieldValue::New
+(
+    const word& name,
+    const objectRegistry& obr,
+    const dictionary& dict,
+    const bool loadFromFiles,
+    const bool output
+)
+{
+    const word modelType(dict.lookup("type"));
+
+    if (output)
+    {
+        Info<< "Selecting " << typeName << " " << modelType << endl;
+    }
+
+    dictionaryConstructorTable::iterator cstrIter =
+        dictionaryConstructorTablePtr_->find(modelType);
+
+    if (cstrIter == dictionaryConstructorTablePtr_->end())
+    {
+        FatalErrorIn
+        (
+            "fieldValue::New"
+            "("
+                "const word&, "
+                "const objectRegistry&, "
+                "const dictionary&, "
+                "const bool"
+            ")"
+        )   << "Unknown " << typeName << " type "
+            << modelType << nl << nl
+            << "Valid " << typeName << " types are:" << nl
+            << dictionaryConstructorTablePtr_->sortedToc()
+            << exit(FatalError);
+    }
+
+    return autoPtr<fieldValue>
+    (
+        cstrIter()
+        (
+            name,
+            obr,
+            dict,
+            loadFromFiles
+        )
+    );
+}
+
+
+// ************************************************************************* //

src/postProcessing/functionObjects/field/fieldValues/fieldValue/fieldValueTemplates.C

@@ -0,0 +1,60 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "fieldValue.H"
+#include "ListListOps.H"
+#include "Pstream.H"
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+template<class Type>
+void Foam::fieldValue::combineFields(Field<Type>& field)
+{
+    List<Field<Type> > allValues(Pstream::nProcs());
+
+    allValues[Pstream::myProcNo()] = field;
+
+    Pstream::gatherList(allValues);
+
+    if (Pstream::master())
+    {
+        field =
+            ListListOps::combine<Field<Type> >
+            (
+                allValues,
+                accessOp<Field<Type> >()
+            );
+    }
+}
+
+
+template<class Type>
+void Foam::fieldValue::combineFields(tmp<Field<Type> >& field)
+{
+    combineFields(field());
+}
+
+
+// ************************************************************************* //

src/postProcessing/functionObjects/field/fieldValues/fieldValueDelta/IOfieldValueDelta.H

@@ -0,0 +1,50 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012 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/>.
+
+Typedef
+    Foam::IOfieldValueDelta
+
+
+Description
+    Instance of the generic IOOutputFilter for fieldValueDelta.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef IOfieldValueDelta_H
+#define IOfieldValueDelta_H
+
+#include "fieldValueDelta.H"
+#include "IOOutputFilter.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    typedef IOOutputFilter<fieldValueDelta> IOfieldValueDelta;
+}
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/postProcessing/functionObjects/field/fieldValues/fieldValueDelta/fieldValueDelta.C

@@ -0,0 +1,219 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012-2014 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "fieldValueDelta.H"
+#include "ListOps.H"
+#include "Time.H"
+#include "volFields.H"
+#include "surfaceFields.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    namespace fieldValues
+    {
+        defineTypeNameAndDebug(fieldValueDelta, 0);
+    }
+
+    template<>
+    const char*
+    NamedEnum<fieldValues::fieldValueDelta::operationType, 5>::names[] =
+    {
+        "add",
+        "subtract",
+        "min",
+        "max",
+        "average"
+    };
+
+    const NamedEnum<fieldValues::fieldValueDelta::operationType, 5>
+        fieldValues::fieldValueDelta::operationTypeNames_;
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::fieldValues::fieldValueDelta::fieldValueDelta
+(
+    const word& name,
+    const objectRegistry& obr,
+    const dictionary& dict,
+    const bool loadFromFiles
+)
+:
+    functionObjectFile(obr, name, typeName),
+    name_(name),
+    obr_(obr),
+    loadFromFiles_(loadFromFiles),
+    log_(true),
+    operation_(opSubtract),
+    source1Ptr_(NULL),
+    source2Ptr_(NULL)
+{
+    read(dict);
+}
+
+
+void Foam::fieldValues::fieldValueDelta::writeFileHeader(const label i)
+{
+    const wordList& fields1 = source1Ptr_->fields();
+    const wordList& fields2 = source2Ptr_->fields();
+
+    DynamicList<word> commonFields(fields1.size());
+    forAll(fields1, i)
+    {
+        label index = findIndex(fields2, fields1[i]);
+        if (index != -1)
+        {
+            commonFields.append(fields1[i]);
+        }
+    }
+
+    Ostream& os = file();
+
+    writeHeaderValue(os, "Source1", source1Ptr_->name());
+    writeHeaderValue(os, "Source2", source2Ptr_->name());
+    writeHeaderValue(os, "Operation", operationTypeNames_[operation_]);
+    writeCommented(os, "Time");
+
+    forAll(commonFields, i)
+    {
+        os  << tab << commonFields[i];
+    }
+
+    os  << endl;
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::fieldValues::fieldValueDelta::~fieldValueDelta()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+void Foam::fieldValues::fieldValueDelta::read(const dictionary& dict)
+{
+    log_ = dict.lookupOrDefault<Switch>("log", true);
+    source1Ptr_.reset
+    (
+        fieldValue::New
+        (
+            name_ + ".source1",
+            obr_,
+            dict.subDict("source1"),
+            loadFromFiles_,
+            false
+        ).ptr()
+    );
+    source2Ptr_.reset
+    (
+        fieldValue::New
+        (
+            name_ + ".source2",
+            obr_,
+            dict.subDict("source2"),
+            loadFromFiles_,
+            false
+        ).ptr()
+    );
+
+    operation_ = operationTypeNames_.read(dict.lookup("operation"));
+}
+
+
+void Foam::fieldValues::fieldValueDelta::write()
+{
+    functionObjectFile::write();
+
+    source1Ptr_->write();
+    source2Ptr_->write();
+
+    if (Pstream::master())
+    {
+        file()<< obr_.time().value();
+    }
+
+    Info(log_)<< type() << " " << name_ << " output:" << endl;
+
+    bool found = false;
+    processFields<scalar>(found);
+    processFields<vector>(found);
+    processFields<sphericalTensor>(found);
+    processFields<symmTensor>(found);
+    processFields<tensor>(found);
+
+    if (Pstream::master())
+    {
+        file()<< endl;
+    }
+
+    if (log_)
+    {
+        if (!found)
+        {
+            Info<< "    none" << endl;
+        }
+        else
+        {
+            Info<< endl;
+        }
+    }
+}
+
+
+void Foam::fieldValues::fieldValueDelta::execute()
+{
+    // Do nothing
+}
+
+
+void Foam::fieldValues::fieldValueDelta::end()
+{
+    // Do nothing
+}
+
+
+void Foam::fieldValues::fieldValueDelta::timeSet()
+{
+    // Do nothing
+}
+
+
+void Foam::fieldValues::fieldValueDelta::updateMesh(const mapPolyMesh&)
+{
+    // Do nothing
+}
+
+
+void Foam::fieldValues::fieldValueDelta::movePoints(const polyMesh&)
+{
+    // Do nothing
+}
+
+
+// ************************************************************************* //

src/postProcessing/functionObjects/field/fieldValues/fieldValueDelta/fieldValueDelta.H

@@ -0,0 +1,221 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012-2013 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/>.
+
+Class
+    Foam::fieldValues::fieldValueDelta
+
+Group
+    grpFieldFunctionObjects
+
+Description
+    This function object provides a differencing option between two 'field
+    value' function objects.
+
+    Example of function object specification:
+    \verbatim
+    fieldValueDelta1
+    {
+        type            fieldValueDelta;
+        functionObjectLibs ("libfieldFunctionObjects.so");
+        operation       subtract;
+
+        fieldValue1
+        {
+            ...
+        }
+        fieldValue2
+        {
+            ...
+        }
+    }
+    \endverbatim
+
+    \heading Function object usage
+    \table
+        Property     | Description             | Required    | Default value
+        type         | type name: fieldValueDelta   | yes    |
+    \endtable
+
+    \linebreak
+    The \c operation is one of:
+    \plaintable
+       add           | add
+       subtract      | subtract
+       min           | minimum
+       max           | maximum
+       average       | average
+    \endplaintable
+SeeAlso
+    Foam::fieldValue
+
+SourceFiles
+    fieldValueDelta.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef fieldValueDelta_H
+#define fieldValueDelta_H
+
+#include "functionObjectFile.H"
+#include "fieldValue.H"
+#include "autoPtr.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+namespace fieldValues
+{
+
+/*---------------------------------------------------------------------------*\
+                       Class fieldValueDelta Declaration
+\*---------------------------------------------------------------------------*/
+
+class fieldValueDelta
+:
+    public functionObjectFile
+{
+public:
+        //- Operation type enumeration
+        enum operationType
+        {
+            opAdd,
+            opSubtract,
+            opMin,
+            opMax,
+            opAverage
+        };
+
+        //- Operation type names
+        static const NamedEnum<operationType, 5> operationTypeNames_;
+
+
+private:
+
+    // Private data
+
+        //- Name of this fieldValue object
+        word name_;
+
+        //- Database this class is registered to
+        const objectRegistry& obr_;
+
+        //- Flag to indicate to load from files
+        bool loadFromFiles_;
+
+        //- Switch to send output to Info as well as to file
+        Switch log_;
+
+        //- Operation to apply to values
+        operationType operation_;
+
+        //- Field value source object 1
+        autoPtr<fieldValue> source1Ptr_;
+
+        //- Field value source object 2
+        autoPtr<fieldValue> source2Ptr_;
+
+
+    // Private Member Functions
+
+        //- Templated function to process common fields
+        template<class Type>
+        void processFields(bool& found);
+
+        //- Templated function to apply the operation
+        template<class Type>
+        Type applyOperation(const Type& value1, const Type& value2) const;
+
+
+protected:
+
+    // Functions to be over-ridden from IOoutputFilter class
+
+        //- Output file header information
+        virtual void writeFileHeader(const label i);
+
+
+public:
+
+    //- Run-time type information
+    TypeName("fieldValueDelta");
+
+
+    //- Construct from components
+    fieldValueDelta
+    (
+        const word& name,
+        const objectRegistry& obr,
+        const dictionary& dict,
+        const bool loadFromFiles = false
+    );
+
+
+    //- Destructor
+    virtual ~fieldValueDelta();
+
+
+    // Public Member Functions
+
+        // Function object functions
+
+            //- Read from dictionary
+            virtual void read(const dictionary&);
+
+            //- Calculate and write
+            virtual void write();
+
+            //- Execute
+            virtual void execute();
+
+            //- Execute the at the final time-loop, currently does nothing
+            virtual void end();
+
+             //- Called when time was set at the end of the Time::operator++
+            virtual void timeSet();
+
+            //- Update mesh
+            virtual void updateMesh(const mapPolyMesh&);
+
+            //- Move points
+            virtual void movePoints(const polyMesh&);
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace fieldValues
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+    #include "fieldValueDeltaTemplates.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/postProcessing/functionObjects/field/fieldValues/fieldValueDelta/fieldValueDeltaFunctionObject.C

@@ -0,0 +1,46 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "fieldValueDeltaFunctionObject.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineNamedTemplateTypeNameAndDebug
+    (
+        fieldValueDeltaFunctionObject,
+        0
+    );
+
+    addToRunTimeSelectionTable
+    (
+        functionObject,
+        fieldValueDeltaFunctionObject,
+        dictionary
+    );
+}
+
+// ************************************************************************* //

src/postProcessing/functionObjects/field/fieldValues/fieldValueDelta/fieldValueDeltaFunctionObject.H

@@ -0,0 +1,54 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012 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/>.
+
+Typedef
+    Foam::fieldValueDeltaFunctionObject
+
+Description
+    FunctionObject wrapper around fieldValueDelta to allow it to be
+    created via the functions entry within controlDict.
+
+SourceFiles
+    fieldValueDeltaFunctionObject.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef fieldValueDeltaFunctionObject_H
+#define fieldValueDeltaFunctionObject_H
+
+#include "fieldValueDelta.H"
+#include "OutputFilterFunctionObject.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    typedef OutputFilterFunctionObject<fieldValues::fieldValueDelta>
+        fieldValueDeltaFunctionObject;
+}
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/postProcessing/functionObjects/field/fieldValues/fieldValueDelta/fieldValueDeltaTemplates.C

@@ -0,0 +1,132 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012-2014 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "GeometricField.H"
+#include "volMesh.H"
+#include "surfaceMesh.H"
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+template<class Type>
+Type Foam::fieldValues::fieldValueDelta::applyOperation
+(
+    const Type& value1,
+    const Type& value2
+) const
+{
+    Type result = pTraits<Type>::zero;
+
+    switch (operation_)
+    {
+        case opAdd:
+        {
+            result = value1 + value2;
+            break;
+        }
+        case opSubtract:
+        {
+            result = value1 - value2;
+            break;
+        }
+        case opMin:
+        {
+            result = min(value1, value2);
+            break;
+        }
+        case opMax:
+        {
+            result = max(value1, value2);
+            break;
+        }
+        case opAverage:
+        {
+            result = 0.5*(value1 + value2);
+            break;
+        }
+        default:
+        {
+            FatalErrorIn
+            (
+                "Type Foam::fieldValues::fieldValueDelta::applyOperation"
+                "("
+                    "const Type&, "
+                    "const Type&"
+                ") const"
+            )
+                << "Unable to process operation "
+                << operationTypeNames_[operation_]
+                << abort(FatalError);
+        }
+    }
+
+    return result;
+}
+
+
+template<class Type>
+void Foam::fieldValues::fieldValueDelta::processFields(bool& found)
+{
+    typedef GeometricField<Type, fvPatchField, volMesh> vf;
+    typedef GeometricField<Type, fvsPatchField, surfaceMesh> sf;
+
+    const wordList& fields1 = source1Ptr_->fields();
+
+    const dictionary& results1 = source1Ptr_->resultDict();
+    const dictionary& results2 = source2Ptr_->resultDict();
+
+    Type r1(pTraits<Type>::zero);
+    Type r2(pTraits<Type>::zero);
+
+    forAll(fields1, i)
+    {
+        const word& fieldName = fields1[i];
+
+        if
+        (
+            (obr_.foundObject<vf>(fieldName) || obr_.foundObject<sf>(fieldName))
+         && results2.found(fieldName)
+        )
+        {
+            results1.lookup(fieldName) >> r1;
+            results2.lookup(fieldName) >> r2;
+
+            Type result = applyOperation(r1, r2);
+
+            Info(log_)<< "    " << operationTypeNames_[operation_]
+                << "(" << fieldName << ") = " << result
+                << endl;
+
+            if (Pstream::master())
+            {
+                file()<< tab << result;
+            }
+
+            found = true;
+        }
+    }
+}
+
+
+// ************************************************************************* //

src/postProcessing/functionObjects/field/nearWallFields/IOnearWallFields.H

@@ -0,0 +1,49 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 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/>.
+
+Typedef
+    Foam::IOnearWallFields
+
+Description
+    Instance of the generic IOOutputFilter for nearWallFields.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef IOnearWallFields_H
+#define IOnearWallFields_H
+
+#include "nearWallFields.H"
+#include "IOOutputFilter.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    typedef IOOutputFilter<nearWallFields> IOnearWallFields;
+}
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/postProcessing/functionObjects/field/nearWallFields/controlDict

@@ -0,0 +1,78 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  dev                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    object      controlDict;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+application     icoFoam;
+
+startFrom       startTime;
+
+startTime       0;
+
+stopAt          endTime;
+
+endTime         0.5;
+
+deltaT          0.005;
+
+writeControl    timeStep;
+
+writeInterval   20;
+
+purgeWrite      0;
+
+writeFormat     ascii;
+
+writePrecision  6;
+
+writeCompression off;
+
+timeFormat      general;
+
+timePrecision   6;
+
+runTimeModifiable true;
+
+functions
+{
+    near
+    {
+        // Where to load it from
+        functionObjectLibs ("libfieldFunctionObjects.so");
+
+        type nearWallFields;
+
+        // Output every
+        outputControl outputTime; //timeStep;
+        //outputInterval 5;
+
+        // Fields to be sampled. Per field original name and mapped field to
+        // create.
+        // Note: fields only get updated when writing!
+        fields
+        (
+            (p pNear)
+            (U UNear)
+        );
+
+        // Patches to sample (regular expressions)
+        patches ("movingWall");
+
+        // Distance to sample
+        distance 0.009;
+    }
+}
+
+
+// ************************************************************************* //

src/postProcessing/functionObjects/field/nearWallFields/findCellParticle.C

@@ -0,0 +1,237 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "findCellParticle.H"
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::findCellParticle::findCellParticle
+(
+    const polyMesh& mesh,
+    const vector& position,
+    const label cellI,
+    const label tetFaceI,
+    const label tetPtI,
+    const point& end,
+    const label data
+)
+:
+    particle(mesh, position, cellI, tetFaceI, tetPtI),
+    end_(end),
+    data_(data)
+{}
+
+
+Foam::findCellParticle::findCellParticle
+(
+    const polyMesh& mesh,
+    Istream& is,
+    bool readFields
+)
+:
+    particle(mesh, is, readFields)
+{
+    if (readFields)
+    {
+        if (is.format() == IOstream::ASCII)
+        {
+            is >> end_;
+            data_ = readLabel(is);
+        }
+        else
+        {
+            is.read
+            (
+                reinterpret_cast<char*>(&end_),
+                sizeof(end_) + sizeof(data_)
+            );
+        }
+    }
+
+    // Check state of Istream
+    is.check
+    (
+        "findCellParticle::findCellParticle"
+        "(const Cloud<findCellParticle>&, Istream&, bool)"
+    );
+}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+bool Foam::findCellParticle::move
+(
+    trackingData& td,
+    const scalar maxTrackLen
+)
+{
+    td.switchProcessor = false;
+    td.keepParticle = true;
+
+    scalar tEnd = (1.0 - stepFraction())*maxTrackLen;
+    scalar dtMax = tEnd;
+
+    while (td.keepParticle && !td.switchProcessor && tEnd > SMALL)
+    {
+        // set the lagrangian time-step
+        scalar dt = min(dtMax, tEnd);
+
+        dt *= trackToFace(end_, td);
+
+        tEnd -= dt;
+        stepFraction() = 1.0 - tEnd/maxTrackLen;
+    }
+
+    if (tEnd < SMALL || !td.keepParticle)
+    {
+        // Hit endpoint or patch. If patch hit could do fancy stuff but just
+        // to use the patch point is good enough for now.
+        td.cellToData()[cell()].append(data());
+        td.cellToEnd()[cell()].append(position());
+    }
+
+    return td.keepParticle;
+}
+
+
+bool Foam::findCellParticle::hitPatch
+(
+    const polyPatch&,
+    trackingData& td,
+    const label patchI,
+    const scalar trackFraction,
+    const tetIndices& tetIs
+)
+{
+    return false;
+}
+
+
+void Foam::findCellParticle::hitWedgePatch
+(
+    const wedgePolyPatch&,
+    trackingData& td
+)
+{
+    // Remove particle
+    td.keepParticle = false;
+}
+
+
+void Foam::findCellParticle::hitSymmetryPlanePatch
+(
+    const symmetryPlanePolyPatch&,
+    trackingData& td
+)
+{
+    // Remove particle
+    td.keepParticle = false;
+}
+
+
+void Foam::findCellParticle::hitSymmetryPatch
+(
+    const symmetryPolyPatch&,
+    trackingData& td
+)
+{
+    // Remove particle
+    td.keepParticle = false;
+}
+
+
+void Foam::findCellParticle::hitCyclicPatch
+(
+    const cyclicPolyPatch&,
+    trackingData& td
+)
+{
+    // Remove particle
+    td.keepParticle = false;
+}
+
+
+void Foam::findCellParticle::hitProcessorPatch
+(
+    const processorPolyPatch&,
+    trackingData& td
+)
+{
+    // Remove particle
+    td.switchProcessor = true;
+}
+
+
+void Foam::findCellParticle::hitWallPatch
+(
+    const wallPolyPatch& wpp,
+    trackingData& td,
+    const tetIndices&
+)
+{
+    // Remove particle
+    td.keepParticle = false;
+}
+
+
+void Foam::findCellParticle::hitPatch
+(
+    const polyPatch& wpp,
+    trackingData& td
+)
+{
+    // Remove particle
+    td.keepParticle = false;
+}
+
+
+// * * * * * * * * * * * * * * * IOstream Operators  * * * * * * * * * * * * //
+
+Foam::Ostream& Foam::operator<<(Ostream& os, const findCellParticle& p)
+{
+    if (os.format() == IOstream::ASCII)
+    {
+        os  << static_cast<const particle&>(p)
+            << token::SPACE << p.end_
+            << token::SPACE << p.data_;
+    }
+    else
+    {
+        os  << static_cast<const particle&>(p);
+        os.write
+        (
+            reinterpret_cast<const char*>(&p.end_),
+            sizeof(p.end_) + sizeof(p.data_)
+        );
+    }
+
+    // Check state of Ostream
+    os.check("Ostream& operator<<(Ostream&, const findCellParticle&)");
+
+    return os;
+}
+
+
+// ************************************************************************* //

src/postProcessing/functionObjects/field/nearWallFields/findCellParticle.H

@@ -0,0 +1,266 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 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/>.
+
+Class
+    Foam::findCellParticle
+
+Description
+    Particle class that finds cells by tracking
+
+SourceFiles
+    findCellParticle.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef findCellParticle_H
+#define findCellParticle_H
+
+#include "particle.H"
+#include "autoPtr.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+class findCellParticleCloud;
+
+/*---------------------------------------------------------------------------*\
+                     Class findCellParticle Declaration
+\*---------------------------------------------------------------------------*/
+
+class findCellParticle
+:
+    public particle
+{
+    // Private data
+
+        //- end point to track to
+        point end_;
+
+        //- passive data
+        label data_;
+
+
+public:
+
+    friend class Cloud<findCellParticle>;
+
+    //- Class used to pass tracking data to the trackToFace function
+    class trackingData
+    :
+        public particle::TrackingData<Cloud<findCellParticle> >
+    {
+        labelListList& cellToData_;
+        List<List<point> >& cellToEnd_;
+
+    public:
+
+        // Constructors
+
+            trackingData
+            (
+                Cloud<findCellParticle>& cloud,
+                labelListList& cellToData,
+                List<List<point> >& cellToEnd
+            )
+            :
+                particle::TrackingData<Cloud<findCellParticle> >(cloud),
+                cellToData_(cellToData),
+                cellToEnd_(cellToEnd)
+            {}
+
+
+        // Member functions
+
+            labelListList& cellToData()
+            {
+                return cellToData_;
+            }
+
+            List<List<point> >& cellToEnd()
+            {
+                return cellToEnd_;
+            }
+    };
+
+
+    // Constructors
+
+        //- Construct from components
+        findCellParticle
+        (
+            const polyMesh& mesh,
+            const vector& position,
+            const label cellI,
+            const label tetFaceI,
+            const label tetPtI,
+            const point& end,
+            const label data
+        );
+
+        //- Construct from Istream
+        findCellParticle
+        (
+            const polyMesh& mesh,
+            Istream& is,
+            bool readFields = true
+        );
+
+        //- Construct and return a clone
+        autoPtr<particle> clone() const
+        {
+            return autoPtr<particle>(new findCellParticle(*this));
+        }
+
+        //- Factory class to read-construct particles used for
+        //  parallel transfer
+        class iNew
+        {
+            const polyMesh& mesh_;
+
+        public:
+
+            iNew(const polyMesh& mesh)
+            :
+                mesh_(mesh)
+            {}
+
+            autoPtr<findCellParticle> operator()(Istream& is) const
+            {
+                return autoPtr<findCellParticle>
+                (
+                    new findCellParticle(mesh_, is, true)
+                );
+            }
+        };
+
+
+    // Member Functions
+
+        //- point to track to
+        const point& end() const
+        {
+            return end_;
+        }
+
+        //- transported label
+        label data() const
+        {
+            return data_;
+        }
+
+
+        // Tracking
+
+            //- Track all particles to their end point
+            bool move(trackingData&, const scalar);
+
+
+            //- Overridable function to handle the particle hitting a patch
+            //  Executed before other patch-hitting functions
+            bool hitPatch
+            (
+                const polyPatch&,
+                trackingData& td,
+                const label patchI,
+                const scalar trackFraction,
+                const tetIndices& tetIs
+            );
+
+            //- Overridable function to handle the particle hitting a wedge
+            void hitWedgePatch
+            (
+                const wedgePolyPatch&,
+                trackingData& td
+            );
+
+            //- Overridable function to handle the particle hitting a
+            //  symmetry plane
+            void hitSymmetryPlanePatch
+            (
+                const symmetryPlanePolyPatch&,
+                trackingData& td
+            );
+
+            //- Overridable function to handle the particle hitting a
+            //  symmetry patch
+            void hitSymmetryPatch
+            (
+                const symmetryPolyPatch&,
+                trackingData& td
+            );
+
+            //- Overridable function to handle the particle hitting a cyclic
+            void hitCyclicPatch
+            (
+                const cyclicPolyPatch&,
+                trackingData& td
+            );
+
+            //- Overridable function to handle the particle hitting a
+            //- processorPatch
+            void hitProcessorPatch
+            (
+                const processorPolyPatch&,
+                trackingData& td
+            );
+
+            //- Overridable function to handle the particle hitting a wallPatch
+            void hitWallPatch
+            (
+                const wallPolyPatch&,
+                trackingData& td,
+                const tetIndices&
+            );
+
+            //- Overridable function to handle the particle hitting a polyPatch
+            void hitPatch
+            (
+                const polyPatch&,
+                trackingData& td
+            );
+
+
+    // Ostream Operator
+
+        friend Ostream& operator<<(Ostream&, const findCellParticle&);
+};
+
+
+template<>
+inline bool contiguous<findCellParticle>()
+{
+    return true;
+}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/postProcessing/functionObjects/field/nearWallFields/findCellParticleCloud.C

@@ -0,0 +1,42 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "findCellParticle.H"
+#include "Cloud.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+defineTemplateTypeNameAndDebug(Cloud<findCellParticle>, 0);
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// ************************************************************************* //

src/postProcessing/functionObjects/field/nearWallFields/nearWallFields.C

@@ -0,0 +1,428 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2014 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "nearWallFields.H"
+#include "wordReList.H"
+#include "findCellParticle.H"
+#include "mappedPatchBase.H"
+#include "OBJstream.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(nearWallFields, 0);
+}
+
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+void Foam::nearWallFields::calcAddressing()
+{
+    const fvMesh& mesh = refCast<const fvMesh>(obr_);
+
+    // Count number of faces
+    label nPatchFaces = 0;
+    forAllConstIter(labelHashSet, patchSet_, iter)
+    {
+        label patchI = iter.key();
+        nPatchFaces += mesh.boundary()[patchI].size();
+    }
+
+    // Global indexing
+    globalIndex globalWalls(nPatchFaces);
+
+    if (debug)
+    {
+        Info<< "nearWallFields::calcAddressing() :"
+            << " nPatchFaces:" << globalWalls.size() << endl;
+    }
+
+    // Construct cloud
+    Cloud<findCellParticle> cloud(mesh, IDLList<findCellParticle>());
+
+    // Add particles to track to sample locations
+    nPatchFaces = 0;
+
+    forAllConstIter(labelHashSet, patchSet_, iter)
+    {
+        label patchI = iter.key();
+        const fvPatch& patch = mesh.boundary()[patchI];
+
+        vectorField nf(patch.nf());
+        vectorField faceCellCentres(patch.patch().faceCellCentres());
+
+        forAll(patch, patchFaceI)
+        {
+            label meshFaceI = patch.start()+patchFaceI;
+
+            // Find starting point on face (since faceCentre might not
+            // be on face-diagonal decomposition)
+            pointIndexHit startInfo
+            (
+                mappedPatchBase::facePoint
+                (
+                    mesh,
+                    meshFaceI,
+                    polyMesh::FACEDIAGTETS
+                )
+            );
+
+
+            point start;
+            if (startInfo.hit())
+            {
+                start = startInfo.hitPoint();
+            }
+            else
+            {
+                // Fallback: start tracking from neighbouring cell centre
+                start = faceCellCentres[patchFaceI];
+            }
+
+            const point end = start-distance_*nf[patchFaceI];
+
+            // Find tet for starting location
+            label cellI = -1;
+            label tetFaceI = -1;
+            label tetPtI = -1;
+            mesh.findCellFacePt(start, cellI, tetFaceI, tetPtI);
+
+            // Add to cloud. Add originating face as passive data
+            cloud.addParticle
+            (
+                new findCellParticle
+                (
+                    mesh,
+                    start,
+                    cellI,
+                    tetFaceI,
+                    tetPtI,
+                    end,
+                    globalWalls.toGlobal(nPatchFaces)    // passive data
+                )
+            );
+
+            nPatchFaces++;
+        }
+    }
+
+
+
+    if (debug)
+    {
+        // Dump particles
+        OBJstream str
+        (
+            mesh.time().path()
+           /"wantedTracks_" + mesh.time().timeName() + ".obj"
+        );
+        Info<< "nearWallFields::calcAddressing() :"
+            << "Dumping tracks to " << str.name() << endl;
+
+        forAllConstIter(Cloud<findCellParticle>, cloud, iter)
+        {
+            const findCellParticle& tp = iter();
+            str.write(linePointRef(tp.position(), tp.end()));
+        }
+    }
+
+
+
+    // Per cell: empty or global wall index and end location
+    cellToWalls_.setSize(mesh.nCells());
+    cellToSamples_.setSize(mesh.nCells());
+
+    // Database to pass into findCellParticle::move
+    findCellParticle::trackingData td(cloud, cellToWalls_, cellToSamples_);
+
+    // Track all particles to their end position.
+    scalar maxTrackLen = 2.0*mesh.bounds().mag();
+
+
+    //Debug: collect start points
+    pointField start;
+    if (debug)
+    {
+        start.setSize(nPatchFaces);
+        nPatchFaces = 0;
+        forAllConstIter(Cloud<findCellParticle>, cloud, iter)
+        {
+            const findCellParticle& tp = iter();
+            start[nPatchFaces++] = tp.position();
+        }
+    }
+
+
+    cloud.move(td, maxTrackLen);
+
+
+    // Rework cell-to-globalpatchface into a map
+    List<Map<label> > compactMap;
+    getPatchDataMapPtr_.reset
+    (
+        new mapDistribute
+        (
+            globalWalls,
+            cellToWalls_,
+            compactMap
+        )
+    );
+
+
+    // Debug: dump resulting tracks
+    if (debug)
+    {
+        getPatchDataMapPtr_().distribute(start);
+        {
+            OBJstream str
+            (
+                mesh.time().path()
+               /"obtainedTracks_" + mesh.time().timeName() + ".obj"
+            );
+            Info<< "nearWallFields::calcAddressing() :"
+                << "Dumping obtained to " << str.name() << endl;
+
+            forAll(cellToWalls_, cellI)
+            {
+                const List<point>& ends = cellToSamples_[cellI];
+                const labelList& cData = cellToWalls_[cellI];
+                forAll(cData, i)
+                {
+                    str.write(linePointRef(ends[i], start[cData[i]]));
+                }
+            }
+        }
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::nearWallFields::nearWallFields
+(
+    const word& name,
+    const objectRegistry& obr,
+    const dictionary& dict,
+    const bool loadFromFiles
+)
+:
+    name_(name),
+    obr_(obr),
+    active_(true),
+    fieldSet_()
+{
+    // Check if the available mesh is an fvMesh otherise deactivate
+    if (isA<fvMesh>(obr_))
+    {
+        read(dict);
+    }
+    else
+    {
+        active_ = false;
+        WarningIn
+        (
+            "nearWallFields::nearWallFields"
+            "("
+                "const word&, "
+                "const objectRegistry&, "
+                "const dictionary&, "
+                "const bool"
+            ")"
+        )   << "No fvMesh available, deactivating " << name_
+            << endl;
+    }
+
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::nearWallFields::~nearWallFields()
+{
+    if (debug)
+    {
+        Info<< "nearWallFields::~nearWallFields()" << endl;
+    }
+}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+void Foam::nearWallFields::read(const dictionary& dict)
+{
+    if (debug)
+    {
+        Info<< "nearWallFields::read(const dictionary&)" << endl;
+    }
+
+    if (active_)
+    {
+        const fvMesh& mesh = refCast<const fvMesh>(obr_);
+
+        dict.lookup("fields") >> fieldSet_;
+        patchSet_ =
+            mesh.boundaryMesh().patchSet(wordReList(dict.lookup("patches")));
+        distance_ = readScalar(dict.lookup("distance"));
+
+
+        // Clear out any previously loaded fields
+        vsf_.clear();
+        vvf_.clear();
+        vSpheretf_.clear();
+        vSymmtf_.clear();
+        vtf_.clear();
+        fieldMap_.clear();
+        reverseFieldMap_.clear();
+
+
+        // Generate fields with mappedField boundary condition
+
+        // Convert field to map
+        fieldMap_.resize(2*fieldSet_.size());
+        reverseFieldMap_.resize(2*fieldSet_.size());
+        forAll(fieldSet_, setI)
+        {
+            const word& fldName = fieldSet_[setI].first();
+            const word& sampleFldName = fieldSet_[setI].second();
+
+            fieldMap_.insert(fldName, sampleFldName);
+            reverseFieldMap_.insert(sampleFldName, fldName);
+        }
+
+        Info<< type() << " " << name_ << ": Sampling " << fieldMap_.size()
+            << " fields" << endl;
+
+        // Do analysis
+        calcAddressing();
+    }
+}
+
+
+void Foam::nearWallFields::execute()
+{
+    if (debug)
+    {
+        Info<< "nearWallFields:execute()" << endl;
+    }
+
+
+    if (active_)
+    {
+        if
+        (
+            fieldMap_.size()
+         && vsf_.empty()
+         && vvf_.empty()
+         && vSpheretf_.empty()
+         && vSymmtf_.empty()
+         && vtf_.empty()
+        )
+        {
+            Info<< type() << " " << name_ << ": Creating " << fieldMap_.size()
+                << " fields" << endl;
+
+            createFields(vsf_);
+            createFields(vvf_);
+            createFields(vSpheretf_);
+            createFields(vSymmtf_);
+            createFields(vtf_);
+
+            Info<< endl;
+        }
+
+        Info<< type() << " " << name_ << " output:" << nl;
+
+        Info<< "    Sampling fields to " << obr_.time().timeName()
+            << endl;
+
+        sampleFields(vsf_);
+        sampleFields(vvf_);
+        sampleFields(vSpheretf_);
+        sampleFields(vSymmtf_);
+        sampleFields(vtf_);
+    }
+}
+
+
+void Foam::nearWallFields::end()
+{
+    if (debug)
+    {
+        Info<< "nearWallFields:end()" << endl;
+    }
+
+    if (active_)
+    {
+        execute();
+    }
+}
+
+
+void Foam::nearWallFields::timeSet()
+{
+    // Do nothing
+}
+
+
+void Foam::nearWallFields::write()
+{
+    if (debug)
+    {
+        Info<< "nearWallFields:write()" << endl;
+    }
+
+    if (active_)
+    {
+        Info<< "    Writing sampled fields to " << obr_.time().timeName()
+            << endl;
+
+        forAll(vsf_, i)
+        {
+            vsf_[i].write();
+        }
+        forAll(vvf_, i)
+        {
+            vvf_[i].write();
+        }
+        forAll(vSpheretf_, i)
+        {
+            vSpheretf_[i].write();
+        }
+        forAll(vSymmtf_, i)
+        {
+            vSymmtf_[i].write();
+        }
+        forAll(vtf_, i)
+        {
+            vtf_[i].write();
+        }
+
+        Info<< endl;
+    }
+}
+
+
+// ************************************************************************* //

src/postProcessing/functionObjects/field/nearWallFields/nearWallFields.H

@@ -0,0 +1,252 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2013 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/>.
+
+Class
+    Foam::nearWallFields
+
+Group
+    grpFieldFunctionObjects
+
+Description
+    This function object samples near-patch volume fields
+
+    Fields are stored
+    - every time step the field is updated with new values
+    - at output it writes the fields
+
+    This functionObject can either be used
+    - to calculate a new field as a  post-processing step or
+    - since the fields are registered, used in another functionObject
+
+    Example of function object specification:
+    \verbatim
+    nearWallFields1
+    {
+        type        nearWallFields;
+        functionObjectLibs ("libfieldFunctionObjects.so");
+        ...
+        fields      ((p pNear)(U UNear));
+        patches     (movingWall);
+        distance    0.13;
+    }
+    \endverbatim
+
+    \heading Function object usage
+    \table
+        Property | Description               | Required    | Default value
+        type     | type name: nearWallFields | yes         |
+        fields   | list of fields with correspoding output field names | yes |
+        patches  | list of patches to sample | yes         |
+        distance | distance from patch to sample | yes     |
+    \endtable
+
+SeeAlso
+    Foam::functionObject
+    Foam::OutputFilterFunctionObject
+
+SourceFiles
+    nearWallFields.C
+    IOnearWallFields.H
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef nearWallFields_H
+#define nearWallFields_H
+
+#include "OFstream.H"
+#include "volFields.H"
+#include "Tuple2.H"
+#include "interpolationCellPoint.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// Forward declaration of classes
+class objectRegistry;
+class dictionary;
+class mapPolyMesh;
+
+/*---------------------------------------------------------------------------*\
+                       Class nearWallFields Declaration
+\*---------------------------------------------------------------------------*/
+
+class nearWallFields
+{
+protected:
+
+    // Protected data
+
+        //- Name of this set of nearWallFields object
+        word name_;
+
+        const objectRegistry& obr_;
+
+        //- on/off switch
+        bool active_;
+
+        // Read from dictionary
+
+            //- Fields to process
+            List<Tuple2<word, word> > fieldSet_;
+
+            //- Patches to sample
+            labelHashSet patchSet_;
+
+            //- Distance away from wall
+            scalar distance_;
+
+            //- From original field to sampled result
+            HashTable<word> fieldMap_;
+
+            //- From resulting back to original field
+            HashTable<word> reverseFieldMap_;
+
+
+        // Calculated addressing
+
+            //- From cell to seed patch faces
+            labelListList cellToWalls_;
+
+            //- From cell to tracked end point
+            List<List<point> > cellToSamples_;
+
+            //- Map from cell based data back to patch based data
+            autoPtr<mapDistribute> getPatchDataMapPtr_;
+
+
+        // Locally constructed fields
+
+            PtrList<volScalarField> vsf_;
+            PtrList<volVectorField> vvf_;
+            PtrList<volSphericalTensorField> vSpheretf_;
+            PtrList<volSymmTensorField> vSymmtf_;
+            PtrList<volTensorField> vtf_;
+
+
+    // Protected Member Functions
+
+        //- Calculate addressing from cells back to patch faces
+        void calcAddressing();
+
+        template<class Type>
+        void createFields
+        (
+            PtrList<GeometricField<Type, fvPatchField, volMesh> >&
+        ) const;
+
+        //- Override boundary fields with sampled values
+        template<class Type>
+        void sampleBoundaryField
+        (
+            const interpolationCellPoint<Type>& interpolator,
+            GeometricField<Type, fvPatchField, volMesh>& fld
+        ) const;
+
+        template<class Type>
+        void sampleFields
+        (
+            PtrList<GeometricField<Type, fvPatchField, volMesh> >&
+        ) const;
+
+
+private:
+
+        //- Disallow default bitwise copy construct
+        nearWallFields(const nearWallFields&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const nearWallFields&);
+
+public:
+
+    //- Runtime type information
+    TypeName("nearWallFields");
+
+
+    // Constructors
+
+        //- Construct for given objectRegistry and dictionary.
+        //  Allow the possibility to load fields from files
+        nearWallFields
+        (
+            const word& name,
+            const objectRegistry&,
+            const dictionary&,
+            const bool loadFromFiles = false
+        );
+
+
+    //- Destructor
+    virtual ~nearWallFields();
+
+
+    // Member Functions
+
+        //- Return name of the nearWallFields object
+        virtual const word& name() const
+        {
+            return name_;
+        }
+
+        //- Read the field min/max data
+        virtual void read(const dictionary&);
+
+        //- Execute, currently does nothing
+        virtual void execute();
+
+        //- Execute at the final time-loop, currently does nothing
+        virtual void end();
+
+        //- Called when time was set at the end of the Time::operator++
+        virtual void timeSet();
+
+        //- Write
+        virtual void write();
+
+        //- Update for changes of mesh
+        virtual void updateMesh(const mapPolyMesh&)
+        {}
+
+        //- Update for changes of mesh
+        virtual void movePoints(const polyMesh&)
+        {}
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+#   include "nearWallFieldsTemplates.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/postProcessing/functionObjects/field/nearWallFields/nearWallFieldsFunctionObject.C

@@ -0,0 +1,46 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "nearWallFieldsFunctionObject.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineNamedTemplateTypeNameAndDebug
+    (
+        nearWallFieldsFunctionObject,
+        0
+    );
+
+    addToRunTimeSelectionTable
+    (
+        functionObject,
+        nearWallFieldsFunctionObject,
+        dictionary
+    );
+}
+
+// ************************************************************************* //

src/postProcessing/functionObjects/field/nearWallFields/nearWallFieldsFunctionObject.H

@@ -0,0 +1,54 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 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/>.
+
+Typedef
+    Foam::nearWallFieldsFunctionObject
+
+Description
+    FunctionObject wrapper around nearWallFields to allow
+    them to be created via the functions entry within controlDict.
+
+SourceFiles
+    nearWallFieldsFunctionObject.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef nearWallFieldsFunctionObject_H
+#define nearWallFieldsFunctionObject_H
+
+#include "nearWallFields.H"
+#include "OutputFilterFunctionObject.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    typedef OutputFilterFunctionObject<nearWallFields>
+        nearWallFieldsFunctionObject;
+}
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/postProcessing/functionObjects/field/nearWallFields/nearWallFieldsTemplates.C

@@ -0,0 +1,146 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2013 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "nearWallFields.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+template<class Type>
+void Foam::nearWallFields::createFields
+(
+    PtrList<GeometricField<Type, fvPatchField, volMesh> >& sflds
+) const
+{
+    typedef GeometricField<Type, fvPatchField, volMesh> vfType;
+
+    HashTable<const vfType*> flds(obr_.lookupClass<vfType>());
+
+    forAllConstIter(typename HashTable<const vfType*>, flds, iter)
+    {
+        const vfType& fld = *iter();
+
+        if (fieldMap_.found(fld.name()))
+        {
+            const word& sampleFldName = fieldMap_[fld.name()];
+
+            if (obr_.found(sampleFldName))
+            {
+                Info<< "    a field " << sampleFldName
+                    << " already exists on the mesh."
+                    << endl;
+            }
+            else
+            {
+                label sz = sflds.size();
+                sflds.setSize(sz+1);
+
+                IOobject io(fld);
+                io.readOpt() = IOobject::NO_READ;
+                io.writeOpt() = IOobject::NO_WRITE;
+                io.rename(sampleFldName);
+
+                sflds.set(sz, new vfType(io, fld));
+
+                Info<< "    created " << sflds[sz].name() << " to sample "
+                    << fld.name() << endl;
+            }
+        }
+    }
+}
+
+
+template<class Type>
+void Foam::nearWallFields::sampleBoundaryField
+(
+    const interpolationCellPoint<Type>& interpolator,
+    GeometricField<Type, fvPatchField, volMesh>& fld
+) const
+{
+    // Construct flat fields for all patch faces to be sampled
+    Field<Type> sampledValues(getPatchDataMapPtr_().constructSize());
+
+    forAll(cellToWalls_, cellI)
+    {
+        const labelList& cData = cellToWalls_[cellI];
+
+        forAll(cData, i)
+        {
+            const point& samplePt = cellToSamples_[cellI][i];
+            sampledValues[cData[i]] = interpolator.interpolate(samplePt, cellI);
+        }
+    }
+
+    // Send back sampled values to patch faces
+    getPatchDataMapPtr_().reverseDistribute
+    (
+        getPatchDataMapPtr_().constructSize(),
+        sampledValues
+    );
+
+    // Pick up data
+    label nPatchFaces = 0;
+    forAllConstIter(labelHashSet, patchSet_, iter)
+    {
+        label patchI = iter.key();
+
+        fvPatchField<Type>& pfld = fld.boundaryField()[patchI];
+
+        Field<Type> newFld(pfld.size());
+        forAll(pfld, i)
+        {
+            newFld[i] = sampledValues[nPatchFaces++];
+        }
+
+        pfld == newFld;
+    }
+}
+
+
+template<class Type>
+void Foam::nearWallFields::sampleFields
+(
+    PtrList<GeometricField<Type, fvPatchField, volMesh> >& sflds
+) const
+{
+    typedef GeometricField<Type, fvPatchField, volMesh> vfType;
+
+    forAll(sflds, i)
+    {
+        const word& fldName = reverseFieldMap_[sflds[i].name()];
+        const vfType& fld = obr_.lookupObject<vfType>(fldName);
+
+        // Take over internal and boundary values
+        sflds[i] == fld;
+
+        // Construct interpolation method
+        interpolationCellPoint<Type> interpolator(fld);
+
+        // Override sampled values
+        sampleBoundaryField(interpolator, sflds[i]);
+    }
+}
+
+
+// ************************************************************************* //

src/postProcessing/functionObjects/field/processorField/IOprocessorField.H

@@ -0,0 +1,49 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 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/>.
+
+Typedef
+    Foam::IOprocessorField
+
+Description
+    Instance of the generic IOOutputFilter for processorField.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef IOprocessorField_H
+#define IOprocessorField_H
+
+#include "processorField.H"
+#include "IOOutputFilter.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    typedef IOOutputFilter<processorField> IOprocessorField;
+}
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //