Merge branch 'finiteAreaUpdate' into feature/PstreamUpdate

src/finiteArea/Make/files

@@ -48,6 +48,8 @@ derivedFaPatchFields = $(faPatchFields)/derived
 $(derivedFaPatchFields)/fixedValueOutflow/fixedValueOutflowFaPatchFields.C
 $(derivedFaPatchFields)/inletOutlet/inletOutletFaPatchFields.C
 $(derivedFaPatchFields)/slip/slipFaPatchFields.C
+$(derivedFaPatchFields)/edgeNormalFixedValue/edgeNormalFixedValueFaPatchVectorField.C
+$(derivedFaPatchFields)/timeVaryingUniformFixedValue/timeVaryingUniformFixedValueFaPatchFields.C
 
 faePatchFields = fields/faePatchFields
 $(faePatchFields)/faePatchField/faePatchFields.C
@@ -92,6 +94,7 @@ $(ddtSchemes)/backwardFaDdtScheme/backwardFaDdtSchemes.C
 $(ddtSchemes)/boundedBackwardFaDdtScheme/boundedBackwardFaDdtScheme.C
 
 divSchemes = finiteArea/divSchemes
+finiteArea/fam/vectorFamDiv.C
 $(divSchemes)/faDivScheme/faDivSchemes.C
 $(divSchemes)/gaussFaDivScheme/gaussFaDivSchemes.C
 

src/finiteArea/fields/faPatchFields/basic/transform/transformFaPatchFields.C

@@ -28,7 +28,6 @@ Description
 #include "faPatchFields.H"
 #include "transformFaPatchFields.H"
 #include "addToRunTimeSelectionTable.H"
-// #include "volFields.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -37,10 +36,6 @@ namespace Foam
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-// defineNamedTemplateTypeNameAndDebug(transformFaPatchScalarField, 0);
-// defineNamedTemplateTypeNameAndDebug(transformFaPatchVectorField, 0);
-// defineNamedTemplateTypeNameAndDebug(transformFaPatchTensorField, 0);
-
 makeFaPatchFieldsTypeName(transform);
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

src/finiteArea/fields/faPatchFields/constraint/wedge/wedgeFaPatchFields.C

@@ -28,7 +28,6 @@ Description
 #include "faPatchFields.H"
 #include "wedgeFaPatchFields.H"
 #include "addToRunTimeSelectionTable.H"
-// #include "volFields.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -37,10 +36,6 @@ namespace Foam
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-// defineNamedTemplateTypeNameAndDebug(wedgeFaPatchScalarField, 0);
-// defineNamedTemplateTypeNameAndDebug(wedgeFaPatchVectorField, 0);
-// defineNamedTemplateTypeNameAndDebug(wedgeFaPatchTensorField, 0);
-
 makeFaPatchFields(wedge);
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

src/finiteArea/fields/faPatchFields/derived/edgeNormalFixedValue/edgeNormalFixedValueFaPatchVectorField.C

@@ -0,0 +1,155 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | foam-extend: Open Source CFD
+   \\    /   O peration     | Version:     4.0
+    \\  /    A nd           | Web:         http://www.foam-extend.org
+     \\/     M anipulation  | For copyright notice see file Copyright
+-------------------------------------------------------------------------------
+License
+    This file is part of foam-extend.
+
+    foam-extend 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.
+
+    foam-extend 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 foam-extend.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "edgeNormalFixedValueFaPatchVectorField.H"
+#include "addToRunTimeSelectionTable.H"
+#include "areaFields.H"
+#include "faPatchFieldMapper.H"
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::edgeNormalFixedValueFaPatchVectorField::
+edgeNormalFixedValueFaPatchVectorField
+(
+    const faPatch& p,
+    const DimensionedField<vector, areaMesh>& iF
+)
+:
+    fixedValueFaPatchVectorField(p, iF),
+    refValue_(p.size(), 0)
+{}
+
+
+Foam::edgeNormalFixedValueFaPatchVectorField::
+edgeNormalFixedValueFaPatchVectorField
+(
+    const edgeNormalFixedValueFaPatchVectorField& ptf,
+    const faPatch& p,
+    const DimensionedField<vector, areaMesh>& iF,
+    const faPatchFieldMapper& mapper
+)
+:
+    fixedValueFaPatchVectorField(ptf, p, iF, mapper),
+    refValue_(ptf.refValue_, mapper)
+{}
+
+
+Foam::edgeNormalFixedValueFaPatchVectorField::
+edgeNormalFixedValueFaPatchVectorField
+(
+    const faPatch& p,
+    const DimensionedField<vector, areaMesh>& iF,
+    const dictionary& dict
+)
+:
+    fixedValueFaPatchVectorField(p, iF, dict),
+    refValue_("refValue", dict, p.size())
+{}
+
+
+Foam::edgeNormalFixedValueFaPatchVectorField::
+edgeNormalFixedValueFaPatchVectorField
+(
+    const edgeNormalFixedValueFaPatchVectorField& pivpvf
+)
+:
+    fixedValueFaPatchVectorField(pivpvf),
+    refValue_(pivpvf.refValue_)
+{}
+
+
+Foam::edgeNormalFixedValueFaPatchVectorField::
+edgeNormalFixedValueFaPatchVectorField
+(
+    const edgeNormalFixedValueFaPatchVectorField& pivpvf,
+    const DimensionedField<vector, areaMesh>& iF
+)
+:
+    fixedValueFaPatchVectorField(pivpvf, iF),
+    refValue_(pivpvf.refValue_)
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+void Foam::edgeNormalFixedValueFaPatchVectorField::autoMap
+(
+    const faPatchFieldMapper& m
+)
+{
+    fixedValueFaPatchVectorField::autoMap(m);
+    refValue_.autoMap(m);
+}
+
+
+void Foam::edgeNormalFixedValueFaPatchVectorField::rmap
+(
+    const faPatchVectorField& ptf,
+    const labelList& addr
+)
+{
+    fixedValueFaPatchVectorField::rmap(ptf, addr);
+
+    const edgeNormalFixedValueFaPatchVectorField& tiptf =
+        refCast<const edgeNormalFixedValueFaPatchVectorField>(ptf);
+
+    refValue_.rmap(tiptf.refValue_, addr);
+}
+
+
+void Foam::edgeNormalFixedValueFaPatchVectorField::updateCoeffs()
+{
+    if (updated())
+    {
+        return;
+    }
+
+    // Bug fix: update for moving mesh.  HJ, 15/Oct/2010
+    operator==(refValue_*patch().edgeNormals());
+}
+
+
+void Foam::edgeNormalFixedValueFaPatchVectorField::write(Ostream& os) const
+{
+    fixedValueFaPatchVectorField::write(os);
+    refValue_.writeEntry("refValue", os);
+}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+makeFaPatchTypeField
+(
+    faPatchVectorField,
+    edgeNormalFixedValueFaPatchVectorField
+);
+
+} // End namespace Foam
+
+
+// ************************************************************************* //

src/finiteArea/fields/faPatchFields/derived/edgeNormalFixedValue/edgeNormalFixedValueFaPatchVectorField.H

