Updates to the fieldValues function object

- Updates to enable correct operation in parallel
- Added weighted average operation for cell sources

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

@@ -46,10 +46,13 @@ namespace Foam
         fieldValues::cellSource::sourceTypeNames_;
 
     template<>
-    const char* NamedEnum<fieldValues::cellSource::operationType, 4>::
-        names[] = {"none", "sum", "volAverage", "volIntegrate"};
+    const char* NamedEnum<fieldValues::cellSource::operationType, 5>::
+        names[] =
+        {
+            "none", "sum", "volAverage", "volIntegrate", "weightedAverage"
+        };
 
-    const NamedEnum<fieldValues::cellSource::operationType, 4>
+    const NamedEnum<fieldValues::cellSource::operationType, 5>
         fieldValues::cellSource::operationTypeNames_;
 
 }
@@ -93,7 +96,7 @@ void Foam::fieldValues::cellSource::setCellZoneCells()
 
 // * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
 
-void Foam::fieldValues::cellSource::initialise()
+void Foam::fieldValues::cellSource::initialise(const dictionary& dict)
 {
     switch (source_)
     {
@@ -104,7 +107,7 @@ void Foam::fieldValues::cellSource::initialise()
         }
         default:
         {
-            FatalErrorIn("cellSource::constructCellAddressing()")
+            FatalErrorIn("cellSource::initialise()")
                 << "Unknown source type. Valid source types are:"
                 << sourceTypeNames_ << nl << exit(FatalError);
         }
@@ -114,6 +117,29 @@ void Foam::fieldValues::cellSource::initialise()
         << "    total cells  = " << cellId_.size() << nl
         << "    total volume = " << sum(filterField(mesh().V()))
         << nl << endl;
+
+    if (operation_ == opWeightedAverage)
+    {
+        dict.lookup("weightField") >> weightFieldName_;
+        if
+        (
+            obr().foundObject<volScalarField>(weightFieldName_)
+        )
+        {
+            Info<< "    weight field = " << weightFieldName_;
+        }
+        else
+        {
+            FatalErrorIn("cellSource::initialise()")
+                << type() << " " << name_ << ": "
+                << sourceTypeNames_[source_] << "(" << sourceName_ << "):"
+                << nl << "    Weight field " << weightFieldName_
+                << " must be a " << volScalarField::typeName
+                << nl << exit(FatalError);
+        }
+    }
+
+    Info<< nl << endl;
 }
 
 
@@ -172,7 +198,7 @@ void Foam::fieldValues::cellSource::read(const dictionary& dict)
     if (active_)
     {
         // no additional info to read
-        initialise();
+        initialise(dict);
     }
 }
 
@@ -183,9 +209,12 @@ void Foam::fieldValues::cellSource::write()
 
     if (active_)
     {
-        outputFilePtr_()
-            << obr_.time().value() << tab
-            << sum(filterField(mesh().V()));
+        if (Pstream::master())
+        {
+            outputFilePtr_()
+                << obr_.time().value() << tab
+                << sum(filterField(mesh().V()));
+        }
 
         forAll(fields_, i)
         {
@@ -196,7 +225,10 @@ void Foam::fieldValues::cellSource::write()
             writeValues<tensor>(fields_[i]);
         }
 
-        outputFilePtr_()<< endl;
+        if (Pstream::master())
+        {
+            outputFilePtr_()<< endl;
+        }
 
         if (log_)
         {

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

@@ -39,7 +39,7 @@ Description
         valueOutput     true;       // Write values at run-time output times?
         source          cellZone;   // Type of cell source
         sourceName      c0;
-        operation       volAverage; // none, sum, volAverage, volIntegrate
+        operation       volAverage;
         fields
         (
             p
@@ -47,6 +47,13 @@ Description
         );
     }
 
+    where operation is one of:
+      - none
+      - sum
+      - volAverage
+      - volIntegrate
+      - weightedAverage
+
 SourceFiles
     cellSource.C
 
@@ -96,11 +103,12 @@ public:
             opNone,
             opSum,
             opVolAverage,
-            opVolIntegrate
+            opVolIntegrate,
+            opWeightedAverage
         };
 
         //- Operation type names
