BUG: overset: newly created interpolated cells are not uptodate. Fixes #968.

src/overset/cellCellStencil/cellCellStencil/cellCellStencil.C

@@ -53,7 +53,8 @@ Foam::cellCellStencil::cellTypeNames_
 
 Foam::cellCellStencil::cellCellStencil(const fvMesh& mesh)
 :
-    mesh_(mesh)
+    mesh_(mesh),
+    nonInterpolatedFields_({"zoneID"})
 {}
 
 
@@ -154,6 +155,12 @@ Foam::labelList Foam::cellCellStencil::count
 }
 
 
+const Foam::wordHashSet& Foam::cellCellStencil::nonInterpolatedFields() const
+{
+    return nonInterpolatedFields_;
+}
+
+
 bool Foam::cellCellStencil::localStencil(const labelUList& slots) const
 {
     forAll(slots, i)

src/overset/cellCellStencil/cellCellStencil/cellCellStencil.H

@@ -86,6 +86,9 @@ protected:
         //- Reference to the mesh
         const fvMesh& mesh_;
 
+        //- Set of fields that should not be interpolated
+        wordHashSet nonInterpolatedFields_;
+
 
     // Protected Member Functions
 
@@ -177,6 +180,10 @@ public:
             scalarList& weights
         ) const = 0;
 
+        //- Return the names of any (stencil or mesh specific) fields that
+        //  should not be interpolated
+        virtual const wordHashSet& nonInterpolatedFields() const;
+
         //- Helper: is stencil fully local
         bool localStencil(const labelUList&) const;
 

src/overset/cellCellStencil/cellCellStencil/cellCellStencilObject.H

@@ -170,6 +170,13 @@ public:
         {
             stencilPtr_().stencilWeights(sample, donorCcs, weights);
         }
+
+        //- Return the names of any (stencil or mesh specific) fields that
+        //  should not be interpolated
+        virtual const wordHashSet& nonInterpolatedFields() const
+        {
+            return stencilPtr_().nonInterpolatedFields();
+        }
 };
 
 

src/overset/cellCellStencil/cellVolumeWeight/cellVolumeWeightCellCellStencil.C

@@ -688,6 +688,7 @@ Foam::cellCellStencils::cellVolumeWeight::cellVolumeWeight
     this->zoneID();
 
     // Read old-time cellTypes
+    nonInterpolatedFields_.insert("cellTypes");
     IOobject io
     (
         "cellTypes",

src/overset/cellCellStencil/inverseDistance/inverseDistanceCellCellStencil.C

@@ -1639,6 +1639,10 @@ Foam::cellCellStencils::inverseDistance::inverseDistance
         zeroGradientFvPatchScalarField::typeName
     )
 {
+    // Protect local fields from interpolation
+    nonInterpolatedFields_.insert("cellInterpolationWeight");
+    nonInterpolatedFields_.insert("cellTypes");
+
     // Read zoneID
     this->zoneID();
 

src/overset/dynamicOversetFvMesh/dynamicOversetFvMesh.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2014-2017 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2014-2018 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -274,6 +274,10 @@ bool Foam::dynamicOversetFvMesh::update()
         // let demand-driven lduAddr() trigger it but just to make sure.
         updateAddressing();
 
+        // Addressing and/or weights have changed. Make interpolated cells
+        // up to date with donors
+        interpolateFields();
+
         return true;
     }
 
@@ -281,6 +285,45 @@ bool Foam::dynamicOversetFvMesh::update()
 }
 
 
