moved field-related function objects to field subfolder

src/postProcessing/functionObjects/field/Make/files

+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/minMaxFields/IOminMaxFields.H → 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/minMaxFields/minMaxFields.C → 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,7 +169,7 @@ void Foam::minMaxFields::write()
 
 
 template<>
-void Foam::minMaxFields::calcMinMaxFields<Foam::scalar>
+void Foam::fieldMinMax::calcMinMaxFields<Foam::scalar>
 (
     const word& fieldName
 )
@@ -185,12 +185,12 @@ void Foam::minMaxFields::calcMinMaxFields<Foam::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/minMaxFields/minMaxFields.H → 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/minMaxFields/minMaxFieldsFunctionObject.C → 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/minMaxFields/minMaxFieldsFunctionObject.H → 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/minMaxFields/minMaxFieldsTemplates.C → 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

-fieldAverage/fieldAverage.C
-fieldAverageItem/fieldAverageItem.C
-fieldAverageItem/fieldAverageItemIO.C
-fieldAverageFunctionObject/fieldAverageFunctionObject.C
-
-LIB = $(FOAM_LIBBIN)/libfieldAverage

src/postProcessing/functionObjects/fieldAverage/Make/options

-EXE_INC = \
-    -I$(LIB_SRC)/finiteVolume/lnInclude \
-    -I$(LIB_SRC)/sampling/lnInclude
-
-LIB_LIBS = \
-    -lfiniteVolume \
-    -lsampling