-        static const NamedEnum<operationType, 4> operationTypeNames_;
+        static const NamedEnum<operationType, 5> operationTypeNames_;
 
 
 private:
@@ -127,23 +135,34 @@ protected:
         //- 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();
+        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>
-        bool setFieldValues
+        tmp<Field<Type> > setFieldValues
         (
-            const word& fieldName,
-            List<Type>& values
+            const word& fieldName
         ) const;
 
         //- Apply the 'operation' to the values
         template<class Type>
-        Type processValues(const List<Type>& values) const;
+        Type processValues
+        (
+            const Field<Type>& values,
+            const scalarField& V,
+            const scalarField& weightField
+        ) const;
 
         //- Output file header information
         virtual void writeFileHeader();

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

@@ -27,27 +27,16 @@ License
 #include "cellSource.H"
 #include "volFields.H"
 #include "IOList.H"
-#include "ListListOps.H"
 
 // * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
 
 template<class Type>
-bool Foam::fieldValues::cellSource::setFieldValues
-(
-    const word& fieldName,
-    List<Type>& values
-) const
+bool Foam::fieldValues::cellSource::validField(const word& fieldName) const
 {
-    values.setSize(cellId_.size(), pTraits<Type>::zero);
-
     typedef GeometricField<Type, fvPatchField, volMesh> vf;
 
     if (obr_.foundObject<vf>(fieldName))
     {
-        const vf& field = obr_.lookupObject<vf>(fieldName);
-
-        values = UIndirectList<Type>(field, cellId_);
-
         return true;
     }
 
@@ -55,10 +44,29 @@ bool Foam::fieldValues::cellSource::setFieldValues
 }
 
 
+template<class Type>
+Foam::tmp<Foam::Field<Type> > Foam::fieldValues::cellSource::setFieldValues
+(
+    const word& fieldName
+) const
+{
+    typedef GeometricField<Type, fvPatchField, volMesh> vf;
+
+    if (obr_.foundObject<vf>(fieldName))
+    {
+        return filterField(obr_.lookupObject<vf>(fieldName));
+    }
+
+    return tmp<Field<Type> >(new Field<Type>(0.0));
+}
+
+
 template<class Type>
 Type Foam::fieldValues::cellSource::processValues
 (
-    const List<Type>& values
+    const Field<Type>& values,
+    const scalarField& V,
+    const scalarField& weightField
 ) const
 {
     Type result = pTraits<Type>::zero;
@@ -71,13 +79,17 @@ Type Foam::fieldValues::cellSource::processValues
         }
         case opVolAverage:
         {
-            tmp<scalarField> V = filterField(mesh().V());
-            result = sum(values*V())/sum(V());
+            result = sum(values*V)/sum(V);
             break;
         }
         case opVolIntegrate:
         {
-            result = sum(values*filterField(mesh().V()));
+            result = sum(values*V);
+            break;
+        }
+        case opWeightedAverage:
+        {
+            result = sum(values*weightField)/sum(weightField);
             break;
         }
         default:
@@ -95,25 +107,20 @@ Type Foam::fieldValues::cellSource::processValues
 template<class Type>
 bool Foam::fieldValues::cellSource::writeValues(const word& fieldName)
 {
-    List<List<Type> > allValues(Pstream::nProcs());
+    const bool ok = validField<Type>(fieldName);
 
-    bool validField =
-        setFieldValues<Type>(fieldName, allValues[Pstream::myProcNo()]);
-
-    if (validField)
+    if (ok)
     {
-        Pstream::gatherList(allValues);
+        Field<Type> values = combineFields(setFieldValues<Type>(fieldName));
+
+        scalarField V = combineFields(filterField(mesh().V()));
+
+        scalarField weightField =
+            combineFields(setFieldValues<scalar>(weightFieldName_));
 
         if (Pstream::master())
         {
-            List<Type> values =
-                ListListOps::combine<List<Type> >
-                (
-                    allValues,
-                    accessOp<List<Type> >()
-                );
-
-            Type result = processValues(values);
+            Type result = processValues(values, V, weightField);
 
             if (valueOutput_)
             {
@@ -144,7 +151,7 @@ bool Foam::fieldValues::cellSource::writeValues(const word& fieldName)
         }
     }
 
-    return validField;
+    return ok;
 }