+Foam::word Foam::dynamicOversetFvMesh::baseName(const word& name)
+{
+    if (name.endsWith("_0"))
+    {
+        return baseName(name.substr(0, name.size()-2));
+    }
+    else
+    {
+        return name;
+    }
+}
+
+
+bool Foam::dynamicOversetFvMesh::interpolateFields()
+{
+    // Add the stencil suppression list
+    wordHashSet suppressed(Stencil::New(*this).nonInterpolatedFields());
+
+    // Use whatever the solver has set up as suppression list
+    const dictionary* dictPtr
+    (
+        this->schemesDict().subDictPtr("oversetInterpolationSuppressed")
+    );
+    if (dictPtr)
+    {
+        suppressed.insert(dictPtr->sortedToc());
+    }
+
+    interpolate<volScalarField>(suppressed);
+    interpolate<volVectorField>(suppressed);
+    interpolate<volSphericalTensorField>(suppressed);
+    interpolate<volSymmTensorField>(suppressed);
+    interpolate<volTensorField>(suppressed);
+
+    return true;
+}
+
+
+
 bool Foam::dynamicOversetFvMesh::writeObject
 (
     IOstream::streamFormat fmt,

src/overset/dynamicOversetFvMesh/dynamicOversetFvMesh.C.orig

@@ -0,0 +1,404 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2014-2017 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify i
+    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 "dynamicOversetFvMesh.H"
+#include "addToRunTimeSelectionTable.H"
+#include "cellCellStencilObject.H"
+#include "zeroGradientFvPatchFields.H"
+#include "lduPrimitiveProcessorInterface.H"
+#include "globalIndex.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(dynamicOversetFvMesh, 0);
+    addToRunTimeSelectionTable(dynamicFvMesh, dynamicOversetFvMesh, IOobject);
+}
+
+
+// * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * * * //
+
+bool Foam::dynamicOversetFvMesh::updateAddressing() const
+{
+    const cellCellStencilObject& overlap = Stencil::New(*this);
+
+    // The (processor-local part of the) stencil determines the local
+    // faces to add to the matrix. tbd: parallel
+    const labelListList& stencil = overlap.cellStencil();
+
+    // Get the base addressing
+    const lduAddressing& baseAddr = dynamicMotionSolverFvMesh::lduAddr();
+
+    // Add to the base addressing
+    labelList lowerAddr;
+    labelList upperAddr;
+    label nExtraFaces;
+
+    const globalIndex globalNumbering(baseAddr.size());
+    labelListList localFaceCells;
+    labelListList remoteFaceCells;
+
+    labelList globalCellIDs(overlap.cellInterpolationMap().constructSize());
+    forAll(baseAddr, cellI)
+    {
+        globalCellIDs[cellI] = globalNumbering.toGlobal(cellI);
+    }
+    overlap.cellInterpolationMap().distribute(globalCellIDs);
+
+
+    reverseFaceMap_ = fvMeshPrimitiveLduAddressing::addAddressing
+    (
+        baseAddr,
+        stencil,
+        nExtraFaces,
+        lowerAddr,
+        upperAddr,
+        stencilFaces_,
+        globalNumbering,
+        globalCellIDs,
+        localFaceCells,
+        remoteFaceCells
+    );
+
+    if (debug)
+    {
+        Pout<< "dynamicOversetFvMesh::update() : extended addressing from"
+            << " nFaces:" << baseAddr.lowerAddr().size()
+            << " to nFaces:" << lowerAddr.size()
+            << " nExtraFaces:" << nExtraFaces << endl;
+    }
+
+    // Extract relevant remote processors
+    labelList nbrProcs(localFaceCells.size());
+    {
+        label nbrI = 0;
+        forAll(localFaceCells, procI)
+        {
+            if (localFaceCells[procI].size())
+            {
+                //Pout<< "   from proc:" << procI
+                //    << " want its local cells " << remoteFaceCells[procI]
+                //    << " to add to my local cells:" << localFaceCells[procI]
+                //    << endl;
+                nbrProcs[nbrI++] = procI;
+            }
+        }
+        nbrProcs.setSize(nbrI);
+    }
+
+    // Construct interfaces
+    remoteStencilInterfaces_.setSize(nbrProcs.size());
+    forAll(nbrProcs, i)
+    {
+        label procI = nbrProcs[i];
+        remoteStencilInterfaces_.set
+        (
+            i,
+            new lduPrimitiveProcessorInterface
+            (
+                localFaceCells[procI],
+                Pstream::myProcNo(),
+                procI,
+                tensorField(0),
+                Pstream::msgType()
+            )
+        );
+    }
+
+
+    // Get addressing and interfaces of all interfaces
+
+
+    List<const labelUList*> patchAddr;
+    {
+        const fvBoundaryMesh& fvp = boundary();
+
+        patchAddr.setSize(fvp.size() + remoteStencilInterfaces_.size());
+
+        allInterfaces_ = dynamicMotionSolverFvMesh::interfaces();
+        allInterfaces_.setSize(patchAddr.size());
+
+        forAll(fvp, patchI)
+        {
+            patchAddr[patchI] = &fvp[patchI].faceCells();
+        }
+        forAll(remoteStencilInterfaces_, i)
+        {
+            label patchI = fvp.size()+i;
+            const lduPrimitiveProcessorInterface& pp =
+                remoteStencilInterfaces_[i];
+
+            //Pout<< "at patch:" << patchI
+            //    << " have procPatch:" << pp.type()
+            //    << " from:" << pp.myProcNo()
+            //    << " to:" << pp.neighbProcNo()
+            //    << " with fc:" << pp.faceCells().size() << endl;
+
+            patchAddr[patchI] = &pp.faceCells();
+            allInterfaces_.set(patchI, &pp);
+        }
+    }
+    const lduSchedule ps
+    (
+        lduPrimitiveMesh::nonBlockingSchedule<processorLduInterface>
+        (
+            allInterfaces_
+        )
+    );
+
+    lduPtr_.reset
+    (
+        new fvMeshPrimitiveLduAddressing
+        (
+            nCells(),
+            std::move(lowerAddr),
+            std::move(upperAddr),
+            patchAddr,
+            ps
+        )
+   );
+
+
+    // Check
+    if (debug)
+    {
+        const lduAddressing& addr = lduPtr_();  //this->lduAddr();
+
+        Pout<< "Adapted addressing:"
+            << " lower:" << addr.lowerAddr().size()
+            << " upper:" << addr.upperAddr().size() << endl;
+
+        lduInterfacePtrsList iFaces = this->interfaces();
+        // Using lduAddressing::patch
+        forAll(patchAddr, patchI)
+        {
+            Pout<< "    " << patchI << "\tpatchAddr:"
+                << addr.patchAddr(patchI).size()
+                << endl;
+        }
+
+        // Using interfaces
+        Pout<< "iFaces:" << iFaces.size() << endl;
+        forAll(iFaces, patchI)
+        {
+            if (iFaces.set(patchI))
+            {
+                Pout<< "    " << patchI << "\tiFace:" << iFaces[patchI].type()
+                        << endl;
+            }
+        }
+
+        Pout<< "end of printing." << endl;
+    }
+
+    return true;
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::dynamicOversetFvMesh::dynamicOversetFvMesh(const IOobject& io)
+:
+    dynamicMotionSolverFvMesh(io),
+    active_(false)
+{
+    // Load stencil (but do not update)
+    (void)Stencil::New(*this, false);
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::dynamicOversetFvMesh::~dynamicOversetFvMesh()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+const Foam::lduAddressing& Foam::dynamicOversetFvMesh::lduAddr() const
+{
+    if (!active_)
+    {
+        return dynamicMotionSolverFvMesh::lduAddr();
+    }
+    if (lduPtr_.empty())
+    {
+        // Build extended addressing
+        updateAddressing();
+    }
+    return *lduPtr_;
+}
+
+
+const Foam::fvMeshPrimitiveLduAddressing&
+Foam::dynamicOversetFvMesh::primitiveLduAddr() const
+{
+    if (lduPtr_.empty())
+    {
+        FatalErrorInFunction
+            << "Extended addressing not allocated" << abort(FatalError);
+    }
+
+    return *lduPtr_;
+}
+
+
+bool Foam::dynamicOversetFvMesh::update()
+{
+    if (dynamicMotionSolverFvMesh::update())
+    {
+        // Calculate the local extra faces for the interpolation. Note: could
+        // let demand-driven lduAddr() trigger it but just to make sure.
+        updateAddressing();
+
+        // This should be done when there is actually a changed in
+        // the new addressing. This sshould no update old fields.
+        interpolateFields();
+
+        return true;
+    }
+
+    return false;
+}
+
+
+bool Foam::dynamicOversetFvMesh::interpolateFields()
+{
+    {
+        auto flds(this->lookupClass<volScalarField>());
+        for (auto fldPtr : flds)
+        {
+            auto& fld = *fldPtr;
+            if
+            (
+                fld.name() != "cellMask"
+             && fld.name() != "cellMask_0"
+             && fld.name() != "interpolatedCells"
+             && fld.name() != "k_0"
+             && fld.name() != "epsilon_0"
+             && fld.name() != "alpha.water_0"
+             && fld.name() != "rho_0"
+            )
+            {
+                Pout << "Interpolating : " << fld.name() << endl;
+                interpolate(fld.primitiveFieldRef());
+            }
+        }
+    }
+
+    {
+        auto flds(this->lookupClass<volVectorField>());
+        for (auto fldPtr : flds)
+        {
+            auto& fld = *fldPtr;
+            if
+            (
+                fld.name() != "cellDisplacement"
+             && fld.name() != "U_0"
+            )
+            {
+                Pout << "Interpolating : " << fld.name() << endl;
+                interpolate(fld.primitiveFieldRef());
+            }
+        }
+    }
+
+    return true;
+}
+
+
+
+bool Foam::dynamicOversetFvMesh::writeObject
+(
+    IOstream::streamFormat fmt,
+    IOstream::versionNumber ver,
+    IOstream::compressionType cmp,
+    const bool valid
+) const
+{
+    bool ok = dynamicMotionSolverFvMesh::writeObject(fmt, ver, cmp, valid);
+
+    // For postprocessing : write cellTypes and zoneID
+    {
+        const cellCellStencilObject& overlap = Stencil::New(*this);
+
+        const labelUList& cellTypes = overlap.cellTypes();
+
+        volScalarField volTypes
+        (
+            IOobject
+            (
+                "cellTypes",
+                this->time().timeName(),
+                *this,
+                IOobject::NO_READ,
+                IOobject::NO_WRITE,
+                false
+            ),
+            *this,
+            dimensionedScalar(dimless, Zero),
+            zeroGradientFvPatchScalarField::typeName
+        );
+
+        forAll(volTypes.internalField(), cellI)
+        {
+            volTypes[cellI] = cellTypes[cellI];
+        }
+        volTypes.correctBoundaryConditions();
+        volTypes.writeObject(fmt, ver, cmp, valid);
+    }
+    {
+        volScalarField volZoneID
+        (
+            IOobject
+            (
+                "zoneID",
+                this->time().timeName(),
+                *this,
+                IOobject::NO_READ,
+                IOobject::NO_WRITE,
+                false
+            ),
+            *this,
+            dimensionedScalar(dimless, Zero),
+            zeroGradientFvPatchScalarField::typeName
+        );
+
+        const cellCellStencilObject& overlap = Stencil::New(*this);
+        const labelIOList& zoneID = overlap.zoneID();
+
+        forAll(zoneID, cellI)
+        {
+            volZoneID[cellI] = zoneID[cellI];
+        }
+        volZoneID.correctBoundaryConditions();
+        volZoneID.writeObject(fmt, ver, cmp, valid);
+    }
+    return ok;
+}
+
+
+// ************************************************************************* //

src/overset/dynamicOversetFvMesh/dynamicOversetFvMesh.H

@@ -102,6 +102,14 @@ protected:
         template<class GeoField>
         void interpolate(GeoField& psi) const;
 
+        //- Helper: strip off trailing _0
+        static word baseName(const word& name);
+
+        //- Explicit interpolation of all registered fields. Excludes
+        //  selected fields (and their old-time fields)
+        template<class GeoField>
+        void interpolate(const wordHashSet& suppressed);
+
         //- Freeze values at holes
         template<class Type>
         void freezeHoles(fvMatrix<Type>&) const;
@@ -299,6 +307,9 @@ public:
         //- Update the mesh for both mesh motion and topology change
         virtual bool update();
 
+        //- Update fields when mesh is updated
+        virtual bool interpolateFields();
+
         //- Write using given format, version and compression
         virtual bool writeObject
         (

src/overset/dynamicOversetFvMesh/dynamicOversetFvMesh.H.orig

@@ -0,0 +1,331 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2015-2017 OpenCFD Ltd.
+     \\/     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::dynamicOversetFvMesh
+
+Description
+    dynamicFvMesh with support for overset meshes.
+
+SourceFiles
+    dynamicOversetFvMesh.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef dynamicOversetFvMesh_H
+#define dynamicOversetFvMesh_H
+
+#include "dynamicMotionSolverFvMesh.H"
+#include "labelIOList.H"
+#include "fvMeshPrimitiveLduAddressing.H"
+#include "lduInterfaceFieldPtrsList.H"
+#include "volFields.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+class mapDistribute;
+class lduPrimitiveProcessorInterface;
+
+/*---------------------------------------------------------------------------*\
+                   Class dynamicOversetFvMesh Declaration
+\*---------------------------------------------------------------------------*/
+
+class dynamicOversetFvMesh
+:
+    public dynamicMotionSolverFvMesh
+{
+protected:
+
+    // Protected data
+
+        //- Select base addressing (false) or locally stored extended
+        //  lduAddressing (true)
+        mutable bool active_;
+
+        //- Extended addressing (extended with local interpolation stencils)
+        mutable autoPtr<fvMeshPrimitiveLduAddressing> lduPtr_;
+
+        //- Added (processor)lduInterfaces for remote bits of stencil.
+        //PtrList<const lduInterface> remoteStencilInterfaces_;
+        mutable PtrList<const lduPrimitiveProcessorInterface>
+            remoteStencilInterfaces_;
+
+        //- Interfaces for above mesh. Contains both original and
+        //  above added processorLduInterfaces
+        mutable lduInterfacePtrsList allInterfaces_;
+
+        //- Corresponding faces (in above lduPtr) to the stencil
+        mutable labelListList stencilFaces_;
+
+        //- From old to new face labels
+        mutable labelList reverseFaceMap_;
+
+
+   // Protected Member Functions
+
+        //- Calculate the extended lduAddressing
+        virtual bool updateAddressing() const;
+
+        //- Debug: print matrix
+        template<class Type>
+        void write(Ostream&, const fvMatrix<Type>&, const lduAddressing&) const;
+
+        //- Explicit interpolation of acceptor cells from donor cells
+        template<class T>
+        void interpolate(Field<T>& psi) const;
+
+        //- Explicit interpolation of acceptor cells from donor cells with
+        //  boundary condition handling
+        template<class GeoField>
+        void interpolate(GeoField& psi) const;
+
+        //- Freeze values at holes
+        template<class Type>
+        void freezeHoles(fvMatrix<Type>&) const;
+
+        //- Get scalar interfaces of certain type
+        template<class GeoField, class PatchType>
+        lduInterfaceFieldPtrsList scalarInterfaces(const GeoField& psi) const;
+
+        //- Add interpolation to matrix (coefficients)
+        template<class Type>
+        void addInterpolation(fvMatrix<Type>&) const;
+
+        //- Solve given dictionary with settings
+        template<class Type>
+        SolverPerformance<Type> solve(fvMatrix<Type>&, const dictionary&) const;
+
+        //- Debug: correct coupled bc
+        template<class GeoField>
+        static void correctCoupledBoundaryConditions(GeoField& fld);
+
+
+private:
+
+    // Private Member Functions
+
+        //- No copy construct
+        dynamicOversetFvMesh(const dynamicOversetFvMesh&) = delete;
+
+        //- No copy assignment
+        void operator=(const dynamicOversetFvMesh&) = delete;
+
+
+public:
+
+    //- Runtime type information
+    TypeName("dynamicOversetFvMesh");
+
+
+    // Constructors
+
+        //- Construct from IOobject
+        dynamicOversetFvMesh(const IOobject& io);
+
+
+    //- Destructor
+    virtual ~dynamicOversetFvMesh();
+
+
+    // Member Functions
+
+
+        // Extended addressing
+
+            //- Return extended ldu addressing
+            const fvMeshPrimitiveLduAddressing& primitiveLduAddr() const;
+
+            //- Return ldu addressing. If active: is (extended)
+            //  primitiveLduAddr
+            virtual const lduAddressing& lduAddr() const;
+
+            //- Return old to new face addressing
+            const labelList& reverseFaceMap() const
+            {
+                return reverseFaceMap_;
+            }
+
+            //- Return true if using extended addressing
+            bool active() const
+            {
+                return active_;
+            }
+
+            //- Enable/disable extended addressing
+            void active(const bool f) const
+            {
+                active_ = f;
+
+                if (active_)
+                {
+                    DebugInfo<< "Switching to extended addressing with nFaces:"
+                        << primitiveLduAddr().lowerAddr().size()
+                        << endl;
+                }
+                else
+                {
+                    DebugInfo<< "Switching to base addressing with nFaces:"
+                        << fvMesh::lduAddr().lowerAddr().size()
+                        << endl;
+                }
+            }
+
+
+        // Overset
+
+            // Explicit interpolation
+
+                virtual void interpolate(scalarField& psi) const
+                {
+                    interpolate<scalar>(psi);
+                }
+
+                virtual void interpolate(vectorField& psi) const
+                {
+                    interpolate<vector>(psi);
+                }
+
+                virtual void interpolate(sphericalTensorField& psi) const
+                {
+                    interpolate<sphericalTensor>(psi);
+                }
+
+                virtual void interpolate(symmTensorField& psi) const
+                {
+                    interpolate<symmTensor>(psi);
+                }
+
+                virtual void interpolate(tensorField& psi) const
+                {
+                    interpolate<tensor>(psi);
+                }
+
+                virtual void interpolate(volScalarField& psi) const
+                {
+                    interpolate<volScalarField>(psi);
+                }
+
+                virtual void interpolate(volVectorField& psi) const
+                {
+                    interpolate<volVectorField>(psi);
+                }
+
+                virtual void interpolate(volSphericalTensorField& psi) const
+                {
+                    interpolate<volSphericalTensorField>(psi);
+                }
+
+                virtual void interpolate(volSymmTensorField& psi) const
+                {
+                    interpolate<volSymmTensorField>(psi);
+                }
+
+                virtual void interpolate(volTensorField& psi) const
+                {
+                    interpolate<volTensorField>(psi);
+                }
+
+
+            // Implicit interpolation (matrix manipulation)
+
+                //- Solve returning the solution statistics given convergence
+                //  tolerance. Use the given solver controls
+                virtual SolverPerformance<scalar> solve
+                (
+                    fvMatrix<scalar>& m,
+                    const dictionary& dict
+                ) const
+                {
+                    return solve<scalar>(m, dict);
+                }
+
+                //- Solve returning the solution statistics given convergence
+                //  tolerance. Use the given solver controls
+                virtual SolverPerformance<vector> solve
+                (
+                    fvMatrix<vector>& m,
+                    const dictionary& dict
+                ) const
+                {
+                    return solve<vector>(m, dict);
+                }
+
+                //- Solve returning the solution statistics given convergence
+                //  tolerance. Use the given solver controls
+                virtual SolverPerformance<symmTensor> solve
+                (
+                    fvMatrix<symmTensor>& m,
+                    const dictionary& dict
+                ) const
+                {
+                    return solve<symmTensor>(m, dict);
+                }
+
+                //- Solve returning the solution statistics given convergence
+                //  tolerance. Use the given solver controls
+                virtual SolverPerformance<tensor> solve
+                (
+                    fvMatrix<tensor>& m,
+                    const dictionary& dict
+                ) const
+                {
+                    return solve<tensor>(m, dict);
+                }
+
+
+        //- Update the mesh for both mesh motion and topology change
+        virtual bool update();
+
+        //- Write using given format, version and compression
+        virtual bool writeObject
+        (
+            IOstream::streamFormat,
+            IOstream::versionNumber,
+            IOstream::compressionType,
+            const bool valid
+        ) const;
+
+        //- Debug: check halo swap is ok
+        template<class GeoField>
+        static void checkCoupledBC(const GeoField& fld);
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+#   include "dynamicOversetFvMeshTemplates.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/overset/dynamicOversetFvMesh/dynamicOversetFvMeshTemplates.C

@@ -78,6 +78,34 @@ void Foam::dynamicOversetFvMesh::interpolate(GeoField& psi) const
 }
 
 
+template<class GeoField>
+void Foam::dynamicOversetFvMesh::interpolate(const wordHashSet& suppressed)
+{
+    auto flds(this->lookupClass<GeoField>());
+    for (auto fldPtr : flds)
+    {
+        const word& name = fldPtr->name();
+        if (!suppressed.found(baseName(name)))
+        {
+            if (debug)
+            {
+                Pout<< "dynamicOversetFvMesh::interpolate: interpolating : "
+                    << name << endl;
+            }
+            interpolate(fldPtr->primitiveFieldRef());
+        }
+        else
+        {
+            if (debug)
+            {
+                Pout<< "dynamicOversetFvMesh::interpolate: skipping : " << name
+                    << endl;
+            }
+        }
+    }
+}
+
+
 template<class GeoField, class PatchType>
 Foam::lduInterfaceFieldPtrsList
 Foam::dynamicOversetFvMesh::scalarInterfaces(const GeoField& psi) const

src/overset/oversetPolyPatch/oversetFvPatchField.C

@@ -115,15 +115,46 @@ void Foam::oversetFvPatchField<Type>::initEvaluate
         else if
         (
            !fvSchemes.found("oversetInterpolation")
-        || !fvSchemes.found("oversetInterpolationRequired")
+         || (
+               fvSchemes.found("oversetInterpolationRequired")
+            == fvSchemes.found("oversetInterpolationSuppressed")
+            )
         )
         {
             IOWarningInFunction(fvSchemes)
                 << "Missing required dictionary entries"
                 << " 'oversetInterpolation' and 'oversetInterpolationRequired'"
+                << " or 'oversetInterpolationSuppressed'"
                 << ". Skipping overset interpolation for field "
                 << fldName << endl;
         }
+        else if (fvSchemes.found("oversetInterpolationSuppressed"))
+        {
+            const dictionary& intDict = fvSchemes.subDict
+            (
+                "oversetInterpolationSuppressed"
+            );
+            if (!intDict.found(fldName))
+            {
+                if (debug)
+                {
+                    Info<< "Interpolating non-suppressed field " << fldName
+                        << endl;
+                }
+                mesh.interpolate
+                (
+                    const_cast<Field<Type>&>
+                    (
+                        this->primitiveField()
+                    )
+                );
+            }
+            else if (debug)
+            {
+                Info<< "Skipping suppressed overset interpolation for field "
+                    << fldName << endl;
+            }
+        }
         else
         {
             const dictionary& intDict = fvSchemes.subDict