@@ -0,0 +1,173 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | foam-extend: Open Source CFD
+   \\    /   O peration     | Version:     4.0
+    \\  /    A nd           | Web:         http://www.foam-extend.org
+     \\/     M anipulation  | For copyright notice see file Copyright
+-------------------------------------------------------------------------------
+License
+    This file is part of foam-extend.
+
+    foam-extend 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.
+
+    foam-extend 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 foam-extend.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::edgeNormalFixedValueFaPatchVectorField
+
+Description
+    Edge normal fixed value vector field finite area boundary condition
+
+    Describes a surface normal vector boundary condition by its magnitude.
+    Note: The value is positive for outward-pointing vectors
+
+SourceFiles
+    edgeNormalFixedValueFaPatchVectorField.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef edgeNormalFixedValueFaPatchVectorField_H
+#define edgeNormalFixedValueFaPatchVectorField_H
+
+#include "faPatchFields.H"
+#include "fixedValueFaPatchFields.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                 Class edgeNormalFixedValueFaPatch Declaration
+\*---------------------------------------------------------------------------*/
+
+class edgeNormalFixedValueFaPatchVectorField
+:
+    public fixedValueFaPatchVectorField
+{
+    // Private data
+
+        //- Surface-normal velocity value
+        scalarField refValue_;
+
+
+public:
+
+    //- Runtime type information
+    TypeName("edgeNormalFixedValue");
+
+
+    // Constructors
+
+        //- Construct from patch and internal field
+        edgeNormalFixedValueFaPatchVectorField
+        (
+            const faPatch&,
+            const DimensionedField<vector, areaMesh>&
+        );
+
+        //- Construct from patch, internal field and dictionary
+        edgeNormalFixedValueFaPatchVectorField
+        (
+            const faPatch&,
+            const DimensionedField<vector, areaMesh>&,
+            const dictionary&
+        );
+
+        //- Construct by mapping given
+        //  edgeNormalFixedValueFaPatchVectorField
+        //  onto a new patch
+        edgeNormalFixedValueFaPatchVectorField
+        (
+            const edgeNormalFixedValueFaPatchVectorField&,
+            const faPatch&,
+            const DimensionedField<vector, areaMesh>&,
+            const faPatchFieldMapper&
+        );
+
+        //- Construct as copy
+        edgeNormalFixedValueFaPatchVectorField
+        (
+            const edgeNormalFixedValueFaPatchVectorField&
+        );
+
+        //- Construct and return a clone
+        virtual tmp<faPatchVectorField> clone() const
+        {
+            return tmp<faPatchVectorField>
+            (
+                new edgeNormalFixedValueFaPatchVectorField(*this)
+            );
+        }
+
+        //- Construct as copy setting internal field reference
+        edgeNormalFixedValueFaPatchVectorField
+        (
+            const edgeNormalFixedValueFaPatchVectorField&,
+            const DimensionedField<vector, areaMesh>&
+        );
+
+        //- Construct and return a clone setting internal field reference
+        virtual tmp<faPatchVectorField> clone
+        (
+            const DimensionedField<vector, areaMesh>& iF
+        ) const
+        {
+            return tmp<faPatchVectorField>
+            (
+                new edgeNormalFixedValueFaPatchVectorField
+                (
+                    *this,
+                    iF
+                )
+            );
+        }
+
+
+
+    // Member functions
+
+        // Mapping functions
+
+            //- Map (and resize as needed) from self given a mapping object
+            virtual void autoMap
+            (
+                const faPatchFieldMapper&
+            );
+
+            //- Reverse map the given faPatchField onto this faPatchField
+            virtual void rmap
+            (
+                const faPatchVectorField&,
+                const labelList&
+            );
+
+
+    // Member functions
+
+        //- Update the coefficients associated with the patch field
+        virtual void updateCoeffs();
+
+        //- Write
+        virtual void write(Ostream&) const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/finiteArea/fields/faPatchFields/derived/timeVaryingUniformFixedValue/timeVaryingUniformFixedValueFaPatchField.C

@@ -0,0 +1,137 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | foam-extend: Open Source CFD
+   \\    /   O peration     | Version:     4.0
+    \\  /    A nd           | Web:         http://www.foam-extend.org
+     \\/     M anipulation  | For copyright notice see file Copyright
+-------------------------------------------------------------------------------
+License
+    This file is part of foam-extend.
+
+    foam-extend 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.
+
+    foam-extend 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 foam-extend.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "timeVaryingUniformFixedValueFaPatchField.H"
+#include "foamTime.H"
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+template<class Type>
+Foam::timeVaryingUniformFixedValueFaPatchField<Type>::
+timeVaryingUniformFixedValueFaPatchField
+(
+    const faPatch& p,
+    const DimensionedField<Type, areaMesh>& iF
+)
+:
+    fixedValueFaPatchField<Type>(p, iF),
+    timeSeries_()
+{}
+
+
+template<class Type>
+Foam::timeVaryingUniformFixedValueFaPatchField<Type>::
+timeVaryingUniformFixedValueFaPatchField
+(
+    const faPatch& p,
+    const DimensionedField<Type, areaMesh>& iF,
+    const dictionary& dict
+)
+:
+    fixedValueFaPatchField<Type>(p, iF),
+    timeSeries_(dict)
+{
+   if (dict.found("value"))
+   {
+       faPatchField<Type>::operator==(Field<Type>("value", dict, p.size()));
+   }
+   else
+   {
+       updateCoeffs();
+   }
+}
+
+
+template<class Type>
+Foam::timeVaryingUniformFixedValueFaPatchField<Type>::
+timeVaryingUniformFixedValueFaPatchField
+(
+    const timeVaryingUniformFixedValueFaPatchField<Type>& ptf,
+    const faPatch& p,
+    const DimensionedField<Type, areaMesh>& iF,
+    const faPatchFieldMapper& mapper
+)
+:
+    fixedValueFaPatchField<Type>(ptf, p, iF, mapper),
+    timeSeries_(ptf.timeSeries_)
+{}
+
+
+template<class Type>
+Foam::timeVaryingUniformFixedValueFaPatchField<Type>::
+timeVaryingUniformFixedValueFaPatchField
+(
+    const timeVaryingUniformFixedValueFaPatchField<Type>& ptf
+)
+:
+    fixedValueFaPatchField<Type>(ptf),
+    timeSeries_(ptf.timeSeries_)
+{}
+
+
+template<class Type>
+Foam::timeVaryingUniformFixedValueFaPatchField<Type>::
+timeVaryingUniformFixedValueFaPatchField
+(
+    const timeVaryingUniformFixedValueFaPatchField<Type>& ptf,
+    const DimensionedField<Type, areaMesh>& iF
+)
+:
+    fixedValueFaPatchField<Type>(ptf, iF),
+    timeSeries_(ptf.timeSeries_)
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+template<class Type>
+void Foam::timeVaryingUniformFixedValueFaPatchField<Type>::updateCoeffs()
+{
+    if (this->updated())
+    {
+        return;
+    }
+
+    faPatchField<Type>::operator==
+    (
+        timeSeries_(this->db().time().timeOutputValue())
+    );
+    fixedValueFaPatchField<Type>::updateCoeffs();
+}
+
+
+template<class Type>
+void Foam::timeVaryingUniformFixedValueFaPatchField<Type>::write
+(
+    Ostream& os
+) const
+{
+    faPatchField<Type>::write(os);
+    timeSeries_.write(os);
+    this->writeEntry("value", os);
+}
+
+
+// ************************************************************************* //

src/finiteArea/fields/faPatchFields/derived/timeVaryingUniformFixedValue/timeVaryingUniformFixedValueFaPatchField.H

@@ -0,0 +1,182 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | foam-extend: Open Source CFD
+   \\    /   O peration     | Version:     4.0
+    \\  /    A nd           | Web:         http://www.foam-extend.org
+     \\/     M anipulation  | For copyright notice see file Copyright
+-------------------------------------------------------------------------------
+License
+    This file is part of foam-extend.
+
+    foam-extend 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.
+
+    foam-extend 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 foam-extend.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::timeVaryingUniformFixedValueFaPatchField
+
+Description
+    A time-varying form of a uniform fixed value finite area
+    boundary condition.
+
+    Example of the boundary condition specification:
+    @verbatim
+    inlet
+    {
+        type            timeVaryingUniformFixedValue;
+        fileName        "$FOAM_CASE/time-series";
+        outOfBounds     clamp;           // (error|warn|clamp|repeat)
+    }
+    @endverbatim
+
+Note
+    This class is derived directly from a fixedValue patch rather than from
+    a uniformFixedValue patch.
+
+See Also
+    Foam::interpolationTable and Foam::fixedValueFaPatchField
+
+SourceFiles
+    timeVaryingUniformFixedValueFaPatchField.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef timeVaryingUniformFixedValueFaPatchField_H
+#define timeVaryingUniformFixedValueFaPatchField_H
+
+#include "fixedValueFaPatchField.H"
+#include "interpolationTable.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+           Class timeVaryingUniformFixedValueFaPatch Declaration
+\*---------------------------------------------------------------------------*/
+
+template<class Type>
+class timeVaryingUniformFixedValueFaPatchField
+:
+    public fixedValueFaPatchField<Type>
+{
+    // Private data
+
+        //- The time series being used, including the bounding treatment
+        interpolationTable<Type> timeSeries_;
+
+
+public:
+
+    //- Runtime type information
+    TypeName("timeVaryingUniformFixedValue");
+
+
+    // Constructors
+
+        //- Construct from patch and internal field
+        timeVaryingUniformFixedValueFaPatchField
+        (
+            const faPatch&,
+            const DimensionedField<Type, areaMesh>&
+        );
+
+        //- Construct from patch, internal field and dictionary
+        timeVaryingUniformFixedValueFaPatchField
+        (
+            const faPatch&,
+            const DimensionedField<Type, areaMesh>&,
+            const dictionary&
+        );
+
+        //- Construct by mapping given patch field onto a new patch
+        timeVaryingUniformFixedValueFaPatchField
+        (
+            const timeVaryingUniformFixedValueFaPatchField<Type>&,
+            const faPatch&,
+            const DimensionedField<Type, areaMesh>&,
+            const faPatchFieldMapper&
+        );
+
+        //- Construct as copy
+        timeVaryingUniformFixedValueFaPatchField
+        (
+            const timeVaryingUniformFixedValueFaPatchField<Type>&
+        );
+
+        //- Construct and return a clone
+        virtual tmp<faPatchField<Type> > clone() const
+        {
+            return tmp<faPatchField<Type> >
+            (
+                new timeVaryingUniformFixedValueFaPatchField<Type>(*this)
+            );
+        }
+
+        //- Construct as copy setting internal field reference
+        timeVaryingUniformFixedValueFaPatchField
+        (
+            const timeVaryingUniformFixedValueFaPatchField<Type>&,
+            const DimensionedField<Type, areaMesh>&
+        );
+
+        //- Construct and return a clone setting internal field reference
+        virtual tmp<faPatchField<Type> > clone
+        (
+            const DimensionedField<Type, areaMesh>& iF
+        ) const
+        {
+            return tmp<faPatchField<Type> >
+            (
+                new timeVaryingUniformFixedValueFaPatchField<Type>(*this, iF)
+            );
+        }
+
+
+    // Member functions
+
+        // Access
+
+            //- Return the time series used
+            const interpolationTable<Type>& timeSeries() const
+            {
+                return timeSeries_;
+            }
+
+
+        // Evaluation functions
+
+            //- Update the coefficients associated with the patch field
+            virtual void updateCoeffs();
+
+
+        //- Write
+        virtual void write(Ostream&) const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+#   include "timeVaryingUniformFixedValueFaPatchField.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/finiteArea/fields/faPatchFields/derived/timeVaryingUniformFixedValue/timeVaryingUniformFixedValueFaPatchFields.C

@@ -0,0 +1,43 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | foam-extend: Open Source CFD
+   \\    /   O peration     | Version:     4.0
+    \\  /    A nd           | Web:         http://www.foam-extend.org
+     \\/     M anipulation  | For copyright notice see file Copyright
+-------------------------------------------------------------------------------
+License
+    This file is part of foam-extend.
+
+    foam-extend 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.
+
+    foam-extend 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 foam-extend.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "timeVaryingUniformFixedValueFaPatchFields.H"
+#include "addToRunTimeSelectionTable.H"
+#include "areaFields.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+makeFaPatchFields(timeVaryingUniformFixedValue);
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// ************************************************************************* //

src/finiteArea/fields/faPatchFields/derived/timeVaryingUniformFixedValue/timeVaryingUniformFixedValueFaPatchFields.H

@@ -0,0 +1,49 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | foam-extend: Open Source CFD
+   \\    /   O peration     | Version:     4.0
+    \\  /    A nd           | Web:         http://www.foam-extend.org
+     \\/     M anipulation  | For copyright notice see file Copyright
+-------------------------------------------------------------------------------
+License
+    This file is part of foam-extend.
+
+    foam-extend 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.
+
+    foam-extend 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 foam-extend.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef timeVaryingUniformFixedValueFaPatchFields_H
+#define timeVaryingUniformFixedValueFaPatchFields_H
+
+#include "timeVaryingUniformFixedValueFaPatchField.H"
+#include "fieldTypes.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+makeFaPatchTypeFieldTypedefs(timeVaryingUniformFixedValue)
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/finiteArea/fields/faPatchFields/derived/timeVaryingUniformFixedValue/timeVaryingUniformFixedValueFaPatchFieldsFwd.H

@@ -0,0 +1,51 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | foam-extend: Open Source CFD
+   \\    /   O peration     | Version:     4.0
+    \\  /    A nd           | Web:         http://www.foam-extend.org
+     \\/     M anipulation  | For copyright notice see file Copyright
+-------------------------------------------------------------------------------
+License
+    This file is part of foam-extend.
+
+    foam-extend 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.
+
+    foam-extend 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 foam-extend.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef timeVaryingUniformFixedValueFaPatchFieldsFwd_H
+#define timeVaryingUniformFixedValueFaPatchFieldsFwd_H
+
+#include "faPatchField.H"
+#include "fieldTypes.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+template<class Type> class timeVaryingUniformFixedValueFaPatchField;
+
+makeFaPatchTypeFieldTypedefs(timeVaryingUniformFixedValue);
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/finiteArea/fields/faPatchFields/faPatchField/faPatchField.H

@@ -468,60 +468,87 @@ public:
 #endif
 
 
-#define makeFaPatchTypeFieldTypeName(typePatchTypeField)                   \
+#define addToFaPatchFieldRunTimeSelection(PatchTypeField, typePatchTypeField) \
-                                                                           \
+                                                                              \
-defineNamedTemplateTypeNameAndDebug(typePatchTypeField, 0);
+addToRunTimeSelectionTable                                                    \
-
+(                                                                             \
-#define makeFaPatchFieldsTypeName(typePatchField)                          \
+    PatchTypeField, typePatchTypeField, patch                                 \
-                                                                           \
+);                                                                            \
-makeFaPatchTypeFieldTypeName(typePatchField##FaPatchScalarField);          \
+                                                                              \
-makeFaPatchTypeFieldTypeName(typePatchField##FaPatchVectorField);          \
+addToRunTimeSelectionTable                                                    \
-makeFaPatchTypeFieldTypeName(typePatchField##FaPatchSphericalTensorField); \
+(                                                                             \
-makeFaPatchTypeFieldTypeName(typePatchField##FaPatchSymmTensorField);      \
+    PatchTypeField,                                                           \
-makeFaPatchTypeFieldTypeName(typePatchField##FaPatchTensorField);
+    typePatchTypeField,                                                       \
-
+    patchMapper                                                               \
-#define makeFaPatchTypeField(PatchTypeField, typePatchTypeField)           \
+);                                                                            \
-                                                                           \
+                                                                              \
-defineNamedTemplateTypeNameAndDebug(typePatchTypeField, 0);                \
+addToRunTimeSelectionTable                                                    \
-                                                                           \
+(                                                                             \
-addToRunTimeSelectionTable                                                 \
+    PatchTypeField, typePatchTypeField, dictionary                            \
-(                                                                          \
-    PatchTypeField, typePatchTypeField, patch                              \
-);                                                                         \
-                                                                           \
-addToRunTimeSelectionTable                                                 \
-(                                                                          \
-    PatchTypeField,                                                        \
-    typePatchTypeField,                                                    \
-    patchMapper                                                            \
-);                                                                         \
-                                                                           \
-addToRunTimeSelectionTable                                                 \
-(                                                                          \
-    PatchTypeField, typePatchTypeField, dictionary                         \
 );
 
 
-#define makeFaPatchFields(type)                                            \
+#define makeFaPatchTypeFieldTypeName(typePatchTypeField)                      \
-                                                                           \
+                                                                              \
-makeFaPatchTypeField(faPatchScalarField, type##FaPatchScalarField);        \
+defineNamedTemplateTypeNameAndDebug(typePatchTypeField, 0);
-makeFaPatchTypeField(faPatchVectorField, type##FaPatchVectorField);        \
-makeFaPatchTypeField                                                       \
-(                                                                          \
-    faPatchSphericalTensorField,                                           \
-    type##FaPatchSphericalTensorField                                      \
-);                                                                         \
-makeFaPatchTypeField(faPatchSymmTensorField, type##FaPatchSymmTensorField);\
-makeFaPatchTypeField(faPatchTensorField, type##FaPatchTensorField);
 
 
-#define makeFaPatchTypeFieldTypedefs(type)                                   \
+#define makeFaPatchFieldsTypeName(typePatchField)                             \
-                                                                             \
+                                                                              \
-typedef type##FaPatchField<scalar> type##FaPatchScalarField;                 \
+makeFaPatchTypeFieldTypeName(typePatchField##FaPatchScalarField);             \
-typedef type##FaPatchField<vector> type##FaPatchVectorField;                 \
+makeFaPatchTypeFieldTypeName(typePatchField##FaPatchVectorField);             \
-typedef type##FaPatchField<sphericalTensor>                                  \
+makeFaPatchTypeFieldTypeName(typePatchField##FaPatchSphericalTensorField);    \
-     type##FaPatchSphericalTensorField;                                      \
+makeFaPatchTypeFieldTypeName(typePatchField##FaPatchSymmTensorField);         \
-typedef type##FaPatchField<symmTensor> type##FaPatchSymmTensorField;         \
+makeFaPatchTypeFieldTypeName(typePatchField##FaPatchTensorField);
+
+
+#define makeFaPatchTypeField(PatchTypeField, typePatchTypeField)              \
+                                                                              \
+defineTypeNameAndDebug(typePatchTypeField, 0);                                \
+                                                                              \
+addToFaPatchFieldRunTimeSelection                                             \
+(                                                                             \
+    PatchTypeField, typePatchTypeField                                        \
+);
+
+#define makeTemplateFaPatchTypeField(PatchTypeField, typePatchTypeField)      \
+                                                                              \
+defineNamedTemplateTypeNameAndDebug(typePatchTypeField, 0);                   \
+                                                                              \
+addToFaPatchFieldRunTimeSelection                                             \
+(                                                                             \
+    PatchTypeField, typePatchTypeField                                        \
+);
+
+
+#define makeFaPatchFields(type)                                               \
+                                                                              \
+makeTemplateFaPatchTypeField(faPatchScalarField, type##FaPatchScalarField);   \
+makeTemplateFaPatchTypeField(faPatchVectorField, type##FaPatchVectorField);   \
+makeTemplateFaPatchTypeField                                                  \
+(                                                                             \
+    faPatchSphericalTensorField,                                              \
+    type##FaPatchSphericalTensorField                                         \
+);                                                                            \
+makeTemplateFaPatchTypeField                                                  \
+(                                                                             \
+    faPatchSymmTensorField,                                                   \
+    type##FaPatchSymmTensorField                                              \
+);                                                                            \
+makeTemplateFaPatchTypeField                                                  \
+(                                                                             \
+    faPatchTensorField,                                                       \
+    type##FaPatchTensorField                                                  \
+);
+
+
+#define makeFaPatchTypeFieldTypedefs(type)                                    \
+                                                                              \
+typedef type##FaPatchField<scalar> type##FaPatchScalarField;                  \
+typedef type##FaPatchField<vector> type##FaPatchVectorField;                  \
+typedef type##FaPatchField<sphericalTensor>                                   \
+     type##FaPatchSphericalTensorField;                                       \
+typedef type##FaPatchField<symmTensor> type##FaPatchSymmTensorField;          \
 typedef type##FaPatchField<tensor> type##FaPatchTensorField;
 
 

src/finiteArea/finiteArea/divSchemes/gaussFaDivScheme/gaussFaDivScheme.C

@@ -62,7 +62,7 @@ gaussDivScheme<Type>::facDiv
         (
             this->mesh_.Le() & this->tinterpScheme_().interpolate(vf)
         )
-      - this->mesh_.faceCurvatures()*(this->mesh_.faceAreaNormals()&vf)
+        // Removed for consistencty.  Matthias Rauter, 6/Dec/2016
     );
 
     tDiv().rename("div(" + vf.name() + ')');

src/finiteArea/finiteArea/fac/fac.H

@@ -43,6 +43,8 @@ Description
 #include "facAverage.H"
 #include "facLnGrad.H"
 #include "facDdt.H"
+#include "facNGrad.H"
+#include "facNDiv.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 

src/finiteArea/finiteArea/fac/facDiv.C

@@ -28,6 +28,7 @@ License
 #include "facEdgeIntegrate.H"
 #include "faDivScheme.H"
 #include "faConvectionScheme.H"
+#include "transformField.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -48,7 +49,17 @@ div
     const GeometricField<Type, faePatchField, edgeMesh>& ssf
 )
 {
-    return fac::edgeIntegrate(ssf);
+    const areaVectorField& n = ssf.mesh().faceAreaNormals();
+
+    tmp<GeometricField<Type, faPatchField, areaMesh> > tDiv =
+        fac::edgeIntegrate(ssf);
+
+    GeometricField<Type, faPatchField, areaMesh>& Div = tDiv();
+
+    Div.internalField() = transform(tensor::I - sqr(n), Div.internalField());
+    Div.correctBoundaryConditions();
+
+    return tDiv;
 }
 
 
@@ -79,10 +90,34 @@ div
     const word& name
 )
 {
-    return fa::divScheme<Type>::New
+    const areaVectorField& n = vf.mesh().faceAreaNormals();
+
+    tmp
+    <
+        GeometricField
+        <
+            typename innerProduct<vector, Type>::type,
+            faPatchField,
+            areaMesh
+        >
+    > tDiv
     (
-        vf.mesh(), vf.mesh().schemesDict().divScheme(name)
+        fa::divScheme<Type>::New
-    )().facDiv(vf);
+        (
+            vf.mesh(), vf.mesh().schemesDict().divScheme(name)
+        )().facDiv(vf)
+    );
+    GeometricField
+    <
+        typename innerProduct<vector, Type>::type,
+        faPatchField,
+        areaMesh
+    >& Div = tDiv();
+
+    Div.internalField() = transform(tensor::I - sqr(n), Div.internalField());
+    Div.correctBoundaryConditions();
+
+    return tDiv;
 }
 
 
@@ -159,12 +194,24 @@ div
     const word& name
 )
 {
-    return fa::convectionScheme<Type>::New
+    const areaVectorField& n = vf.mesh().faceAreaNormals();
+
+    tmp<GeometricField<Type, faPatchField, areaMesh> > tDiv
     (
-        vf.mesh(),
+        fa::convectionScheme<Type>::New
-        flux,
+        (
-        vf.mesh().schemesDict().divScheme(name)
+            vf.mesh(),
-    )().facDiv(flux, vf);
+            flux,
+            vf.mesh().schemesDict().divScheme(name)
+        )().facDiv(flux, vf)
+    );
+    GeometricField<Type, faPatchField, areaMesh>& Div = tDiv();
+
+    Div.internalField() = transform(tensor::I - sqr(n), Div.internalField());
+    Div.correctBoundaryConditions();
+
+    return tDiv;
+
 }
 
 

src/finiteArea/finiteArea/fac/facGrad.C

@@ -55,7 +55,18 @@ grad
     const GeometricField<Type, faePatchField, edgeMesh>& ssf
 )
 {
-    return fac::edgeIntegrate(ssf.mesh().Sf() * ssf);
+    const areaVectorField &n = ssf.mesh().faceAreaNormals();
+    typedef typename outerProduct<vector,Type>::type GradType;
+
+    tmp<GeometricField<GradType, faPatchField, areaMesh> > tgGrad =
+        fac::edgeIntegrate(ssf.mesh().Sf()*ssf);
+
+    GeometricField<GradType, faPatchField, areaMesh>& gGrad = tgGrad();
+
+    gGrad -= (gGrad & n)*n;
+    gGrad.correctBoundaryConditions();
+
+    return tgGrad;
 }
 
 template<class Type>
@@ -95,11 +106,22 @@ grad
     const word& name
 )
 {
-    return fa::gradScheme<Type>::New
+    const areaVectorField &n = vf.mesh().faceAreaNormals();
-    (
+    typedef typename outerProduct<vector,Type>::type GradType;
-        vf.mesh(),
+
-        vf.mesh().schemesDict().gradScheme(name)
+    tmp<GeometricField<GradType, faPatchField, areaMesh> > tgGrad =
-    )().grad(vf);
+        fa::gradScheme<Type>::New
+        (
+            vf.mesh(),
+            vf.mesh().schemesDict().gradScheme(name)
+        )().grad(vf);
+
+    GeometricField<GradType, faPatchField, areaMesh>& gGrad = tgGrad();
+
+    gGrad -= (gGrad & n)*n;
+    gGrad.correctBoundaryConditions();
+
+    return tgGrad;
 }
 
 

src/finiteArea/finiteArea/fac/facNDiv.C

@@ -0,0 +1,333 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | foam-extend: Open Source CFD
+   \\    /   O peration     | Version:     3.2
+    \\  /    A nd           | Web:         http://www.foam-extend.org
+     \\/     M anipulation  | For copyright notice see file Copyright
+-------------------------------------------------------------------------------
+License
+    This file is part of foam-extend.
+
+    foam-extend 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.
+
+    foam-extend 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 foam-extend.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "facNDiv.H"
+#include "faMesh.H"
+#include "facEdgeIntegrate.H"
+#include "faDivScheme.H"
+#include "faConvectionScheme.H"
+#include "transformField.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace fac
+{
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+template<class Type>
+tmp<GeometricField<Type, faPatchField, areaMesh> >
+ndiv
+(
+    const GeometricField<Type, faePatchField, edgeMesh>& ssf
+)
+{
+    const areaVectorField &n = ssf.mesh().faceAreaNormals();
+
+    tmp<GeometricField<Type, faPatchField, areaMesh> > v = fac::edgeIntegrate(ssf);
+
+    //v.internalField() = transform(n*n, v.internalField());
+    v.internalField() = (v.internalField()&n)*n;
+
+    return v;
+}
+
+
+template<class Type>
+tmp<GeometricField<Type, faPatchField, areaMesh> >
+ndiv
+(
+    const tmp<GeometricField<Type, faePatchField, edgeMesh> >& tssf
+)
+{
+    tmp<GeometricField<Type, faPatchField, areaMesh> > Div(fac::ndiv(tssf()));
+    tssf.clear();
+    return Div;
+}
+
+
+template<class Type>
+tmp
+<
+    GeometricField
+    <
+        typename innerProduct<vector, Type>::type, faPatchField, areaMesh
+    >
+>
+ndiv
+(
+    const GeometricField<Type, faPatchField, areaMesh>& vf,
+    const word& name
+)
+{
+    const areaVectorField &n = vf.mesh().faceAreaNormals();
+
+    tmp<GeometricField<Type, faPatchField, areaMesh> > tDiv
+    (
+        fa::divScheme<Type>::New
+            (
+                vf.mesh(), vf.mesh().schemesDict().divScheme(name)
+            )().facDiv(vf)
+    );
+
+    GeometricField<Type, faPatchField, areaMesh>& Div = tDiv();
+
+    //Div.internalField() = transform(n*n, Div.internalField());
+    Div.internalField() = (Div.internalField()&n)*n;
+    return tDiv;
+}
+
+
+template<class Type>
+tmp
+<
+    GeometricField
+    <
+        typename innerProduct<vector, Type>::type, faPatchField, areaMesh
+    >
+>
+ndiv
+(
+    const tmp<GeometricField<Type, faPatchField, areaMesh> >& tvvf,
+    const word& name
+)
+{
+    typedef typename innerProduct<vector, Type>::type DivType;
+    tmp<GeometricField<DivType, faPatchField, areaMesh> > Div
+    (
+        fac::ndiv(tvvf(), name)
+    );
+    tvvf.clear();
+    return Div;
+}
+
+template<class Type>
+tmp
+<
+    GeometricField
+    <
+        typename innerProduct<vector, Type>::type, faPatchField, areaMesh
+    >
+>
+ndiv
+(
+    const GeometricField<Type, faPatchField, areaMesh>& vf
+)
+{
+    return fac::ndiv(vf, "div("+vf.name()+')');
+}
+
+
+template<class Type>
+tmp
+<
+    GeometricField
+    <
+        typename innerProduct<vector, Type>::type, faPatchField, areaMesh
+    >
+>
+ndiv
+(
+    const tmp<GeometricField<Type, faPatchField, areaMesh> >& tvvf
+)
+{
+    typedef typename innerProduct<vector, Type>::type DivType;
+    tmp<GeometricField<DivType, faPatchField, areaMesh> > Div
+    (
+        fac::ndiv(tvvf())
+    );
+
+    tvvf.clear();
+    return Div;
+}
+
+
+template<class Type>
+tmp<GeometricField<Type, faPatchField, areaMesh> >
+ndiv
+(
+    const edgeScalarField& flux,
+    const GeometricField<Type, faPatchField, areaMesh>& vf,
+    const word& name
+)
+{
+    const areaVectorField &n = vf.mesh().faceAreaNormals();
+
+    tmp<GeometricField<Type, faPatchField, areaMesh> > tDiv
+    (
+        fa::convectionScheme<Type>::New
+            (
+                vf.mesh(),
+                flux,
+                vf.mesh().schemesDict().divScheme(name)
+            )().facDiv(flux, vf)
+    );
+
+    GeometricField<Type, faPatchField, areaMesh>& Div = tDiv();
+
+    //Div.internalField() = transform(n*n, Div.internalField());
+    Div.internalField() = (Div.internalField()&n)*n;
+
+    return tDiv;
+
+}
+
+
+template<class Type>
+tmp<GeometricField<Type, faPatchField, areaMesh> >
+ndiv
+(
+    const tmp<edgeScalarField>& tflux,
+    const GeometricField<Type, faPatchField, areaMesh>& vf,
+    const word& name
+)
+{
+    tmp<GeometricField<Type, faPatchField, areaMesh> > Div
+    (
+        fac::ndiv(tflux(), vf, name)
+    );
+    tflux.clear();
+    return Div;
+}
+
+
+template<class Type>
+tmp<GeometricField<Type, faPatchField, areaMesh> >
+ndiv
+(
+    const edgeScalarField& flux,
+    const tmp<GeometricField<Type, faPatchField, areaMesh> >& tvf,
+    const word& name
+)
+{
+    tmp<GeometricField<Type, faPatchField, areaMesh> > Div
+    (
+        fac::ndiv(flux, tvf(), name)
+    );
+    tvf.clear();
+    return Div;
+}
+
+
+template<class Type>
+tmp<GeometricField<Type, faPatchField, areaMesh> >
+ndiv
+(
+    const tmp<edgeScalarField>& tflux,
+    const tmp<GeometricField<Type, faPatchField, areaMesh> >& tvf,
+    const word& name
+)
+{
+    tmp<GeometricField<Type, faPatchField, areaMesh> > Div
+    (
+        fac::ndiv(tflux(), tvf(), name)
+    );
+    tflux.clear();
+    tvf.clear();
+    return Div;
+}
+
+
+template<class Type>
+tmp<GeometricField<Type, faPatchField, areaMesh> >
+ndiv
+(
+    const edgeScalarField& flux,
+    const GeometricField<Type, faPatchField, areaMesh>& vf
+)
+{
+    return fac::ndiv
+    (
+        flux, vf, "div("+flux.name()+','+vf.name()+')'
+    );
+}
+
+
+template<class Type>
+tmp<GeometricField<Type, faPatchField, areaMesh> >
+ndiv
+(
+    const tmp<edgeScalarField>& tflux,
+    const GeometricField<Type, faPatchField, areaMesh>& vf
+)
+{
+    tmp<GeometricField<Type, faPatchField, areaMesh> > Div
+    (
+        fac::ndiv(tflux(), vf)
+    );
+    tflux.clear();
+    return Div;
+}
+
+
+template<class Type>
+tmp<GeometricField<Type, faPatchField, areaMesh> >
+ndiv
+(
+    const edgeScalarField& flux,
+    const tmp<GeometricField<Type, faPatchField, areaMesh> >& tvf
+)
+{
+    tmp<GeometricField<Type, faPatchField, areaMesh> > Div
+    (
+        fac::ndiv(flux, tvf())
+    );
+    tvf.clear();
+    return Div;
+}
+
+
+template<class Type>
+tmp<GeometricField<Type, faPatchField, areaMesh> >
+ndiv
+(
+    const tmp<edgeScalarField>& tflux,
+    const tmp<GeometricField<Type, faPatchField, areaMesh> >& tvf
+)
+{
+    tmp<GeometricField<Type, faPatchField, areaMesh> > Div
+    (
+        fac::ndiv(tflux(), tvf())
+    );
+    tflux.clear();
+    tvf.clear();
+    return Div;
+}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace fac
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// ************************************************************************* //

src/finiteArea/finiteArea/fac/facNDiv.H

@@ -0,0 +1,187 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | foam-extend: Open Source CFD
+   \\    /   O peration     | Version:     3.2
+    \\  /    A nd           | Web:         http://www.foam-extend.org
+     \\/     M anipulation  | For copyright notice see file Copyright
+-------------------------------------------------------------------------------
+License
+    This file is part of foam-extend.
+
+    foam-extend 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.
+
+    foam-extend 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 foam-extend.  If not, see <http://www.gnu.org/licenses/>.
+
+Namespace
+    fac
+
+Description
+    Calculate the divergence of the given field.
+
+SourceFiles
+    facDiv.C
+
+\*---------------------------------------------------------------------------*/
+
+
+#ifndef facNDiv_H
+#define facNDiv_H
+
+#include "areaFieldsFwd.H"
+#include "edgeFieldsFwd.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                     Namespace fac functions Declaration
+\*---------------------------------------------------------------------------*/
+
+namespace fac
+{
+    template<class Type>
+    tmp<GeometricField<Type, faPatchField, areaMesh> > ndiv
+    (
+        const GeometricField<Type, faePatchField, edgeMesh>&
+    );
+
+    template<class Type>
+    tmp<GeometricField<Type, faPatchField, areaMesh> > ndiv
+    (
+        const tmp<GeometricField<Type, faePatchField, edgeMesh> >&
+    );
+
+
+    template<class Type>
+    tmp
+    <
+        GeometricField
+        <typename innerProduct<vector, Type>::type, faPatchField, areaMesh>
+    > ndiv
+    (
+        const GeometricField<Type, faPatchField, areaMesh>&,
+        const word& name
+    );
+
+    template<class Type>
+    tmp
+    <
+        GeometricField
+        <typename innerProduct<vector, Type>::type, faPatchField, areaMesh>
+    > ndiv
+    (
+        const tmp<GeometricField<Type, faPatchField, areaMesh> >&,
+        const word& name
+    );
+
+
+    template<class Type>
+    tmp
+    <
+        GeometricField
+        <typename innerProduct<vector, Type>::type, faPatchField, areaMesh>
+    > ndiv
+    (
+        const GeometricField<Type, faPatchField, areaMesh>&
+    );
+
+    template<class Type>
+    tmp
+    <
+        GeometricField
+        <typename innerProduct<vector, Type>::type, faPatchField, areaMesh>
+    > ndiv
+    (
+        const tmp<GeometricField<Type, faPatchField, areaMesh> >&
+    );
+
+
+    template<class Type>
+    tmp<GeometricField<Type, faPatchField, areaMesh> > ndiv
+    (
+        const edgeScalarField&,
+        const GeometricField<Type, faPatchField, areaMesh>&,
+        const word& name
+    );
+
+    template<class Type>
+    tmp<GeometricField<Type, faPatchField, areaMesh> > ndiv
+    (
+        const tmp<edgeScalarField>&,
+        const GeometricField<Type, faPatchField, areaMesh>&,
+        const word& name
+    );
+
+    template<class Type>
+    tmp<GeometricField<Type, faPatchField, areaMesh> > ndiv
+    (
+        const edgeScalarField&,
+        const tmp<GeometricField<Type, faPatchField, areaMesh> >&,
+        const word& name
+    );
+
+    template<class Type>
+    tmp<GeometricField<Type, faPatchField, areaMesh> > ndiv
+    (
+        const tmp<edgeScalarField>&,
+        const tmp<GeometricField<Type, faPatchField, areaMesh> >&,
+        const word& name
+    );
+
+
+    template<class Type>
+    tmp<GeometricField<Type, faPatchField, areaMesh> > ndiv
+    (
+        const edgeScalarField&,
+        const GeometricField<Type, faPatchField, areaMesh>&
+    );
+
+    template<class Type>
+    tmp<GeometricField<Type, faPatchField, areaMesh> > ndiv
+    (
+        const tmp<edgeScalarField>&,
+        const GeometricField<Type, faPatchField, areaMesh>&
+    );
+
+    template<class Type>
+    tmp<GeometricField<Type, faPatchField, areaMesh> > ndiv
+    (
+        const edgeScalarField&,
+        const tmp<GeometricField<Type, faPatchField, areaMesh> >&
+    );
+
+    template<class Type>
+    tmp<GeometricField<Type, faPatchField, areaMesh> > ndiv
+    (
+        const tmp<edgeScalarField>&,
+        const tmp<GeometricField<Type, faPatchField, areaMesh> >&
+    );
+}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+#   include "facNDiv.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/finiteArea/finiteArea/fac/facNGrad.C

@@ -0,0 +1,202 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | foam-extend: Open Source CFD
+   \\    /   O peration     | Version:     3.2
+    \\  /    A nd           | Web:         http://www.foam-extend.org
+     \\/     M anipulation  | For copyright notice see file Copyright
+-------------------------------------------------------------------------------
+License
+    This file is part of foam-extend.
+
+    foam-extend 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.
+
+    foam-extend 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 foam-extend.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "facNGrad.H"
+#include "areaFields.H"
+#include "edgeFields.H"
+#include "facEdgeIntegrate.H"
+#include "faMesh.H"
+#include "faGradScheme.H"
+#include "transformField.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace fac
+{
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+template<class Type>
+tmp
+<
+    GeometricField
+    <
+        typename outerProduct<vector, Type>::type, faPatchField, areaMesh
+    >
+>
+ngrad
+(
+    const GeometricField<Type, faePatchField, edgeMesh>& ssf
+)
+{
+    const areaVectorField &n = ssf.mesh().faceAreaNormals();
+    typedef typename outerProduct<vector,Type>::type GradType;
+
+    tmp<GeometricField<GradType, faPatchField, areaMesh> > tgGrad = fac::edgeIntegrate(ssf.mesh().Sf() * ssf);
+
+    GeometricField<GradType, faPatchField, areaMesh>& grad = tgGrad();
+
+    grad = (grad&n)*n;
+
+    return tgGrad;
+}
+
+template<class Type>
+tmp
+<
+    GeometricField
+    <
+        typename outerProduct<vector,Type>::type, faPatchField, areaMesh
+    >
+>
+ngrad
+(
+    const tmp<GeometricField<Type, faePatchField, edgeMesh> >& tssf
+)
+{
+    typedef typename outerProduct<vector, Type>::type GradType;
+    tmp<GeometricField<GradType, faPatchField, areaMesh> > Grad
+    (
+        fac::ngrad(tssf())
+    );
+    tssf.clear();
+    return Grad;
+}
+
+
+template<class Type>
+tmp
+<
+    GeometricField
+    <
+        typename outerProduct<vector,Type>::type, faPatchField, areaMesh
+    >
+>
+ngrad
+(
+    const GeometricField<Type, faPatchField, areaMesh>& vf,
+    const word& name
+)
+{
+    const areaVectorField &n = vf.mesh().faceAreaNormals();
+    typedef typename outerProduct<vector,Type>::type GradType;
+
+    tmp<GeometricField<GradType, faPatchField, areaMesh> > tgGrad = fa::gradScheme<Type>::New
+        (
+            vf.mesh(),
+            vf.mesh().schemesDict().gradScheme(name)
+        )().grad(vf);
+
+    GeometricField<GradType, faPatchField, areaMesh>& grad = tgGrad();
+
+    grad = (grad&n)*n;
+
+    return tgGrad;
+}
+
+
+template<class Type>
+tmp
+<
+    GeometricField
+    <
+        typename outerProduct<vector,Type>::type, faPatchField, areaMesh
+    >
+>
+ngrad
+(
+    const tmp<GeometricField<Type, faPatchField, areaMesh> >& tvf,
+    const word& name
+)
+{
+    tmp
+    <
+        GeometricField
+        <
+            typename outerProduct<vector, Type>::type, faPatchField, areaMesh
+        >
+    > tGrad
+    (
+        fac::ngrad(tvf(), name)
+    );
+    tvf.clear();
+    return tGrad;
+}
+
+
+template<class Type>
+tmp
+<
+    GeometricField
+    <
+        typename outerProduct<vector,Type>::type, faPatchField, areaMesh
+    >
+>
+ngrad
+(
+    const GeometricField<Type, faPatchField, areaMesh>& vf
+)
+{
+    return fac::ngrad(vf, "grad(" + vf.name() + ')');
+}
+
+
+template<class Type>
+tmp
+<
+    GeometricField
+    <
+        typename outerProduct<vector,Type>::type, faPatchField, areaMesh
+    >
+>
+ngrad
+(
+    const tmp<GeometricField<Type, faPatchField, areaMesh> >& tvf
+)
+{
+    typedef typename outerProduct<vector, Type>::type GradType;
+    tmp<GeometricField<GradType, faPatchField, areaMesh> > Grad
+    (
+        fac::ngrad(tvf())
+    );
+    tvf.clear();
+    return Grad;
+}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace fac
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// ************************************************************************* //

src/finiteArea/finiteArea/fac/facNGrad.H

@@ -0,0 +1,131 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | foam-extend: Open Source CFD
+   \\    /   O peration     | Version:     3.2
+    \\  /    A nd           | Web:         http://www.foam-extend.org
+     \\/     M anipulation  | For copyright notice see file Copyright
+-------------------------------------------------------------------------------
+License
+    This file is part of foam-extend.
+
+    foam-extend 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.
+
+    foam-extend 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 foam-extend.  If not, see <http://www.gnu.org/licenses/>.
+
+Namespace
+    fac
+
+Description
+    Calculate the gradient normal to the surface of the given field.
+
+SourceFiles
+    facGrad.C
+
+\*---------------------------------------------------------------------------*/
+
+
+#ifndef facNGrad_H
+#define facNGrad_H
+
+#include "areaFieldsFwd.H"
+#include "edgeFieldsFwd.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                     Namespace fac functions Declaration
+\*---------------------------------------------------------------------------*/
+
+namespace fac
+{
+    template<class Type>
+    tmp
+    <
+        GeometricField
+        <typename outerProduct<vector, Type>::type, faPatchField, areaMesh>
+    > ngrad
+    (
+        const GeometricField<Type, faePatchField, edgeMesh>&
+    );
+
+    template<class Type>
+    tmp
+    <
+        GeometricField
+        <typename outerProduct<vector, Type>::type, faPatchField, areaMesh>
+    > ngrad
+    (
+        const tmp<GeometricField<Type, faePatchField, edgeMesh> >&
+    );
+
+    template<class Type>
+    tmp
+    <
+        GeometricField
+        <typename outerProduct<vector, Type>::type, faPatchField, areaMesh>
+    >ngrad
+    (
+        const GeometricField<Type, faPatchField, areaMesh>&,
+        const word& name
+    );
+
+    template<class Type>
+    tmp
+    <
+        GeometricField
+        <typename outerProduct<vector, Type>::type, faPatchField, areaMesh>
+    >ngrad
+    (
+        const tmp<GeometricField<Type, faPatchField, areaMesh> >&,
+        const word& name
+    );
+
+    template<class Type>
+    tmp
+    <
+        GeometricField
+        <typename outerProduct<vector, Type>::type, faPatchField, areaMesh>
+    >ngrad
+    (
+        const GeometricField<Type, faPatchField, areaMesh>&
+    );
+
+    template<class Type>
+    tmp
+    <
+        GeometricField
+        <typename outerProduct<vector, Type>::type, faPatchField, areaMesh>
+    >ngrad
+    (
+        const tmp<GeometricField<Type, faPatchField, areaMesh> >&
+    );
+}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+#   include "facNGrad.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/finiteArea/finiteArea/fam/fam.H

@@ -43,6 +43,7 @@ SourceFiles
 #include "famDiv.H"
 #include "famLaplacian.H"
 #include "famSup.H"
+#include "famNDiv.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 

src/finiteArea/finiteArea/fam/famDiv.C

@@ -49,14 +49,36 @@ div
     const word& name
 )
 {
-    return fa::convectionScheme<Type>::New
+    const areaVectorField& n = vf.mesh().faceAreaNormals();
+
+    tmp<faMatrix<Type> > tM
     (
-        vf.mesh(),
+        fa::convectionScheme<Type>::New
-        flux,
+        (
-        vf.mesh().schemesDict().divScheme(name)
+            vf.mesh(),
-    )().famDiv(flux, vf);
+            flux,
+            vf.mesh().schemesDict().divScheme(name)
+        )().famDiv(flux, vf)
+    );
+    faMatrix<Type>& M = tM();
+
+    GeometricField<Type, faPatchField, areaMesh> v
+    (
+        fa::convectionScheme<Type>::New
+        (
+            vf.mesh(),
+            flux,
+            vf.mesh().schemesDict().divScheme(name)
+        )().facDiv(flux, vf)
+    );
+
+    //HJ Check if the product is from left or right.  HJ, 6/Dec/2016
+    M -= (v & n)*n;
+
+    return tM;
 }
 
+
 template<class Type>
 tmp<faMatrix<Type> >
 div

src/finiteArea/finiteArea/fam/famDiv.H

@@ -29,6 +29,7 @@ Description
 
 SourceFiles
     famDiv.C
+    vectorFamDiv.C
 
 \*---------------------------------------------------------------------------*/
 
@@ -89,6 +90,9 @@ namespace fam
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
+// Template specialisation
+#include "vectorFamDiv.H"
+
 #ifdef NoRepository
 #   include "famDiv.C"
 #endif

src/finiteArea/finiteArea/fam/famNDiv.C

@@ -0,0 +1,108 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | foam-extend: Open Source CFD
+   \\    /   O peration     | Version:     3.2
+    \\  /    A nd           | Web:         http://www.foam-extend.org
+     \\/     M anipulation  | For copyright notice see file Copyright
+-------------------------------------------------------------------------------
+License
+    This file is part of foam-extend.
+
+    foam-extend 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.
+
+    foam-extend 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 foam-extend.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "famNDiv.H"
+#include "faMesh.H"
+#include "faMatrix.H"
+#include "faConvectionScheme.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace fam
+{
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+template<class Type>
+tmp<faMatrix<Type> >
+ndiv
+(
+    const edgeScalarField& flux,
+    GeometricField<Type, faPatchField, areaMesh>& vf,
+    const word& name
+)
+{
+    return fa::convectionScheme<Type>::New
+    (
+        vf.mesh(),
+        flux,
+        vf.mesh().schemesDict().divScheme(name)
+    )().famDiv(flux, vf);//TODO calculate normal
+}
+
+template<class Type>
+tmp<faMatrix<Type> >
+ndiv
+(
+    const tmp<edgeScalarField>& tflux,
+    GeometricField<Type, faPatchField, areaMesh>& vf,
+    const word& name
+)
+{
+    tmp<faMatrix<Type> > Div(fam::ndiv(tflux(), vf, name));
+    tflux.clear();
+    return Div;
+}
+
+
+template<class Type>
+tmp<faMatrix<Type> >
+ndiv
+(
+    const edgeScalarField& flux,
+    GeometricField<Type, faPatchField, areaMesh>& vf
+)
+{
+    return fam::ndiv(flux, vf, "div("+flux.name()+','+vf.name()+')');
+}
+
+template<class Type>
+tmp<faMatrix<Type> >
+ndiv
+(
+    const tmp<edgeScalarField>& tflux,
+    GeometricField<Type, faPatchField, areaMesh>& vf
+)
+{
+    tmp<faMatrix<Type> > Div(fam::ndiv(tflux(), vf));
+    tflux.clear();
+    return Div;
+}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace fam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// ************************************************************************* //

src/finiteArea/finiteArea/fam/famNDiv.H

@@ -0,0 +1,100 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | foam-extend: Open Source CFD
+   \\    /   O peration     | Version:     3.2
+    \\  /    A nd           | Web:         http://www.foam-extend.org
+     \\/     M anipulation  | For copyright notice see file Copyright
+-------------------------------------------------------------------------------
+License
+    This file is part of foam-extend.
+
+    foam-extend 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.
+
+    foam-extend 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 foam-extend.  If not, see <http://www.gnu.org/licenses/>.
+
+Namespace
+    fam
+
+Description
+    Calculate the matrix for the divergence of the given field and flux.
+
+SourceFiles
+    famDiv.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef famNDiv_H
+#define famNDiv_H
+
+#include "areaFieldsFwd.H"
+#include "edgeFieldsFwd.H"
+#include "edgeInterpolationScheme.H"
+#include "faMatrix.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                     Namespace fam functions Declaration
+\*---------------------------------------------------------------------------*/
+
+namespace fam
+{
+    template<class Type>
+    tmp<faMatrix<Type> > ndiv
+    (
+        const edgeScalarField&,
+        GeometricField<Type, faPatchField, areaMesh>&,
+        const word& name
+    );
+
+    template<class Type>
+    tmp<faMatrix<Type> > ndiv
+    (
+        const tmp<edgeScalarField>&,
+        GeometricField<Type, faPatchField, areaMesh>&,
+        const word& name
+    );
+
+    template<class Type>
+    tmp<faMatrix<Type> > ndiv
+    (
+        const edgeScalarField&,
+        GeometricField<Type, faPatchField, areaMesh>&
+    );
+
+    template<class Type>
+    tmp<faMatrix<Type> > ndiv
+    (
+        const tmp<edgeScalarField>&,
+        GeometricField<Type, faPatchField, areaMesh>&
+    );
+}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+#   include "famNDiv.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/finiteArea/finiteArea/fam/vectorFamDiv.C

@@ -0,0 +1,69 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | foam-extend: Open Source CFD
+   \\    /   O peration     | Version:     4.0
+    \\  /    A nd           | Web:         http://www.foam-extend.org
+     \\/     M anipulation  | For copyright notice see file Copyright
+-------------------------------------------------------------------------------
+License
+    This file is part of foam-extend.
+
+    foam-extend 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.
+
+    foam-extend 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 foam-extend.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "vectorFamDiv.H"
+#include "faMesh.H"
+#include "faMatrix.H"
+#include "faConvectionScheme.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace fam
+{
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+template<>
+tmp<faMatrix<scalar> >
+div
+(
+    const edgeScalarField& flux,
+    const GeometricField<scalar, faPatchField, areaMesh>& vf,
+    const word& name
+)
+{
+    return fa::convectionScheme<scalar>::New
+    (
+        vf.mesh(),
+        flux,
+        vf.mesh().schemesDict().divScheme(name)
+    )().famDiv(flux, vf);
+}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace fam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// ************************************************************************* //

src/finiteArea/finiteArea/fam/vectorFamDiv.H

@@ -0,0 +1,74 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | foam-extend: Open Source CFD
+   \\    /   O peration     | Version:     4.0
+    \\  /    A nd           | Web:         http://www.foam-extend.org
+     \\/     M anipulation  | For copyright notice see file Copyright
+-------------------------------------------------------------------------------
+License
+    This file is part of foam-extend.
+
+    foam-extend 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.
+
+    foam-extend 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 foam-extend.  If not, see <http://www.gnu.org/licenses/>.
+
+Typedef
+    Foam::fam
+
+Description
+    Specialisation of fam div for a flux.
+
+SourceFiles
+    vectorFamDiv.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef vectorFamDiv_H
+#define vectorFamDiv_H
+
+#include "famDiv.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+namespace fam
+{
+
+/*---------------------------------------------------------------------------*\
+                     Namespace fam functions Declaration
+\*---------------------------------------------------------------------------*/
+
+template<>
+tmp<faMatrix<scalar> >
+div
+(
+    const edgeScalarField& flux,
+    const GeometricField<scalar, faPatchField, areaMesh>& vf,
+    const word& name
+);
+
+    
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+}
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/finiteArea/finiteArea/gradSchemes/gaussFaGrad/gaussFaGrad.C

@@ -66,12 +66,7 @@ gaussGrad<Type>::grad
 
     GeometricField<GradType, faPatchField, areaMesh>& gGrad = tgGrad();
 
-    gGrad -= vsf*fac::edgeIntegrate(vsf.mesh().Le());
+    // Removed for consistencty.  Matthias Rauter, 6/Dec/2016
-
-    // Remove component of gradient normal to surface (area)
-    const areaVectorField& n = vsf.mesh().faceAreaNormals();
-
-    gGrad -= n*(n & gGrad);
     gGrad.correctBoundaryConditions();
 
     gGrad.rename("grad(" + vsf.name() + ')');
@@ -96,15 +91,9 @@ void gaussGrad<Type>::correctBoundaryConditions
         if (!vsf.boundaryField()[patchI].coupled())
         {
             vectorField m =
-                vsf.mesh().Le().boundaryField()[patchI]
+                vsf.mesh().Le().boundaryField()[patchI]/
-                /vsf.mesh().magLe().boundaryField()[patchI];
+                vsf.mesh().magLe().boundaryField()[patchI];
 
-            // Zeljko Tukovic
-//             gGrad.boundaryField()[patchI] =
-//                 m*vsf.boundaryField()[patchI].snGrad();
-
-            //HJ Not sure: should this be a complete correction or just the
-            //   tangential part?  HJ, 24/Jul/2009
             gGrad.boundaryField()[patchI] += m*
             (
                 vsf.boundaryField()[patchI].snGrad()

src/finiteArea/finiteArea/gradSchemes/leastSquaresFaGrad/leastSquaresFaGrad.C

@@ -138,11 +138,8 @@ leastSquaresFaGrad<Type>::grad
         }
     }
 
-
     // Remove component of gradient normal to surface (area)
-    const areaVectorField& n = vsf.mesh().faceAreaNormals();
+    // Removed for consistencty.  Matthias Rauter, 6/Dec/2016
-
-    lsGrad -= n*(n & lsGrad);
     lsGrad.correctBoundaryConditions();
 
     gaussGrad<Type>::correctBoundaryConditions(vsf, lsGrad);