linearUpwind: Specialize for volVectorField to support cached gradients

src/finiteVolume/interpolation/surfaceInterpolation/schemes/linearUpwind/linearUpwind.C

@@ -65,6 +65,15 @@ Foam::linearUpwind<Type>::correction
     const volVectorField& C = mesh.C();
     const surfaceVectorField& Cf = mesh.Cf();
 
+    tmp<fv::gradScheme<scalar>> gradScheme_
+    (
+        fv::gradScheme<scalar>::New
+        (
+            mesh,
+            mesh.gradScheme(gradSchemeName_)
+        )
+    );
+
     for (direction cmpt = 0; cmpt < pTraits<Type>::nComponents; cmpt++)
     {
         tmp<volVectorField> tgradVf =
@@ -133,6 +142,121 @@ Foam::linearUpwind<Type>::correction
 }
 
 
+template<>
+Foam::tmp<Foam::surfaceVectorField>
+Foam::linearUpwind<Foam::vector>::correction
+(
+    const volVectorField& vf
+) const
+{
+    const fvMesh& mesh = this->mesh();
+
+    tmp<GeometricField<vector, fvsPatchField, surfaceMesh>> tsfCorr
+    (
+        new GeometricField<vector, fvsPatchField, surfaceMesh>
+        (
+            IOobject
+            (
+                "linearUpwind::correction(" + vf.name() + ')',
+                mesh.time().timeName(),
+                mesh,
+                IOobject::NO_READ,
+                IOobject::NO_WRITE,
+                false
+            ),
+            mesh,
+            dimensioned<vector>(vf.name(), vf.dimensions(), Zero)
+        )
+    );
+
+    GeometricField<vector, fvsPatchField, surfaceMesh>& sfCorr = tsfCorr.ref();
+
+    const surfaceScalarField& faceFlux = this->faceFlux_;
+
+    const labelList& owner = mesh.owner();
+    const labelList& neighbour = mesh.neighbour();
+
+    const volVectorField& C = mesh.C();
+    const surfaceVectorField& Cf = mesh.Cf();
+
+    tmp<fv::gradScheme<vector>> gradScheme_
+    (
+        fv::gradScheme<vector>::New
+        (
+            mesh,
+            mesh.gradScheme(gradSchemeName_)
+        )
+    );
+
+    tmp
+    <
+        GeometricField
+        <
+            typename outerProduct<vector, vector>::type,
+            fvPatchField,
+            volMesh
+        >
+    > tgradVf = gradScheme_().grad(vf, gradSchemeName_);
+
+    const GeometricField
+    <
+        typename outerProduct<vector, vector>::type,
+        fvPatchField,
+        volMesh
+    >& gradVf = tgradVf();
+
+    forAll(faceFlux, facei)
+    {
+        label celli = (faceFlux[facei] > 0) ? owner[facei] : neighbour[facei];
+        sfCorr[facei] = (Cf[facei] - C[celli]) & gradVf[celli];
+    }
+
+
+    typename GeometricField<vector, fvsPatchField, surfaceMesh>::
+        Boundary& bSfCorr = sfCorr.boundaryFieldRef();
+
+    forAll(bSfCorr, patchi)
+    {
+        fvsPatchField<vector>& pSfCorr = bSfCorr[patchi];
+
+        if (pSfCorr.coupled())
+        {
+            const labelUList& pOwner =
+                mesh.boundary()[patchi].faceCells();
+
+            const vectorField& pCf = Cf.boundaryField()[patchi];
+
+            const scalarField& pFaceFlux = faceFlux.boundaryField()[patchi];
+
+            const Field<typename outerProduct<vector, vector>::type> pGradVfNei
+            (
+                gradVf.boundaryField()[patchi].patchNeighbourField()
+            );
+
+            // Build the d-vectors
+            vectorField pd(Cf.boundaryField()[patchi].patch().delta());
+
+            forAll(pOwner, facei)
+            {
+                label own = pOwner[facei];
+
+                if (pFaceFlux[facei] > 0)
+                {
+                    pSfCorr[facei] = (pCf[facei] - C[own]) & gradVf[own];
+                }
+                else
+                {
+                    pSfCorr[facei] =
+                        (pCf[facei] - pd[facei] - C[own]) & pGradVfNei[facei];
+                }
+            }
+        }
+    }
+
+    return tsfCorr;
+}
+
+
 namespace Foam
 {
     makelimitedSurfaceInterpolationScheme(linearUpwind)

src/finiteVolume/interpolation/surfaceInterpolation/schemes/linearUpwind/linearUpwind.H

@@ -57,7 +57,6 @@ class linearUpwind
     // Private Data
 
         word gradSchemeName_;
-        tmp<fv::gradScheme<scalar>> gradScheme_;
 
 
     // Private Member Functions
@@ -85,11 +84,7 @@ public:
         )
         :
             upwind<Type>(mesh, faceFlux),
-            gradSchemeName_("grad"),
-            gradScheme_
-            (
-                new fv::gaussGrad<scalar>(mesh)
-            )
+            gradSchemeName_("grad")
         {}
 
         //- Construct from Istream.
@@ -102,15 +97,7 @@ public:
         )
         :
             upwind<Type>(mesh, schemeData),
-            gradSchemeName_(schemeData),
-            gradScheme_
-            (
-                fv::gradScheme<scalar>::New
-                (
-                    mesh,
-                    mesh.gradScheme(gradSchemeName_)
-                )
-            )
+            gradSchemeName_(schemeData)
         {}
 
         //- Construct from faceFlux and Istream
@@ -122,15 +109,7 @@ public:
         )
         :
             upwind<Type>(mesh, faceFlux, schemeData),
-            gradSchemeName_(schemeData),
-            gradScheme_
-            (
-                fv::gradScheme<scalar>::New
-                (
-                    mesh,
-                    mesh.gradScheme(gradSchemeName_)
-                )
-            )
+            gradSchemeName_(schemeData)
         {}
 
 
@@ -151,6 +130,14 @@ public:
 };
 
 
+// Specialize for volVectorField to support cached gradients
+template<>
+tmp<surfaceVectorField> linearUpwind<vector>::correction
+(
+    const volVectorField& vf
+) const;
+
+
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 } // End namespace Foam