Merge commit 'OpenCFD/master' into olesenm

src/postProcessing/functionObjects/Allwmake

@@ -2,9 +2,9 @@
 cd ${0%/*} || exit 1    # run from this directory
 set -x
 
-wmake libso fieldAverage
+wmake libso field
 wmake libso forces
-wmake libso minMaxFields
+wmake libso utilities
 wmake libso systemCall
 
 # ----------------------------------------------------------------- end-of-file

src/postProcessing/functionObjects/field/Make/files

@@ -0,0 +1,9 @@
+fieldAverage/fieldAverage/fieldAverage.C
+fieldAverage/fieldAverageItem/fieldAverageItem.C
+fieldAverage/fieldAverageItem/fieldAverageItemIO.C
+fieldAverage/fieldAverageFunctionObject/fieldAverageFunctionObject.C
+
+fieldMinMax/fieldMinMax.C
+fieldMinMax/fieldMinMaxFunctionObject.C
+
+LIB = $(FOAM_LIBBIN)/libfieldFunctionObjects

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

@@ -170,6 +170,7 @@ Foam::fieldAverage::fieldAverage
     name_(name),
     obr_(obr),
     active_(true),
+    cleanRestart_(dict.lookupOrDefault<Switch>("cleanRestart", false)),
     faItems_(dict.lookup("fields")),
     meanScalarFields_(faItems_.size()),
     meanVectorFields_(faItems_.size()),
@@ -326,29 +327,44 @@ void Foam::fieldAverage::writeAveragingProperties() const
 
 void Foam::fieldAverage::readAveragingProperties()
 {
-    IFstream propsFile
-    (
-        obr_.time().path()/obr_.time().timeName()
-       /"uniform"/"fieldAveragingProperties"
-    );
-
-    if (!propsFile.good())
+    if (cleanRestart_)
     {
-        return;
+        Info<< "fieldAverage: starting averaging at time "
+            << obr_.time().timeName() << nl << endl;
     }
-
-    dictionary propsDict(dictionary::null, propsFile);
-
-    forAll(faItems_, i)
+    else
     {
-        const word& fieldName = faItems_[i].fieldName();
-        if (propsDict.found(fieldName))
-        {
-            dictionary fieldDict(propsDict.subDict(fieldName));
+        IFstream propsFile
+        (
+            obr_.time().path()/obr_.time().timeName()
+            /"uniform"/"fieldAveragingProperties"
+        );
 
-            totalIter_[i] = readLabel(fieldDict.lookup("totalIter"));
-            totalTime_[i] = readScalar(fieldDict.lookup("totalTime"));
+        if (!propsFile.good())
+        {
+            Info<< "fieldAverage: starting averaging at time "
+                << obr_.time().timeName() << nl << endl;
+            return;
         }
+
+        dictionary propsDict(dictionary::null, propsFile);
+
+        Info<< "fieldAverage: restarting averaging for fields:" << endl;
+        forAll(faItems_, i)
+        {
+            const word& fieldName = faItems_[i].fieldName();
+            if (propsDict.found(fieldName))
+            {
+                dictionary fieldDict(propsDict.subDict(fieldName));
+
+                totalIter_[i] = readLabel(fieldDict.lookup("totalIter"));
+                totalTime_[i] = readScalar(fieldDict.lookup("totalTime"));
+                Info<< "    " << fieldName
+                    << " iters = " << totalIter_[i]
+                    << " time = " << totalTime_[i] << endl;
+            }
+        }
+        Info<< endl;
     }
 }
 

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

@@ -37,6 +37,10 @@ Description
         // Where to load it from (if not already in solver)
         functionObjectLibs ("libfieldAverage.so");
 
+        // Whether to perform a clean restart, or start from previous
+        // averaging info if available
+        cleanRestart true;
+
         // Fields to be probed. runTime modifiable!
         fields
         (
@@ -80,6 +84,7 @@ SourceFiles
 
 #include "volFieldsFwd.H"
 #include "pointFieldFwd.H"
+#include "Switch.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -114,6 +119,9 @@ protected:
         //- On/off switch
         bool active_;
 
+        //- Clean restart flag
+        Switch cleanRestart_;
+
         //- List of field average items, describing waht averages to be
         //  calculated and output
         List<fieldAverageItem> faItems_;

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

@@ -23,24 +23,24 @@ License
     Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 
 Typedef
-    Foam::IOminMaxFields
+    Foam::IOfieldMinMax
 
 Description
-    Instance of the generic IOOutputFilter for minMaxFields.
+    Instance of the generic IOOutputFilter for fieldMinMax.
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef IOminMaxFields_H
-#define IOminMaxFields_H
+#ifndef IOfieldMinMax_H
+#define IOfieldMinMax_H
 
-#include "minMaxFields.H"
+#include "fieldMinMax.H"
 #include "IOOutputFilter.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 namespace Foam
 {
-    typedef IOOutputFilter<minMaxFields> IOminMaxFields;
+    typedef IOOutputFilter<fieldMinMax> IOfieldMinMax;
 }
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

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

@@ -24,7 +24,7 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-#include "minMaxFields.H"
+#include "fieldMinMax.H"
 #include "volFields.H"
 #include "dictionary.H"
 #include "Time.H"
@@ -34,13 +34,13 @@ License
 
 namespace Foam
 {
-    defineTypeNameAndDebug(minMaxFields, 0);
+    defineTypeNameAndDebug(fieldMinMax, 0);
 }
 
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
-Foam::minMaxFields::minMaxFields
+Foam::fieldMinMax::fieldMinMax
 (
     const word& name,
     const objectRegistry& obr,
@@ -53,7 +53,7 @@ Foam::minMaxFields::minMaxFields
     active_(true),
     log_(false),
     fieldSet_(),
-    minMaxFieldsFilePtr_(NULL)
+    fieldMinMaxFilePtr_(NULL)
 {
     // Check if the available mesh is an fvMesh otherise deactivate
     if (!isA<fvMesh>(obr_))
@@ -61,7 +61,7 @@ Foam::minMaxFields::minMaxFields
         active_ = false;
         WarningIn
         (
-            "minMaxFields::minMaxFields"
+            "fieldMinMax::fieldMinMax"
             "(const objectRegistry& obr, const dictionary& dict)"
         )   << "No fvMesh available, deactivating."
             << endl;
@@ -73,13 +73,13 @@ Foam::minMaxFields::minMaxFields
 
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 
-Foam::minMaxFields::~minMaxFields()
+Foam::fieldMinMax::~fieldMinMax()
 {}
 
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
-void Foam::minMaxFields::read(const dictionary& dict)
+void Foam::fieldMinMax::read(const dictionary& dict)
 {
     if (active_)
     {
@@ -90,40 +90,40 @@ void Foam::minMaxFields::read(const dictionary& dict)
 }
 
 
-void Foam::minMaxFields::makeFile()
+void Foam::fieldMinMax::makeFile()
 {
-    // Create the minMaxFields file if not already created
-    if (minMaxFieldsFilePtr_.empty())
+    // Create the fieldMinMax file if not already created
+    if (fieldMinMaxFilePtr_.empty())
     {
         if (debug)
         {
-            Info<< "Creating minMaxFields file." << endl;
+            Info<< "Creating fieldMinMax file." << endl;
         }
 
         // File update
         if (Pstream::master())
         {
-            fileName minMaxFieldsDir;
+            fileName fieldMinMaxDir;
             if (Pstream::parRun())
             {
                 // Put in undecomposed case (Note: gives problems for
                 // distributed data running)
-                minMaxFieldsDir =
+                fieldMinMaxDir =
                     obr_.time().path()/".."/name_/obr_.time().timeName();
             }
             else
             {
-                minMaxFieldsDir =
+                fieldMinMaxDir =
                     obr_.time().path()/name_/obr_.time().timeName();
             }
 
             // Create directory if does not exist.
-            mkDir(minMaxFieldsDir);
+            mkDir(fieldMinMaxDir);
 
             // Open new file at start up
-            minMaxFieldsFilePtr_.reset
+            fieldMinMaxFilePtr_.reset
             (
-                new OFstream(minMaxFieldsDir/(type() + ".dat"))
+                new OFstream(fieldMinMaxDir/(type() + ".dat"))
             );
 
             // Add headers to output data
@@ -133,27 +133,27 @@ void Foam::minMaxFields::makeFile()
 }
 
 
-void Foam::minMaxFields::writeFileHeader()
+void Foam::fieldMinMax::writeFileHeader()
 {
-    if (minMaxFieldsFilePtr_.valid())
+    if (fieldMinMaxFilePtr_.valid())
     {
-        minMaxFieldsFilePtr_()
+        fieldMinMaxFilePtr_()
             << "# Time" << tab << "field" << tab << "min" << tab << "max"
             << endl;
     }
 }
 
 
-void Foam::minMaxFields::execute()
+void Foam::fieldMinMax::execute()
 {
     // Do nothing - only valid on write
 }
 
-void Foam::minMaxFields::write()
+void Foam::fieldMinMax::write()
 {
     if (active_)
     {
-        // Create the minMaxFields file if not already created
+        // Create the fieldMinMax file if not already created
         makeFile();
 
         forAll(fieldSet_, fieldI)
@@ -169,28 +169,29 @@ void Foam::minMaxFields::write()
 
 
 template<>
-void Foam::minMaxFields::calcMinMaxFields<Foam::scalar>
+void Foam::fieldMinMax::calcMinMaxFields<Foam::scalar>
 (
     const word& fieldName
 )
 {
     if (obr_.foundObject<volScalarField>(fieldName))
     {
-        const scalarField& field = obr_.lookupObject<scalarField>(fieldName);
-        scalar minValue = min(field);
-        scalar maxValue = max(field);
+        const volScalarField& field =
+            obr_.lookupObject<volScalarField>(fieldName);
+        scalar minValue = min(field).value();
+        scalar maxValue = max(field).value();
 
         reduce(minValue, minOp<scalar>());
         reduce(maxValue, maxOp<scalar>());
 
         if (Pstream::master())
         {
-            minMaxFieldsFilePtr_() << obr_.time().value() << tab
+            fieldMinMaxFilePtr_() << obr_.time().value() << tab
                 << fieldName << tab << minValue << tab << maxValue << endl;
 
             if (log_)
             {
-                Info<< "minMaxFields output:" << nl
+                Info<< "fieldMinMax output:" << nl
                     << "    min(" << fieldName << ") = " << minValue << nl
                     << "    max(" << fieldName << ") = " << maxValue << nl
                     << endl;

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

@@ -23,7 +23,7 @@ License
     Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 
 Class
-    Foam::minMaxFields
+    Foam::fieldMinMax
 
 Description
     Calculates scalar minimim and maximum field values.
@@ -31,17 +31,17 @@ Description
     For variables with rank > 0, computes the magnitude of the min/max
     values.
 
-    Data written to the file \<timeDir\>/minMaxFields.dat
+    Data written to the file \<timeDir\>/fieldMinMax.dat
 
 
 SourceFiles
-    minMaxFields.C
-    IOminMaxFields.H
+    fieldMinMax.C
+    IOfieldMinMax.H
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef minMaxFields_H
-#define minMaxFields_H
+#ifndef fieldMinMax_H
+#define fieldMinMax_H
 
 #include "primitiveFieldsFwd.H"
 #include "volFieldsFwd.H"
@@ -61,10 +61,10 @@ class dictionary;
 class mapPolyMesh;
 
 /*---------------------------------------------------------------------------*\
-                       Class minMaxFields Declaration
+                       Class fieldMinMax Declaration
 \*---------------------------------------------------------------------------*/
 
-class minMaxFields
+class fieldMinMax
 {
 protected:
 
@@ -87,7 +87,7 @@ protected:
 
 
         //- Forces/moment file ptr
-        autoPtr<OFstream> minMaxFieldsFilePtr_;
+        autoPtr<OFstream> fieldMinMaxFilePtr_;
 
 
     // Private Member Functions
@@ -96,10 +96,10 @@ protected:
         void makeFile();
 
         //- Disallow default bitwise copy construct
-        minMaxFields(const minMaxFields&);
+        fieldMinMax(const fieldMinMax&);
 
         //- Disallow default bitwise assignment
-        void operator=(const minMaxFields&);
+        void operator=(const fieldMinMax&);
 
         //- Output file header information
         virtual void writeFileHeader();
@@ -108,14 +108,14 @@ protected:
 public:
 
     //- Runtime type information
-    TypeName("minMaxFields");
+    TypeName("fieldMinMax");
 
 
     // Constructors
 
         //- Construct for given objectRegistry and dictionary.
         //  Allow the possibility to load fields from files
-        minMaxFields
+        fieldMinMax
         (
             const word& name,
             const objectRegistry&,
@@ -126,7 +126,7 @@ public:
 
     // Destructor
 
-        virtual ~minMaxFields();
+        virtual ~fieldMinMax();
 
 
     // Member Functions
@@ -147,7 +147,7 @@ public:
         template<class Type>
         void calcMinMaxFields(const word& fieldName);
 
-        //- Write the minMaxFields
+        //- Write the fieldMinMax
         virtual void write();
 
         //- Update for changes of mesh
@@ -162,7 +162,7 @@ public:
 
 // Template specialisation for scalar fields
 template<>
-void minMaxFields::calcMinMaxFields<scalar>(const word& fieldName);
+void fieldMinMax::calcMinMaxFields<scalar>(const word& fieldName);
 
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@@ -172,7 +172,7 @@ void minMaxFields::calcMinMaxFields<scalar>(const word& fieldName);
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 #ifdef NoRepository
-#   include "minMaxFieldsTemplates.C"
+#   include "fieldMinMaxTemplates.C"
 #endif
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

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

@@ -24,18 +24,18 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-#include "minMaxFieldsFunctionObject.H"
+#include "fieldMinMaxFunctionObject.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
 namespace Foam
 {
-    defineNamedTemplateTypeNameAndDebug(minMaxFieldsFunctionObject, 0);
+    defineNamedTemplateTypeNameAndDebug(fieldMinMaxFunctionObject, 0);
 
     addToRunTimeSelectionTable
     (
         functionObject,
-        minMaxFieldsFunctionObject,
+        fieldMinMaxFunctionObject,
         dictionary
     );
 }

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

@@ -23,29 +23,29 @@ License
     Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 
 Typedef
-    Foam::minMaxFieldsFunctionObject
+    Foam::fieldMinMaxFunctionObject
 
 Description
-    FunctionObject wrapper around minMaxFields to allow them to be created via
+    FunctionObject wrapper around fieldMinMax to allow them to be created via
     the functions list within controlDict.
 
 SourceFiles
-    minMaxFieldsFunctionObject.C
+    fieldMinMaxFunctionObject.C
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef minMaxFieldsFunctionObject_H
-#define minMaxFieldsFunctionObject_H
+#ifndef fieldMinMaxFunctionObject_H
+#define fieldMinMaxFunctionObject_H
 
-#include "minMaxFields.H"
+#include "fieldMinMax.H"
 #include "OutputFilterFunctionObject.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 namespace Foam
 {
-    typedef OutputFilterFunctionObject<minMaxFields>
-        minMaxFieldsFunctionObject;
+    typedef OutputFilterFunctionObject<fieldMinMax>
+        fieldMinMaxFunctionObject;
 }
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

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

@@ -24,7 +24,7 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-#include "minMaxFields.H"
+#include "fieldMinMax.H"
 #include "volFields.H"
 #include "dictionary.H"
 #include "Time.H"
@@ -32,7 +32,7 @@ License
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 template<class Type>
-void Foam::minMaxFields::calcMinMaxFields(const word& fieldName)
+void Foam::fieldMinMax::calcMinMaxFields(const word& fieldName)
 {
     typedef GeometricField<Type, fvPatchField, volMesh> fieldType;
 
@@ -47,12 +47,12 @@ void Foam::minMaxFields::calcMinMaxFields(const word& fieldName)
 
         if (Pstream::master())
         {
-            minMaxFieldsFilePtr_() << obr_.time().value() << tab
+            fieldMinMaxFilePtr_() << obr_.time().value() << tab
                 << fieldName << tab << minValue << tab << maxValue << endl;
 
             if (log_)
             {
-                Info<< "minMaxFields output:" << nl
+                Info<< "fieldMinMax output:" << nl
                     << "    min(mag(" << fieldName << ")) = " << minValue << nl
                     << "    max(mag(" << fieldName << ")) = " << maxValue << nl
                     << endl;

src/postProcessing/functionObjects/fieldAverage/Make/files

@@ -1,6 +0,0 @@
-fieldAverage/fieldAverage.C
-fieldAverageItem/fieldAverageItem.C
-fieldAverageItem/fieldAverageItemIO.C
-fieldAverageFunctionObject/fieldAverageFunctionObject.C
-
-LIB = $(FOAM_LIBBIN)/libfieldAverage

src/postProcessing/functionObjects/minMaxFields/Make/files

@@ -1,4 +0,0 @@
-minMaxFields.C
-minMaxFieldsFunctionObject.C
-
-LIB = $(FOAM_LIBBIN)/libminMaxFields

src/postProcessing/functionObjects/utilities/Make/files

@@ -0,0 +1,4 @@
+dynamicPressure/dynamicPressure.C
+dynamicPressure/dynamicPressureFunctionObject.C
+
+LIB = $(FOAM_LIBBIN)/libutilityFunctionObjects

src/postProcessing/functionObjects/utilities/Make/options

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

src/postProcessing/functionObjects/utilities/dynamicPressure/IOdynamicPressure.H

@@ -0,0 +1,50 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2009 OpenCFD Ltd.
+     \\/     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 2 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, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Typedef
+    Foam::IOdynamicPressure
+
+Description
+    Instance of the generic IOOutputFilter for dynamicPressure.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef IOdynamicPressure_H
+#define IOdynamicPressure_H
+
+#include "dynamicPressure.H"
+#include "IOOutputFilter.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    typedef IOOutputFilter<dynamicPressure> IOdynamicPressure;
+}
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/postProcessing/functionObjects/utilities/dynamicPressure/dynamicPressure.C

@@ -0,0 +1,141 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2009 OpenCFD Ltd.
+     \\/     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 2 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, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+\*---------------------------------------------------------------------------*/
+
+#include "dynamicPressure.H"
+#include "volFields.H"
+#include "dictionary.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(dynamicPressure, 0);
+}
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+bool Foam::dynamicPressure::isKinematicPressure()
+{
+    const volScalarField& p = obr_.lookupObject<volScalarField>(pName_);
+
+    return p.dimensions() == sqr(dimLength)/sqr(dimTime);
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::dynamicPressure::dynamicPressure
+(
+    const word& name,
+    const objectRegistry& obr,
+    const dictionary& dict,
+    const bool loadFromFiles
+)
+:
+    name_(name),
+    obr_(obr),
+    active_(true),
+    pName_(dict.lookup("p")),
+    rho_(readScalar(dict.lookup("rho")))
+{
+    // Check if the available mesh is an fvMesh, otherwise deactivate
+    if (!isA<fvMesh>(obr_))
+    {
+        active_ = false;
+        WarningIn
+        (
+            "dynamicPressure::dynamicPressure"
+            "(const objectRegistry& obr, const dictionary& dict)"
+        )   << "No fvMesh available, deactivating." << nl
+            << endl;
+    }
+    else
+    {
+        // Check if the pressure is kinematic pressure, otherwise deactivate
+        if (!isKinematicPressure())
+        {
+            active_ = false;
+            WarningIn
+            (
+                "dynamicPressure::dynamicPressure"
+                "(const objectRegistry& obr, const dictionary& dict)"
+            )   << "Pressure is not kinematic pressure, deactivating." << nl
+                << endl;
+        }
+    }
+
+    read(dict);
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::dynamicPressure::~dynamicPressure()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+void Foam::dynamicPressure::read(const dictionary& dict)
+{
+    if (active_)
+    {
+        dict.lookup("p") >> pName_;
+        dict.lookup("rho") >> rho_;
+    }
+}
+
+
+void Foam::dynamicPressure::execute()
+{
+    // Do nothing - only valid on write
+}
+
+
+void Foam::dynamicPressure::write()
+{
+    if (active_)
+    {
+        const volScalarField& p = obr_.lookupObject<volScalarField>(pName_);
+
+        volScalarField pDyn
+        (
+            IOobject
+            (
+                "pDyn",
+                obr_.time().timeName(),
+                obr_,
+                IOobject::NO_READ
+            ),
+            dimensionedScalar("rho", dimDensity, rho_)*p
+        );
+
+        pDyn.write();
+    }
+}
+
+
+// ************************************************************************* //

src/postProcessing/functionObjects/utilities/dynamicPressure/dynamicPressure.H

@@ -0,0 +1,147 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2009 OpenCFD Ltd.
+     \\/     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 2 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, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Class
+    Foam::dynamicPressure
+
+Description
+    Converts kinematic pressure to dynamic pressure, from the name of the
+    pressure field, and density.
+
+SourceFiles
+    dynamicPressure.C
+    IOdynamicPressure.H
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef dynamicPressure_H
+#define dynamicPressure_H
+
+#include "pointFieldFwd.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// Forward declaration of classes
+class objectRegistry;
+class dictionary;
+class mapPolyMesh;
+
+/*---------------------------------------------------------------------------*\
+                           Class dynamicPressure Declaration
+\*---------------------------------------------------------------------------*/
+
+class dynamicPressure
+{
+    // Private data
+
+        //- Name of this set of dynamicPressure objects
+        word name_;
+
+        const objectRegistry& obr_;
+
+        //- on/off switch
+        bool active_;
+
+        //- Name of pressure field
+        word pName_;
+
+        //- Density
+        scalar rho_;
+
+
+    // Private Member Functions
+
+        //- Return true if the pressure field corresponds to kinematic pressure
+        bool isKinematicPressure();
+
+        //- Disallow default bitwise copy construct
+        dynamicPressure(const dynamicPressure&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const dynamicPressure&);
+
+
+public:
+
+    //- Runtime type information
+    TypeName("dynamicPressure");
+
+
+    // Constructors
+
+        //- Construct for given objectRegistry and dictionary.
+        //  Allow the possibility to load fields from files
+        dynamicPressure
+        (
+            const word& name,
+            const objectRegistry&,
+            const dictionary&,
+            const bool loadFromFiles = false
+        );
+
+
+    // Destructor
+
+        virtual ~dynamicPressure();
+
+
+    // Member Functions
+
+        //- Return name of the set of dynamicPressure
+        virtual const word& name() const
+        {
+            return name_;
+        }
+
+        //- Read the dynamicPressure data
+        virtual void read(const dictionary&);
+
+        //- Execute
+        virtual void execute();
+
+        //- Calculate the dynamicPressure and write
+        virtual void write();
+
+        //- Update for changes of mesh
+        virtual void updateMesh(const mapPolyMesh&)
+        {}
+
+        //- Update for changes of mesh
+        virtual void movePoints(const pointField&)
+        {}
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/postProcessing/functionObjects/utilities/dynamicPressure/dynamicPressureFunctionObject.C

@@ -0,0 +1,43 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2009 OpenCFD Ltd.
+     \\/     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 2 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, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+\*---------------------------------------------------------------------------*/
+
+#include "dynamicPressureFunctionObject.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineNamedTemplateTypeNameAndDebug(dynamicPressureFunctionObject, 0);
+
+    addToRunTimeSelectionTable
+    (
+        functionObject,
+        dynamicPressureFunctionObject,
+        dictionary
+    );
+}
+
+// ************************************************************************* //

src/postProcessing/functionObjects/utilities/dynamicPressure/dynamicPressureFunctionObject.H

@@ -0,0 +1,55 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2009 OpenCFD Ltd.
+     \\/     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 2 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, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Typedef
+    Foam::dynamicPressureFunctionObject
+
+Description
+    FunctionObject wrapper around dynamicPressure to allow it to be created via
+    the functions list within controlDict.
+
+SourceFiles
+    dynamicPressureFunctionObject.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef dynamicPressureFunctionObject_H
+#define dynamicPressureFunctionObject_H
+
+#include "dynamicPressure.H"
+#include "OutputFilterFunctionObject.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    typedef OutputFilterFunctionObject<dynamicPressure>
+        dynamicPressureFunctionObject;
+}
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //