functionObjects::add: Add list of fields

    The operation can be applied to any volume or surface fields generating a
    volume or surface scalar field.

    Example of function object specification:
    \verbatim
    Ttot
    {
        type            add;
        libs            ("libfieldFunctionObjects.so");
        fields          (T Tdelta);
        result          Ttot;
        executeControl  writeTime;
        writeControl    writeTime;
    }
    \endverbatim

Also refactored functionObjects::fieldsExpression to avoid code
duplication between the 'add' and 'subtract' functionObjects.

src/functionObjects/field/Make/files

@@ -62,6 +62,7 @@ XiReactionRate/XiReactionRate.C
 streamFunction/streamFunction.C
 
 fieldsExpression/fieldsExpression.C
+add/add.C
 subtract/subtract.C
 
 LIB = $(FOAM_LIBBIN)/libfieldFunctionObjects

src/functionObjects/field/add/add.C

+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2016 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "add.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace functionObjects
+{
+    defineTypeNameAndDebug(add, 0);
+    addToRunTimeSelectionTable(functionObject, add, dictionary);
+}
+}
+
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+bool Foam::functionObjects::add::calc()
+{
+    return calcAllTypes(*this);
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::functionObjects::add::add
+(
+    const word& name,
+    const Time& runTime,
+    const dictionary& dict
+)
+:
+    fieldsExpression(name, runTime, dict)
+{
+    setResultName("add");
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::functionObjects::add::~add()
+{}
+
+
+// ************************************************************************* //

src/functionObjects/field/add/add.H

+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2016 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::functionObjects::add
+
+Group
+    grpFieldFunctionObjects
+
+Description
+    Add a list of fields.
+
+    The operation can be applied to any volume or surface fields generating a
+    volume or surface scalar field.
+
+    Example of function object specification:
+    \verbatim
+    Ttot
+    {
+        type            add;
+        libs            ("libfieldFunctionObjects.so");
+        fields          (T Tdelta);
+        result          Ttot;
+        executeControl  writeTime;
+        writeControl    writeTime;
+    }
+    \endverbatim
+
+See also
+    Foam::functionObjects::fieldsExpression
+    Foam::functionObjects::fvMeshFunctionObject
+
+SourceFiles
+    add.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef functionObjects_add_H
+#define functionObjects_add_H
+
+#include "fieldsExpression.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace functionObjects
+{
+
+/*---------------------------------------------------------------------------*\
+                           Class add Declaration
+\*---------------------------------------------------------------------------*/
+
+class add
+:
+    public fieldsExpression
+{
+    // Private Member Functions
+
+        //- Add the list of fields of the specified type
+        //  and return the result
+        template<class GeoFieldType>
+        tmp<GeoFieldType> calcFieldType() const;
+
+        //- Add the list of fields and return true if successful
+        virtual bool calc();
+
+
+public:
+
+    friend class fieldsExpression;
+
+
+    //- Runtime type information
+    TypeName("add");
+
+
+    // Constructors
+
+        //- Construct from Time and dictionary
+        add
+        (
+            const word& name,
+            const Time& runTime,
+            const dictionary& dict
+        );
+
+
+    //- Destructor
+    virtual ~add();
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace functionObjects
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+    #include "addTemplates.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/functionObjects/field/add/addTemplates.C

+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2016 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+template<class GeoFieldType>
+Foam::tmp<GeoFieldType>
+Foam::functionObjects::add::calcFieldType() const
+{
+    tmp<GeoFieldType> tresult
+    (
+        lookupObject<GeoFieldType>(fieldNames_[0])
+      + lookupObject<GeoFieldType>(fieldNames_[1])
+    );
+
+    for (label i=2; i<fieldNames_.size(); i++)
+    {
+        tresult.ref() += lookupObject<GeoFieldType>(fieldNames_[i]);
+    }
+
+    return tresult;
+}
+
+
+// ************************************************************************* //

src/functionObjects/field/fieldsExpression/fieldsExpression.C

@@ -52,12 +52,12 @@ void Foam::functionObjects::fieldsExpression::setResultName
 
     if (resultName_.empty())
     {
-        if (fieldNames_ != defaultArgs)
+        if (!fieldNames_.empty())
         {
-            resultName_ = typeName + '(';
-            forAll(fieldNames_, i)
+            resultName_ = typeName + '(' + fieldNames_[0];
+            for (label i=1; i<fieldNames_.size(); i++)
             {
-                resultName_ += fieldNames_[i];
+                resultName_ += ',' + fieldNames_[i];
             }
             resultName_ += ')';
         }
@@ -85,6 +85,15 @@ Foam::functionObjects::fieldsExpression::fieldsExpression
     resultName_(resultName)
 {
     read(dict);
+
+    if (fieldNames_.size() < 2)
+    {
+        FatalIOErrorInFunction(dict)
+            << "functionObject::" << type() << " " << name
+            << " requires at least 2 fields only "
+            << fieldNames_.size() << " provided: " << fieldNames_
+            << exit(FatalIOError);
+    }
 }
 
 

src/functionObjects/field/fieldsExpression/fieldsExpression.H

@@ -71,9 +71,27 @@ protected:
 
     // Protected member functions
 
-        virtual bool calc() = 0;
+        void setResultName
+        (
+            const word& typeName,
+            const wordList& defaultArg = wordList::null()
+        );
 
-        void setResultName(const word& typeName, const wordList& defaultArg);
+        //- Call 'calcFieldType' for the given functionObject
+        //  for 'volField' and 'surfaceField' field types
+        template<class Type, class FOType>
+        bool calcFieldTypes(FOType& fo);
+
+        //- Call 'calcFieldTypes' for the given 'Type' and functionObject
+        template<class Type, class FOType>
+        bool calcType(FOType& fo);
+
+        //- Call 'calcType' for the given functionObject
+        //  for each primitive type
+        template<class FOType>
+        bool calcAllTypes(FOType& fo);
+
+        virtual bool calc() = 0;
 
 
 private:
@@ -133,6 +151,12 @@ public:
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
+#ifdef NoRepository
+    #include "fieldsExpressionTemplates.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
 #endif
 
 // ************************************************************************* //

src/functionObjects/field/fieldsExpression/fieldsExpressionTemplates.C

+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2016 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "volFields.H"
+#include "surfaceFields.H"
+
+// * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
+
+template<class Type, class FOType>
+bool Foam::functionObjects::fieldsExpression::calcFieldTypes(FOType& fo)
+{
+    typedef GeometricField<Type, fvPatchField, volMesh> VolFieldType;
+    typedef GeometricField<Type, fvsPatchField, surfaceMesh> SurfaceFieldType;
+
+    if (foundObject<VolFieldType>(fieldNames_[0]))
+    {
+        return store
+        (
+            resultName_,
+            fo.template calcFieldType<VolFieldType>()
+        );
+    }
+    else if (foundObject<SurfaceFieldType>(fieldNames_[0]))
+    {
+        return store
+        (
+            resultName_,
+            fo.template calcFieldType<SurfaceFieldType>()
+        );
+    }
+    else
+    {
+        return false;
+    }
+}
+
+
+template<class Type, class FOType>
+bool Foam::functionObjects::fieldsExpression::calcType(FOType& fo)
+{
+    return calcFieldTypes<Type>(fo);
+}
+
+
+template<class FOType>
+bool Foam::functionObjects::fieldsExpression::calcAllTypes(FOType& fo)
+{
+    bool processed = false;
+
+    processed = processed || fo.template calcType<scalar>(fo);
+    processed = processed || fo.template calcType<vector>(fo);
+    processed = processed || fo.template calcType<sphericalTensor>(fo);
+    processed = processed || fo.template calcType<symmTensor>(fo);
+    processed = processed || fo.template calcType<tensor>(fo);
+
+    return processed;
+}
+
+
+// ************************************************************************* //

src/functionObjects/field/subtract/subtract.C

@@ -42,15 +42,7 @@ namespace functionObjects
 
 bool Foam::functionObjects::subtract::calc()
 {
-    bool processed = false;
-
-    processed = processed || calcSubtract<scalar>();
-    processed = processed || calcSubtract<vector>();
-    processed = processed || calcSubtract<sphericalTensor>();
-    processed = processed || calcSubtract<symmTensor>();
-    processed = processed || calcSubtract<tensor>();
-
-    return processed;
+    return calcAllTypes(*this);
 }
 
 
@@ -65,15 +57,7 @@ Foam::functionObjects::subtract::subtract
 :
     fieldsExpression(name, runTime, dict)
 {
-    read(dict);
-
-    if (fieldNames_.size() < 2)
-    {
-        FatalIOErrorInFunction(dict)
-            << type() << " requires at least 2 fields only "
-            << fieldNames_.size() << " provided: " << fieldNames_
-            << exit(FatalIOError);
-    }
+    setResultName("subtract");
 }
 
 

src/functionObjects/field/subtract/subtract.H

@@ -80,11 +80,7 @@ class subtract
         //- Subtract the list of fields of the specified type
         //  and return the result
         template<class GeoFieldType>
-        tmp<GeoFieldType> subtractFields() const;
-
-        //- Subtract the list of fields and register the result
-        template<class Type>
-        bool calcSubtract();
+        tmp<GeoFieldType> calcFieldType() const;
 
         //- Subtract the list of fields and return true if successful
         virtual bool calc();
@@ -92,6 +88,9 @@ class subtract
 
 public:
 
+    friend class fieldsExpression;
+
+
     //- Runtime type information
     TypeName("subtract");
 

src/functionObjects/field/subtract/subtractTemplates.C

@@ -23,14 +23,11 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-#include "volFields.H"
-#include "surfaceFields.H"
-
-// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 
 template<class GeoFieldType>
 Foam::tmp<GeoFieldType>
-Foam::functionObjects::subtract::subtractFields() const
+Foam::functionObjects::subtract::calcFieldType() const
 {
     tmp<GeoFieldType> tresult
     (
@@ -40,40 +37,11 @@ Foam::functionObjects::subtract::subtractFields() const
 
     for (label i=2; i<fieldNames_.size(); i++)
     {
-        tresult = tresult - lookupObject<GeoFieldType>(fieldNames_[i]);
+        tresult.ref() -= lookupObject<GeoFieldType>(fieldNames_[i]);
     }
 
     return tresult;
 }
 
 
-template<class Type>
-bool Foam::functionObjects::subtract::calcSubtract()
-{
-    typedef GeometricField<Type, fvPatchField, volMesh> VolFieldType;
-    typedef GeometricField<Type, fvsPatchField, surfaceMesh> SurfaceFieldType;
-
-    if (foundObject<VolFieldType>(fieldNames_[0]))
-    {
-        return store
-        (
-            resultName_,
-            subtractFields<VolFieldType>()
-        );
-    }
-    else if (foundObject<SurfaceFieldType>(fieldNames_[0]))
-    {
-        return store
-        (
-            resultName_,
-            subtractFields<SurfaceFieldType>()
-        );
-    }
-    else
-    {
-        return false;
-    }
-}
-
-
 // ************************************************************************* //