diff --git a/src/MomentumTransportModels/momentumTransportModels/LES/LESdeltas/vanDriestDelta/vanDriestDelta.C b/src/MomentumTransportModels/momentumTransportModels/LES/LESdeltas/vanDriestDelta/vanDriestDelta.C
index 3eb3d84f38..5d482ac9ef 100644
--- a/src/MomentumTransportModels/momentumTransportModels/LES/LESdeltas/vanDriestDelta/vanDriestDelta.C
+++ b/src/MomentumTransportModels/momentumTransportModels/LES/LESdeltas/vanDriestDelta/vanDriestDelta.C
@@ -26,7 +26,7 @@ License
 #include "vanDriestDelta.H"
 #include "wallFvPatch.H"
 #include "fvPatchDistWave.H"
-#include "fvWallPointYPlus.H"
+#include "FvWallInfoYPlus.H"
 #include "addToRunTimeSelectionTable.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
@@ -51,11 +51,11 @@ void Foam::LESModels::vanDriestDelta::calcDelta()
     const volScalarField& nu = tnu();
     tmp<volScalarField> nuSgs = momentumTransportModel_.nut();
 
-    volScalarField ystar
+    volScalarField yStar
     (
         IOobject
         (
-            "ystar",
+            "yStar",
             mesh.time().constant(),
             mesh
         ),
@@ -64,7 +64,7 @@ void Foam::LESModels::vanDriestDelta::calcDelta()
     );
 
     const fvPatchList& patches = mesh.boundary();
-    volScalarField::Boundary& ystarBf = ystar.boundaryFieldRef();
+    volScalarField::Boundary& yStarBf = yStar.boundaryFieldRef();
 
     forAll(patches, patchi)
     {
@@ -74,32 +74,33 @@ void Foam::LESModels::vanDriestDelta::calcDelta()
             const scalarField& nuw = nu.boundaryField()[patchi];
             const scalarField& nuSgsw = nuSgs().boundaryField()[patchi];
 
-            ystarBf[patchi] =
+            yStarBf[patchi] =
                 nuw/sqrt((nuw + nuSgsw)*mag(Uw.snGrad()) + vSmall);
         }
     }
 
-    fvWallPointYPlus::trackData td;
-    td.yPlusCutOff = yPlusCutOff_;
     volScalarField y
     (
         volScalarField::New("y", mesh, dimensionedScalar(dimLength, great))
     );
-    fvPatchDistWave::wave<fvWallPointYPlus, fvWallPointYPlus::trackData>
+
+    FvWallInfoYPlus<wallPoint>::trackData td;
+    td.yPlusCutOff = yPlusCutOff_;
+
+    fvPatchDistWave::calculateAndCorrect<FvWallInfoYPlus>
     (
         mesh,
         mesh.boundaryMesh().findPatchIDs<wallPolyPatch>(),
-        ystar.boundaryField(),
+        2, // <-- roughly equivalent to old point-cell corrections
         y,
-        ystar,
-        true,
+        yStar,
         td
     );
 
     delta_ = min
     (
         static_cast<const volScalarField&>(geometricDelta_()),
-        (kappa_/Cdelta_)*((scalar(1) + small) - exp(-y/ystar/Aplus_))*y
+        (kappa_/Cdelta_)*((scalar(1) + small) - exp(-y/yStar/Aplus_))*y
     );
 }
 
diff --git a/src/finiteVolume/Make/files b/src/finiteVolume/Make/files
index 4c941ac8cc..00cb4c9f63 100644
--- a/src/finiteVolume/Make/files
+++ b/src/finiteVolume/Make/files
@@ -46,6 +46,7 @@ $(meshWave)/FvFaceCellWaveName.C
 
 
 wallDist = fvMesh/wallDist
+$(wallDist)/fvPatchDistWave/fvPatchDistWave.C
 $(wallDist)/nearWallDist/nearWallDist.C
 $(wallDist)/wallDist/wallDist.C
 $(wallDist)/patchDistMethods/patchDistMethod/patchDistMethod.C
diff --git a/src/finiteVolume/fvMesh/wallDist/fvWallPoint/fvWallPoint.H b/src/finiteVolume/fvMesh/wallDist/FvWallInfo/FvWallInfo.H
similarity index 77%
rename from src/finiteVolume/fvMesh/wallDist/fvWallPoint/fvWallPoint.H
rename to src/finiteVolume/fvMesh/wallDist/FvWallInfo/FvWallInfo.H
index 1d3445bbc9..dc3abc3ebf 100644
--- a/src/finiteVolume/fvMesh/wallDist/fvWallPoint/fvWallPoint.H
+++ b/src/finiteVolume/fvMesh/wallDist/FvWallInfo/FvWallInfo.H
@@ -22,22 +22,22 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Class
-    Foam::fvWallPoint
+    Foam::FvWallInfo
 
 Description
     Holds information regarding nearest wall point. Used in wall distance
     calculation.
 
 SourceFiles
-    fvWallPointI.H
-    fvWallPoint.C
+    FvWallInfoI.H
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef fvWallPoint_H
-#define fvWallPoint_H
+#ifndef FvWallInfo_H
+#define FvWallInfo_H
 
 #include "wallPoint.H"
+#include "wallFace.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -49,21 +49,21 @@ class fvPatch;
 class fvMesh;
 class transformer;
 
-
 /*---------------------------------------------------------------------------*\
-                          Class fvWallPoint Declaration
+                          Class FvWallInfoBase Declaration
 \*---------------------------------------------------------------------------*/
 
-class fvWallPoint
+template<class WallInfo, class Derived>
+class FvWallInfoBase
 :
-    public wallPoint
+    public WallInfo::template type<Derived>
 {
 public:
 
     // Constructors
 
         //- Inherit constructors
-        using wallPoint::wallPoint;
+        using WallInfo::template type<Derived>::type;
 
 
     // Member Functions
@@ -87,7 +87,7 @@ public:
                 const fvMesh&,
                 const label thisCelli,
                 const labelPair& neighbourPatchAndFacei,
-                const fvWallPoint& neighbourInfo,
+                const FvWallInfoBase<WallInfo, Derived>& neighbourInfo,
                 const scalar tol,
                 TrackingData& td
             );
@@ -99,7 +99,7 @@ public:
                 const fvMesh&,
                 const labelPair& thisPatchAndFacei,
                 const label neighbourCelli,
-                const fvWallPoint& neighbourInfo,
+                const FvWallInfoBase<WallInfo, Derived>& neighbourInfo,
                 const scalar tol,
                 TrackingData& td
             );
@@ -110,19 +110,27 @@ public:
             (
                 const fvMesh&,
                 const labelPair& thisPatchAndFacei,
-                const fvWallPoint& neighbourInfo,
+                const FvWallInfoBase<WallInfo, Derived>& neighbourInfo,
                 const scalar tol,
                 TrackingData& td
             );
 };
 
+/*---------------------------------------------------------------------------*\
+                          Class FvWallInfo Declaration
+\*---------------------------------------------------------------------------*/
 
-//- Data associated with fvWallPoint type are contiguous
-template<>
-inline bool contiguous<fvWallPoint>()
+template<class WallInfo>
+class FvWallInfo
+:
+    public FvWallInfoBase<WallInfo, FvWallInfo<WallInfo>>
 {
-    return true;
-}
+    public:
+
+        using
+            FvWallInfoBase<WallInfo, FvWallInfo<WallInfo>>::
+            FvWallInfoBase;
+};
 
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@@ -131,7 +139,7 @@ inline bool contiguous<fvWallPoint>()
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-#include "fvWallPointI.H"
+#include "FvWallInfoI.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
diff --git a/src/finiteVolume/fvMesh/wallDist/FvWallInfo/FvWallInfoData.H b/src/finiteVolume/fvMesh/wallDist/FvWallInfo/FvWallInfoData.H
new file mode 100644
index 0000000000..b9b778eee8
--- /dev/null
+++ b/src/finiteVolume/fvMesh/wallDist/FvWallInfo/FvWallInfoData.H
@@ -0,0 +1,208 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::FvWallInfoData
+
+Description
+    Holds information (coordinate and normal) regarding nearest wall point.
+
+    Is like FvWallInfo but transfer extra (passive) data.
+    Used e.g. in wall distance calculation with wall reflection vectors.
+
+SourceFiles
+    FvWallInfoDataI.H
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef FvWallInfoData_H
+#define FvWallInfoData_H
+
+#include "FvWallInfo.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// Forward declaration of friend functions and operators
+template<class WallInfo, class Type, class Derived>
+class FvWallInfoDataBase;
+
+template<class WallInfo, class Type, class Derived>
+Istream& operator>>
+(
+    Istream&,
+    FvWallInfoDataBase<WallInfo, Type, Derived>&
+);
+
+template<class WallInfo, class Type, class Derived>
+Ostream& operator<<
+(
+    Ostream&,
+    const FvWallInfoDataBase<WallInfo, Type, Derived>&
+);
+
+
+/*---------------------------------------------------------------------------*\
+                        Class FvWallInfoDataBase Declaration
+\*---------------------------------------------------------------------------*/
+
+template<class WallInfo, class Type, class Derived>
+class FvWallInfoDataBase
+:
+    public FvWallInfoBase<WallInfo, Derived>
+{
+    // Private Data
+
+        //- Data at nearest wall center
+        Type data_;
+
+
+protected:
+
+    // Protected Member Functions
+
+        //- Evaluate distance to point. Update distSqr, origin from whomever
+        //  is nearer pt. Return true if w2 is closer to point.
+        template<class TrackingData>
+        inline bool update
+        (
+            const point&,
+            const FvWallInfoDataBase<WallInfo, Type, Derived>& w2,
+            const scalar tol,
+            TrackingData& td
+        );
+
+
+public:
+
+    friend class FvWallInfoBase<WallInfo, Derived>;
+
+
+    typedef Type dataType;
+
+
+    // Constructors
+
+        //- Construct null
+        inline FvWallInfoDataBase();
+
+        //- Construct from data and other geometry
+        template<class ... Geometry>
+        inline FvWallInfoDataBase
+        (
+            const Type& data,
+            const Geometry& ... geometry
+        );
+
+
+    // Member Functions
+
+        // Access
+
+            inline const Type& data() const;
+
+            inline Type& data();
+
+            template<class TrackingData>
+            inline const Type& data(TrackingData& td) const;
+
+
+        // Needed by meshWave
+
+            //- Transform across an interface
+            template<class TrackingData>
+            inline void transform
+            (
+                const fvPatch& patch,
+                const label patchFacei,
+                const transformer& transform,
+                TrackingData& td
+            );
+
+
+    // IOstream Operators
+
+        friend Ostream& operator<< <WallInfo, Type, Derived>
+        (
+            Ostream&,
+            const FvWallInfoDataBase<WallInfo, Type, Derived>&
+        );
+
+        friend Istream& operator>> <WallInfo, Type, Derived>
+        (
+            Istream&,
+            FvWallInfoDataBase<WallInfo, Type, Derived>&
+        );
+};
+
+
+/*---------------------------------------------------------------------------*\
+                        Class FvWallInfoData Declaration
+\*---------------------------------------------------------------------------*/
+
+template<class WallInfo, class Type>
+class FvWallInfoData
+:
+    public FvWallInfoDataBase<WallInfo, Type, FvWallInfoData<WallInfo, Type>>
+{
+    public:
+
+        using
+            FvWallInfoDataBase<WallInfo, Type, FvWallInfoData<WallInfo, Type>>::
+            FvWallInfoDataBase;
+};
+
+
+#define DefineFvWallInfoType(Type, nullArg)                                    \
+                                                                               \
+    template<class WallInfo>                                                   \
+    using CAT(FvWallInfo, CAPITALIZE(Type)) = FvWallInfoData<WallInfo, Type>;  \
+                                                                               \
+    template<>                                                                 \
+    inline bool contiguous<CAT(FvWallInfo, CAPITALIZE(Type))<wallPoint>>()     \
+    {                                                                          \
+        return contiguous<FvWallInfo<wallPoint>>();                            \
+    }
+
+DefineFvWallInfoType(bool, nullArg)
+DefineFvWallInfoType(label, nullArg)
+FOR_ALL_FIELD_TYPES(DefineFvWallInfoType);
+
+#undef DefineFvWallInfoType
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#include "FvWallInfoDataI.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/finiteVolume/fvMesh/wallDist/FvWallInfo/FvWallInfoDataI.H b/src/finiteVolume/fvMesh/wallDist/FvWallInfo/FvWallInfoDataI.H
new file mode 100644
index 0000000000..63a7a26dc1
--- /dev/null
+++ b/src/finiteVolume/fvMesh/wallDist/FvWallInfo/FvWallInfoDataI.H
@@ -0,0 +1,153 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "FvWallInfoData.H"
+
+// * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
+
+template<class WallInfo, class Type, class Derived>
+template<class TrackingData>
+inline bool Foam::FvWallInfoDataBase<WallInfo, Type, Derived>::update
+(
+    const point& pt,
+    const FvWallInfoDataBase<WallInfo, Type, Derived>& w2,
+    const scalar tol,
+    TrackingData& td
+)
+{
+    const bool result =
+        FvWallInfoBase<WallInfo, Derived>::update(pt, w2, tol, td);
+
+    if (result)
+    {
+        data_ = w2.data();
+    }
+
+    return result;
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+template<class WallInfo, class Type, class Derived>
+inline Foam::FvWallInfoDataBase<WallInfo, Type, Derived>::FvWallInfoDataBase()
+:
+    FvWallInfoBase<WallInfo, Derived>(),
+    data_()
+{}
+
+
+template<class WallInfo, class Type, class Derived>
+template<class ... Geometry>
+inline Foam::FvWallInfoDataBase<WallInfo, Type, Derived>::FvWallInfoDataBase
+(
+    const Type& data,
+    const Geometry& ... geometry
+)
+:
+    FvWallInfoBase<WallInfo, Derived>(geometry ...),
+    data_(data)
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+template<class WallInfo, class Type, class Derived>
+inline const Type&
+Foam::FvWallInfoDataBase<WallInfo, Type, Derived>::data() const
+{
+    return data_;
+}
+
+
+template<class WallInfo, class Type, class Derived>
+inline Type&
+Foam::FvWallInfoDataBase<WallInfo, Type, Derived>::data()
+{
+    return data_;
+}
+
+
+template<class WallInfo, class Type, class Derived>
+template<class TrackingData>
+inline const Type&
+Foam::FvWallInfoDataBase<WallInfo, Type, Derived>::data(TrackingData& td) const
+{
+    return data_;
+}
+
+
+template<class WallInfo, class Type, class Derived>
+template<class TrackingData>
+inline void Foam::FvWallInfoDataBase<WallInfo, Type, Derived>::transform
+(
+    const fvPatch& patch,
+    const label patchFacei,
+    const transformer& transform,
+    TrackingData& td
+)
+{
+    FvWallInfoBase<WallInfo, Derived>::transform
+    (
+        patch,
+        patchFacei,
+        transform,
+        td
+    );
+
+    data_ = transform.transform(data_);
+}
+
+
+// * * * * * * * * * * * * * * * Friend Operators  * * * * * * * * * * * * * //
+
+template<class WallInfo, class Type, class Derived>
+Foam::Ostream& Foam::operator<<
+(
+    Ostream& os,
+    const FvWallInfoDataBase<WallInfo, Type, Derived>& w
+)
+{
+    return os
+        << static_cast<const FvWallInfoBase<WallInfo, Derived>&>(w)
+        << token::SPACE
+        << w.data();
+}
+
+
+template<class WallInfo, class Type, class Derived>
+Foam::Istream& Foam::operator>>
+(
+    Istream& is,
+    FvWallInfoDataBase<WallInfo, Type, Derived>& w
+)
+{
+    return is
+        >> static_cast<FvWallInfoBase<WallInfo, Derived>&>(w)
+        >> w.data_;
+}
+
+
+// ************************************************************************* //
diff --git a/src/finiteVolume/fvMesh/wallDist/fvWallPoint/fvWallPointI.H b/src/finiteVolume/fvMesh/wallDist/FvWallInfo/FvWallInfoI.H
similarity index 72%
rename from src/finiteVolume/fvMesh/wallDist/fvWallPoint/fvWallPointI.H
rename to src/finiteVolume/fvMesh/wallDist/FvWallInfo/FvWallInfoI.H
index 2d496081a5..78b307b3a0 100644
--- a/src/finiteVolume/fvMesh/wallDist/fvWallPoint/fvWallPointI.H
+++ b/src/finiteVolume/fvMesh/wallDist/FvWallInfo/FvWallInfoI.H
@@ -23,15 +23,16 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-#include "fvWallPoint.H"
+#include "FvWallInfo.H"
 #include "fvMesh.H"
 #include "volFields.H"
 #include "surfaceFields.H"
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
+template<class WallInfo, class Derived>
 template<class TrackingData>
-inline void Foam::fvWallPoint::transform
+inline void Foam::FvWallInfoBase<WallInfo, Derived>::transform
 (
     const fvPatch& patch,
     const label patchFacei,
@@ -39,39 +40,47 @@ inline void Foam::fvWallPoint::transform
     TrackingData& td
 )
 {
-    wallPoint::transform(patch.patch(), patchFacei, transform, td);
+    WallInfo::template type<Derived>::transform
+    (
+        patch.patch(),
+        patchFacei,
+        transform,
+        td
+    );
 }
 
 
+template<class WallInfo, class Derived>
 template<class TrackingData>
-inline bool Foam::fvWallPoint::updateCell
+inline bool Foam::FvWallInfoBase<WallInfo, Derived>::updateCell
 (
     const fvMesh& mesh,
     const label thisCelli,
     const labelPair& neighbourPatchAndFacei,
-    const fvWallPoint& neighbourWallInfo,
+    const FvWallInfoBase<WallInfo, Derived>& neighbourWallInfo,
     const scalar tol,
     TrackingData& td
 )
 {
     return
-        this->update
+        static_cast<Derived&>(*this).update
         (
             mesh.C()[thisCelli],
-            neighbourWallInfo,
+            static_cast<const Derived&>(neighbourWallInfo),
             tol,
             td
         );
 }
 
 
+template<class WallInfo, class Derived>
 template<class TrackingData>
-inline bool Foam::fvWallPoint::updateFace
+inline bool Foam::FvWallInfoBase<WallInfo, Derived>::updateFace
 (
     const fvMesh& mesh,
     const labelPair& thisPatchAndFacei,
     const label neighbourCelli,
-    const fvWallPoint& neighbourWallInfo,
+    const FvWallInfoBase<WallInfo, Derived>& neighbourWallInfo,
     const scalar tol,
     TrackingData& td
 )
@@ -80,24 +89,25 @@ inline bool Foam::fvWallPoint::updateFace
     const label thisFacei = thisPatchAndFacei.second();
 
     return
-        this->update
+        static_cast<Derived&>(*this).update
         (
             thisPatchi == -1
           ? mesh.Cf()[thisFacei]
           : mesh.Cf().boundaryField()[thisPatchi][thisFacei],
-            neighbourWallInfo,
+            static_cast<const Derived&>(neighbourWallInfo),
             tol,
             td
         );
 }
 
 
+template<class WallInfo, class Derived>
 template<class TrackingData>
-inline bool Foam::fvWallPoint::updateFace
+inline bool Foam::FvWallInfoBase<WallInfo, Derived>::updateFace
 (
     const fvMesh& mesh,
     const labelPair& thisPatchAndFacei,
-    const fvWallPoint& neighbourWallInfo,
+    const FvWallInfoBase<WallInfo, Derived>& neighbourWallInfo,
     const scalar tol,
     TrackingData& td
 )
@@ -106,12 +116,12 @@ inline bool Foam::fvWallPoint::updateFace
     const label thisFacei = thisPatchAndFacei.second();
 
     return
-        this->update
+        static_cast<Derived&>(*this).update
         (
             thisPatchi == -1
           ? mesh.Cf()[thisFacei]
           : mesh.Cf().boundaryField()[thisPatchi][thisFacei],
-            neighbourWallInfo,
+            static_cast<const Derived&>(neighbourWallInfo),
             tol,
             td
         );
diff --git a/src/finiteVolume/fvMesh/wallDist/fvWallPointYPlus/fvWallPointYPlus.H b/src/finiteVolume/fvMesh/wallDist/FvWallInfo/FvWallInfoYPlus.H
similarity index 53%
rename from src/finiteVolume/fvMesh/wallDist/fvWallPointYPlus/fvWallPointYPlus.H
rename to src/finiteVolume/fvMesh/wallDist/FvWallInfo/FvWallInfoYPlus.H
index e5aa9bd4aa..6dbd55d1ec 100644
--- a/src/finiteVolume/fvMesh/wallDist/fvWallPointYPlus/fvWallPointYPlus.H
+++ b/src/finiteVolume/fvMesh/wallDist/FvWallInfo/FvWallInfoYPlus.H
@@ -22,7 +22,7 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Class
-    Foam::fvWallPointYPlus
+    Foam::FvWallInfoYPlus
 
 Description
     Holds information (coordinate and yStar) regarding nearest wall point.
@@ -32,33 +32,29 @@ Description
     the damping function becomes 1, since y gets initialised to great and
     yStar to 1.
 
-    Note: should feed the additional argument (yPlusCutoff) through as a
-    template argument into FvFaceCellWave
-
 SourceFiles
-    fvWallPointYPlusI.H
-    fvWallPointYPlus.C
+    FvWallInfoYPlusI.H
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef fvWallPointYPlus_H
-#define fvWallPointYPlus_H
+#ifndef FvWallInfoYPlus_H
+#define FvWallInfoYPlus_H
 
-#include "fvWallPointData.H"
+#include "FvWallInfoData.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 namespace Foam
 {
 
-
 /*---------------------------------------------------------------------------*\
-                       Class fvWallPointYPlus Declaration
+                       Class FvWallInfoYPlusBase Declaration
 \*---------------------------------------------------------------------------*/
 
-class fvWallPointYPlus
+template<class WallInfo, class Derived>
+class FvWallInfoYPlusBase
 :
-    public fvWallPointData<scalar>
+    public FvWallInfoDataBase<WallInfo, scalar, Derived>
 {
 public:
 
@@ -72,9 +68,12 @@ public:
     };
 
 
-private:
+protected:
 
-    // Private Member Functions
+    friend class FvWallInfoBase<WallInfo, Derived>;
+
+
+    // Protected Member Functions
 
         //- Evaluate distance to point. Update distSqr, origin from whomever
         //  is nearer pt. Return true if w2 is closer to point,
@@ -83,7 +82,7 @@ private:
         inline bool update
         (
             const point& pt,
-            const fvWallPointYPlus& w2,
+            const FvWallInfoYPlusBase<WallInfo, Derived>& w2,
             const scalar tol,
             TrackingData& td
         );
@@ -94,68 +93,28 @@ public:
     // Constructors
 
         //- Construct null
-        inline fvWallPointYPlus();
+        inline FvWallInfoYPlusBase();
 
-        //- Construct from origin, yStar, distance
-        inline fvWallPointYPlus
-        (
-            const point& origin,
-            const scalar yStar,
-            const scalar distSqr
-        );
-
-
-    // Member Functions
-
-        // Needed by FvFaceCellWave
-
-            //- Influence of neighbouring face.
-            //  Calls update(...) with cellCentre of celli
-            template<class TrackingData>
-            inline bool updateCell
-            (
-                const fvMesh& mesh,
-                const label thisCelli,
-                const labelPair& neighbourPatchAndFacei,
-                const fvWallPointYPlus& neighbourWallInfo,
-                const scalar tol,
-                TrackingData& td
-            );
-
-            //- Influence of neighbouring cell.
-            //  Calls update(...) with faceCentre of facei
-            template<class TrackingData>
-            inline bool updateFace
-            (
-                const fvMesh& mesh,
-                const labelPair& thisPatchAndFacei,
-                const label neighbourCelli,
-                const fvWallPointYPlus& neighbourWallInfo,
-                const scalar tol,
-                TrackingData& td
-            );
-
-            //- Influence of different value on same face.
-            //  Merge new and old info.
-            //  Calls update(...) with faceCentre of facei
-            template<class TrackingData>
-            inline bool updateFace
-            (
-                const fvMesh& mesh,
-                const labelPair& thisPatchAndFacei,
-                const fvWallPointYPlus& neighbourWallInfo,
-                const scalar tol,
-                TrackingData& td
-            );
+        //- Inherit constructors
+        using FvWallInfoDataBase<WallInfo, scalar, Derived>::FvWallInfoDataBase;
 };
 
 
-//- Data associated with pointEdgePoint type as contiguous as underlying type
-template<>
-inline bool contiguous<fvWallPointYPlus>()
+/*---------------------------------------------------------------------------*\
+                       Class FvWallInfoYPlus Declaration
+\*---------------------------------------------------------------------------*/
+
+template<class WallInfo>
+class FvWallInfoYPlus
+:
+    public FvWallInfoYPlusBase<WallInfo, FvWallInfoYPlus<WallInfo>>
 {
-    return contiguous<fvWallPointData<scalar>>();
-}
+    public:
+
+        using
+            FvWallInfoYPlusBase<WallInfo, FvWallInfoYPlus<WallInfo>>::
+            FvWallInfoYPlusBase;
+};
 
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@@ -164,7 +123,7 @@ inline bool contiguous<fvWallPointYPlus>()
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-#include "fvWallPointYPlusI.H"
+#include "FvWallInfoYPlusI.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
diff --git a/src/meshTools/patchDist/wallPoint/wallPoint.C b/src/finiteVolume/fvMesh/wallDist/FvWallInfo/FvWallInfoYPlusI.H
similarity index 54%
rename from src/meshTools/patchDist/wallPoint/wallPoint.C
rename to src/finiteVolume/fvMesh/wallDist/FvWallInfo/FvWallInfoYPlusI.H
index c5e4fdcae7..d6a70da52e 100644
--- a/src/meshTools/patchDist/wallPoint/wallPoint.C
+++ b/src/finiteVolume/fvMesh/wallDist/FvWallInfo/FvWallInfoYPlusI.H
@@ -23,18 +23,50 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-#include "wallPoint.H"
+#include "FvWallInfoYPlus.H"
 
-// * * * * * * * * * * * * * * * Friend Operators  * * * * * * * * * * * * * //
+// * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
 
-Foam::Ostream& Foam::operator<<(Foam::Ostream& os, const Foam::wallPoint& wDist)
+template<class WallInfo, class Derived>
+template<class TrackingData>
+inline bool Foam::FvWallInfoYPlusBase<WallInfo, Derived>::update
+(
+    const point& pt,
+    const FvWallInfoYPlusBase<WallInfo, Derived>& w2,
+    const scalar tol,
+    TrackingData& td
+)
 {
-    return os << wDist.origin() << token::SPACE << wDist.distSqr();
+    FvWallInfoYPlusBase<WallInfo, Derived> copy(*this);
+
+    bool result =
+        FvWallInfoDataBase<WallInfo, scalar, Derived>::update(pt, w2, tol, td);
+
+    if (result)
+    {
+        const scalar yPlus = sqrt(this->distSqr())/w2.data();
+
+        if (yPlus >= td.yPlusCutOff)
+        {
+            *this = copy;
+            result = false;
+        }
+    }
+
+    return result;
 }
 
-Foam::Istream& Foam::operator>>(Foam::Istream& is, Foam::wallPoint& wDist)
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+template<class WallInfo, class Derived>
+inline Foam::FvWallInfoYPlusBase<WallInfo, Derived>::FvWallInfoYPlusBase()
+:
+    FvWallInfoDataBase<WallInfo, scalar, Derived>()
 {
-    return is >> wDist.origin() >> wDist.distSqr();
+    // Important: The value of yStar where the meshWave does not come.
+    this->data() = 1.0;
 }
 
+
 // ************************************************************************* //
diff --git a/src/finiteVolume/fvMesh/wallDist/fvWallPointData/fvWallPointData.C b/src/finiteVolume/fvMesh/wallDist/fvPatchDistWave/fvPatchDistWave.C
similarity index 64%
rename from src/finiteVolume/fvMesh/wallDist/fvWallPointData/fvWallPointData.C
rename to src/finiteVolume/fvMesh/wallDist/fvPatchDistWave/fvPatchDistWave.C
index 3f1597f660..5bb37e65cc 100644
--- a/src/finiteVolume/fvMesh/wallDist/fvWallPointData/fvWallPointData.C
+++ b/src/finiteVolume/fvMesh/wallDist/fvPatchDistWave/fvPatchDistWave.C
@@ -23,42 +23,39 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-#include "fvWallPointData.H"
+#include "fvPatchDistWave.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-namespace Foam
-{
-
-// * * * * * * * * * * * * * * * Friend Operators  * * * * * * * * * * * * * //
-
-template<class Type>
-Ostream& operator<<
+Foam::List<Foam::labelPair> Foam::fvPatchDistWave::getChangedPatchAndFaces
 (
-    Ostream& os,
-    const fvWallPointData<Type>& wDist
+    const fvMesh& mesh,
+    const labelHashSet& patchIDs
 )
 {
-    return os
-        << static_cast<const fvWallPoint&>(wDist)
-        << token::SPACE
-        << wDist.data();
-}
+    label nChangedFaces = 0;
+    forAllConstIter(labelHashSet, patchIDs, iter)
+    {
+        nChangedFaces += mesh.boundary()[iter.key()].size();
+    }
 
+    List<labelPair> changedPatchAndFaces(nChangedFaces);
+    label changedFacei = 0;
 
-template<class Type>
-Istream& operator>>
-(
-    Istream& is,
-    fvWallPointData<Type>& wDist
-)
-{
-    return is >> static_cast<fvWallPoint&>(wDist) >> wDist.data_;
+    forAllConstIter(labelHashSet, patchIDs, iter)
+    {
+        const label patchi = iter.key();
+        const fvPatch& patch = mesh.boundary()[patchi];
+
+        forAll(patch, patchFacei)
+        {
+            changedPatchAndFaces[changedFacei] = labelPair(patchi, patchFacei);
+            changedFacei++;
+        }
+    }
+
+    return changedPatchAndFaces;
 }
 
 
-// ************************************************************************* //
-
-} // End namespace Foam
-
 // ************************************************************************* //
diff --git a/src/finiteVolume/fvMesh/wallDist/fvPatchDistWave/fvPatchDistWave.H b/src/finiteVolume/fvMesh/wallDist/fvPatchDistWave/fvPatchDistWave.H
index 6993606702..4554f348a8 100644
--- a/src/finiteVolume/fvMesh/wallDist/fvPatchDistWave/fvPatchDistWave.H
+++ b/src/finiteVolume/fvMesh/wallDist/fvPatchDistWave/fvPatchDistWave.H
@@ -38,6 +38,8 @@ SourceFiles
 
 #include "FvFaceCellWave.H"
 #include "volFields.H"
+#include "wallPoint.H"
+#include "wallFace.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -48,74 +50,126 @@ namespace fvPatchDistWave
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-//- Set initial set of changed faces
-template<class PatchPointType, class ... InitialPatchData>
-void setChangedFaces
+//- Get initial set of changed faces
+List<labelPair> getChangedPatchAndFaces
 (
     const fvMesh& mesh,
-    const labelHashSet& patchIDs,
-    List<labelPair>& changedPatchAndFaces,
-    List<PatchPointType>& faceDist,
-    const InitialPatchData& ... initialPatchData
+    const labelHashSet& patchIDs
 );
 
-//- Copy FvFaceCellWave values into the cell fields
+//- Wave distance (and maybe additional) data from faces. If nCorrections is
+//  negative (-1) then the wave propagates through the entire mesh and all
+//  values are calculated. If nCorrections is positive, then this many wave
+//  steps are computed and the result is corrected only on cells and faces that
+//  the wave reaches. Don't use this directly. Use
+//  calculate/correct/calculateAndCorrect functions below.
 template
 <
-    class PatchPointType,
+    class WallInfo,
     class TrackingData,
-    class DataType,
-    class DataMethod
+    template<class> class PatchField,
+    class GeoMesh,
+    class ... DataType
 >
-label getCellValues
-(
-    FvFaceCellWave<PatchPointType, TrackingData>& waveInfo,
-    Field<DataType>& cellValues,
-    DataMethod method,
-    const DataType& stabiliseValue = pTraits<DataType>::zero
-);
-
-//- Copy FvFaceCellWave values into the patch field-fields
-template
-<
-    class PatchPointType,
-    class TrackingData,
-    class DataType,
-    class DataMethod
->
-label getPatchValues
-(
-    FvFaceCellWave<PatchPointType, TrackingData>& wave,
-    GeometricBoundaryField<DataType, fvPatchField, volMesh>& valuesBf,
-    DataMethod method,
-    const DataType& stabiliseValue = pTraits<DataType>::zero
-);
-
-//- Wave distance data from the patches to the cells and other patch faces
-template<class PatchPointType, class TrackingData = int>
 label wave
 (
     const fvMesh& mesh,
-    const labelHashSet& patchIDs,
-    volScalarField& distance,
-    bool correct = true,
-    TrackingData& td = FvFaceCellWave<PatchPointType>::defaultTrackingData_
+    const List<labelPair>& changedPatchAndFaces,
+    const label nCorrections,
+    GeometricField<scalar, PatchField, GeoMesh>& distance,
+    TrackingData& td,
+    GeometricField<DataType, PatchField, GeoMesh>& ... data
 );
 
-//- Wave distance and auxiliary data from the patches to the cells and other
-//  patch faces
-template<class PatchPointType, class TrackingData = int>
-label wave
+//- Calculate distance data from patches
+template<template<class> class PatchField, class GeoMesh>
+label calculate
 (
     const fvMesh& mesh,
     const labelHashSet& patchIDs,
-    const GeometricBoundaryField
-        <typename PatchPointType::dataType, fvPatchField, volMesh>&
-        initialPatchData,
-    volScalarField& distance,
-    VolField<typename PatchPointType::dataType>& data,
-    bool correct = true,
-    TrackingData& td = FvFaceCellWave<PatchPointType>::defaultTrackingData_
+    GeometricField<scalar, PatchField, GeoMesh>& distance
+);
+
+//- Correct distance data from patches
+template<template<class> class PatchField, class GeoMesh>
+void correct
+(
+    const fvMesh& mesh,
+    const labelHashSet& patchIDs,
+    const label nCorrections,
+    GeometricField<scalar, PatchField, GeoMesh>& distance
+);
+
+//- Calculate and correct distance data from patches
+template<template<class> class PatchField, class GeoMesh>
+label calculateAndCorrect
+(
+    const fvMesh& mesh,
+    const labelHashSet& patchIDs,
+    const label nCorrections,
+    GeometricField<scalar, PatchField, GeoMesh>& distance
+);
+
+//- Calculate distance and additional data from patches
+template
+<
+    template<class> class WallInfoData,
+    template<class> class PatchField,
+    class GeoMesh,
+    class TrackingData = int
+>
+label calculate
+(
+    const fvMesh& mesh,
+    const labelHashSet& patchIDs,
+    GeometricField<scalar, PatchField, GeoMesh>& distance,
+    GeometricField
+        <typename WallInfoData<wallPoint>::dataType, PatchField, GeoMesh>&
+        data,
+    TrackingData& td =
+        FvFaceCellWave<WallInfoData<wallPoint>>::defaultTrackingData_
+);
+
+//- Correct distance and additional data from patches
+template
+<
+    template<class> class WallInfoData,
+    template<class> class PatchField,
+    class GeoMesh,
+    class TrackingData = int
+>
+void correct
+(
+    const fvMesh& mesh,
+    const labelHashSet& patchIDs,
+    const label nCorrections,
+    GeometricField<scalar, PatchField, GeoMesh>& distance,
+    GeometricField
+        <typename WallInfoData<wallPoint>::dataType, PatchField, GeoMesh>&
+        data,
+    TrackingData& td =
+        FvFaceCellWave<WallInfoData<wallPoint>>::defaultTrackingData_
+);
+
+//- Calculate and correct distance and additional data from patches
+template
+<
+    template<class> class WallInfoData,
+    template<class> class PatchField,
+    class GeoMesh,
+    class TrackingData = int
+>
+label calculateAndCorrect
+(
+    const fvMesh& mesh,
+    const labelHashSet& patchIDs,
+    const label nCorrections,
+    GeometricField<scalar, PatchField, GeoMesh>& distance,
+    GeometricField
+        <typename WallInfoData<wallPoint>::dataType, PatchField, GeoMesh>&
+        data,
+    TrackingData& td =
+        FvFaceCellWave<WallInfoData<wallPoint>>::defaultTrackingData_
 );
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
diff --git a/src/finiteVolume/fvMesh/wallDist/fvPatchDistWave/fvPatchDistWaveTemplates.C b/src/finiteVolume/fvMesh/wallDist/fvPatchDistWave/fvPatchDistWaveTemplates.C
index 5ad2f7cbe3..bf642d0e58 100644
--- a/src/finiteVolume/fvMesh/wallDist/fvPatchDistWave/fvPatchDistWaveTemplates.C
+++ b/src/finiteVolume/fvMesh/wallDist/fvPatchDistWave/fvPatchDistWaveTemplates.C
@@ -24,319 +24,353 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "fvPatchDistWave.H"
-#include "patchDistFuncs.H"
+#include "FvWallInfo.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-template<class PatchPointType, class ... InitialPatchData>
-void Foam::fvPatchDistWave::setChangedFaces
+namespace Foam
+{
+namespace fvPatchDistWave
+{
+
+template<class WallInfo, class TrackingData>
+const List<WallInfo>& getInternalInfo
 (
-    const fvMesh& mesh,
-    const labelHashSet& patchIDs,
-    List<labelPair>& changedPatchAndFaces,
-    List<PatchPointType>& changedFacesInfo,
-    const InitialPatchData& ... initialPatchData
+    const volScalarField& distance,
+    FvFaceCellWave<WallInfo, TrackingData>& wave
 )
 {
-    label nChangedFaces = 0;
-    forAllConstIter(labelHashSet, patchIDs, iter)
-    {
-        nChangedFaces += mesh.boundary()[iter.key()].size();
-    }
-
-    changedPatchAndFaces.resize(nChangedFaces);
-    changedFacesInfo.resize(nChangedFaces);
-
-    label changedFacei = 0;
-
-    forAllConstIter(labelHashSet, patchIDs, iter)
-    {
-        const label patchi = iter.key();
-
-        const fvPatch& patch = mesh.boundary()[patchi];
-
-        forAll(patch.Cf(), patchFacei)
-        {
-            changedPatchAndFaces[changedFacei] = {patchi, patchFacei};
-
-            changedFacesInfo[changedFacei] =
-                PatchPointType
-                (
-                    patch.Cf()[patchFacei],
-                    initialPatchData[patchi][patchFacei] ...,
-                    scalar(0)
-                );
-
-            changedFacei++;
-        }
-    }
+    return wave.cellInfo();
 }
 
+template<class WallInfo, class TrackingData>
+const List<WallInfo>& getInternalInfo
+(
+    const surfaceScalarField& distance,
+    FvFaceCellWave<WallInfo, TrackingData>& wave
+)
+{
+    return wave.internalFaceInfo();
+}
+
+}
+}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 template
 <
-    class PatchPointType,
+    class WallInfo,
     class TrackingData,
-    class DataType,
-    class DataMethod
+    template<class> class PatchField,
+    class GeoMesh,
+    class ... DataType
 >
-Foam::label Foam::fvPatchDistWave::getCellValues
-(
-    FvFaceCellWave<PatchPointType, TrackingData>& waveInfo,
-    Field<DataType>& cellValues,
-    DataMethod method,
-    const DataType& stabiliseValue
-)
-{
-    const List<PatchPointType>& cellInfo = waveInfo.cellInfo();
-
-    label nInvalid = 0;
-
-    forAll(cellInfo, celli)
-    {
-        cellValues[celli] =
-            (cellInfo[celli].*method)(waveInfo.data())
-          + stabiliseValue;
-
-        nInvalid += !cellInfo[celli].valid(waveInfo.data());
-    }
-
-    return nInvalid;
-}
-
-
-template
-<
-    class PatchPointType,
-    class TrackingData,
-    class DataType,
-    class DataMethod
->
-Foam::label Foam::fvPatchDistWave::getPatchValues
-(
-    FvFaceCellWave<PatchPointType, TrackingData>& waveInfo,
-    GeometricBoundaryField<DataType, fvPatchField, volMesh>& valuesBf,
-    DataMethod method,
-    const DataType& stabiliseValue
-)
-{
-    const List<List<PatchPointType>>& patchFaceInfo = waveInfo.patchFaceInfo();
-
-    label nInvalid = 0;
-
-    forAll(valuesBf, patchi)
-    {
-        forAll(valuesBf[patchi], patchFacei)
-        {
-            valuesBf[patchi][patchFacei] =
-                (patchFaceInfo[patchi][patchFacei].*method)(waveInfo.data())
-              + stabiliseValue;
-
-            nInvalid +=
-                !patchFaceInfo[patchi][patchFacei].valid(waveInfo.data());
-        }
-    }
-
-    return nInvalid;
-}
-
-
-template<class PatchPointType, class TrackingData>
 Foam::label Foam::fvPatchDistWave::wave
 (
     const fvMesh& mesh,
-    const labelHashSet& patchIDs,
-    volScalarField& distance,
-    const bool correct,
-    TrackingData& td
+    const List<labelPair>& changedPatchAndFaces,
+    const label nCorrections,
+    GeometricField<scalar, PatchField, GeoMesh>& distance,
+    TrackingData& td,
+    GeometricField<DataType, PatchField, GeoMesh>& ... data
 )
 {
+    // If the number of corrections is less than 0 (i.e., -1) then this is a
+    // calculation across the entire mesh. Otherwise it is a correction for the
+    // cells/faces near the changed faces.
+    const bool calculate = nCorrections < 0;
+
+    // Quick return if no corrections
+    if (!calculate && nCorrections == 0) return 0;
+
     // Initialise changedFacesInfo to face centres on patches
-    List<labelPair> changedPatchAndFaces;
-    List<PatchPointType> changedFacesInfo;
-    setChangedFaces
-    (
-        mesh,
-        patchIDs,
-        changedPatchAndFaces,
-        changedFacesInfo
-    );
+    List<WallInfo> changedFacesInfo(changedPatchAndFaces.size());
+    forAll(changedPatchAndFaces, changedFacei)
+    {
+        const label patchi =
+            changedPatchAndFaces[changedFacei].first();
+        const label patchFacei =
+            changedPatchAndFaces[changedFacei].second();
+
+        changedFacesInfo[changedFacei] =
+            WallInfo
+            (
+                data.boundaryField()[patchi][patchFacei] ...,
+                mesh.boundaryMesh()[patchi][patchFacei],
+                mesh.points(),
+                mesh.Cf().boundaryField()[patchi][patchFacei],
+                scalar(0)
+            );
+    }
 
     // Do calculate patch distance by 'growing' from faces.
-    List<PatchPointType> internalFaceInfo(mesh.nInternalFaces());
-    List<List<PatchPointType>> patchFaceInfo
+    List<WallInfo> internalFaceInfo(mesh.nInternalFaces());
+    List<List<WallInfo>> patchFaceInfo
     (
-        FvFaceCellWave<PatchPointType, TrackingData>::template
-        sizesListList<List<List<PatchPointType>>>
+        FvFaceCellWave<WallInfo, TrackingData>::template
+        sizesListList<List<List<WallInfo>>>
         (
-            FvFaceCellWave<PatchPointType, TrackingData>::template
+            FvFaceCellWave<WallInfo, TrackingData>::template
             listListSizes(mesh.boundary()),
-            PatchPointType()
+            WallInfo()
         )
     );
-    List<PatchPointType> cellInfo(mesh.nCells());
-    FvFaceCellWave<PatchPointType, TrackingData> wave
+    List<WallInfo> cellInfo(mesh.nCells());
+
+    // Do the wave
+    FvFaceCellWave<WallInfo, TrackingData> wave
     (
         mesh,
-        changedPatchAndFaces,
-        changedFacesInfo,
         internalFaceInfo,
         patchFaceInfo,
         cellInfo,
-        mesh.globalData().nTotalCells() + 1, // max iterations
         td
     );
-
-    // Copy distance into return field
-    const label nUnset =
-        getCellValues
-        (
-            wave,
-            distance.primitiveFieldRef(),
-            &PatchPointType::template dist<int>
-        )
-      + getPatchValues
-        (
-            wave,
-            distance.boundaryFieldRef(),
-            &PatchPointType::template dist<int>,
-            small
-        );
-
-    // Correct patch cells for true distance
-    if (correct)
+    wave.setFaceInfo(changedPatchAndFaces, changedFacesInfo);
+    if (calculate)
     {
-        Map<labelPair> nearestFace(2*changedFacesInfo.size());
-        patchDistFuncs::correctBoundaryFaceCells
-        (
-            mesh,
-            patchIDs,
-            distance.primitiveFieldRef(),
-            nearestFace
-        );
-        patchDistFuncs::correctBoundaryPointCells
-        (
-            mesh,
-            patchIDs,
-            distance.primitiveFieldRef(),
-            nearestFace
-        );
+        // Calculation. Wave to completion.
+        wave.iterate(mesh.globalData().nTotalCells() + 1);
+    }
+    else
+    {
+        // Correction. Wave the specified number of times then stop. We care
+        // about cell values, so avoid the final cellToFace by doing n - 1
+        // iterations than a final faceToCell.
+        wave.iterate(nCorrections - 1);
+        wave.faceToCell();
+    }
+
+    // Copy distances into field
+    const List<WallInfo>& internalInfo = getInternalInfo(distance, wave);
+    label nUnset = 0;
+    forAll(internalInfo, internali)
+    {
+        const bool valid = internalInfo[internali].valid(td);
+
+        if (calculate || valid)
+        {
+            nUnset += !valid;
+
+            distance.primitiveFieldRef()[internali] =
+                internalInfo[internali].dist(td);
+
+            std::initializer_list<nil>
+            {(
+                data.primitiveFieldRef()[internali] =
+                    internalInfo[internali].data(td),
+                nil()
+            ) ... };
+        }
+    }
+    forAll(patchFaceInfo, patchi)
+    {
+        forAll(patchFaceInfo[patchi], patchFacei)
+        {
+            const bool valid = patchFaceInfo[patchi][patchFacei].valid(td);
+
+            if (calculate || valid)
+            {
+                nUnset += !valid;
+
+                distance.boundaryFieldRef()[patchi][patchFacei] =
+                    patchFaceInfo[patchi][patchFacei].dist(td) + small;
+
+                std::initializer_list<nil>
+                {(
+                    data.boundaryFieldRef()[patchi][patchFacei] =
+                        patchFaceInfo[patchi][patchFacei].data(td),
+                    nil()
+                ) ... };
+            }
+        }
     }
 
     return nUnset;
 }
 
 
-template<class PatchPointType, class TrackingData>
-Foam::label Foam::fvPatchDistWave::wave
+template<template<class> class PatchField, class GeoMesh>
+Foam::label Foam::fvPatchDistWave::calculate
 (
     const fvMesh& mesh,
     const labelHashSet& patchIDs,
-    const GeometricBoundaryField
-        <typename PatchPointType::dataType, fvPatchField, volMesh>&
-        initialPatchData,
-    volScalarField& distance,
-    VolField<typename PatchPointType::dataType>& data,
-    const bool correct,
+    GeometricField<scalar, PatchField, GeoMesh>& distance
+)
+{
+    return
+        wave<FvWallInfo<wallPoint>>
+        (
+            mesh,
+            getChangedPatchAndFaces(mesh, patchIDs),
+            -1,
+            distance,
+            FvFaceCellWave<FvWallInfo<wallPoint>>::defaultTrackingData_
+        );
+}
+
+
+template<template<class> class PatchField, class GeoMesh>
+void Foam::fvPatchDistWave::correct
+(
+    const fvMesh& mesh,
+    const labelHashSet& patchIDs,
+    const label nCorrections,
+    GeometricField<scalar, PatchField, GeoMesh>& distance
+)
+{
+    wave<FvWallInfo<wallFace>>
+    (
+        mesh,
+        getChangedPatchAndFaces(mesh, patchIDs),
+        nCorrections,
+        distance,
+        FvFaceCellWave<FvWallInfo<wallFace>>::defaultTrackingData_
+    );
+}
+
+
+template<template<class> class PatchField, class GeoMesh>
+Foam::label Foam::fvPatchDistWave::calculateAndCorrect
+(
+    const fvMesh& mesh,
+    const labelHashSet& patchIDs,
+    const label nCorrections,
+    GeometricField<scalar, PatchField, GeoMesh>& distance
+)
+{
+    const List<labelPair> changedPatchAndFaces =
+        getChangedPatchAndFaces(mesh, patchIDs);
+
+    const label nUnset =
+        wave<FvWallInfo<wallPoint>>
+        (
+            mesh,
+            changedPatchAndFaces,
+            -1,
+            distance,
+            FvFaceCellWave<FvWallInfo<wallPoint>>::defaultTrackingData_
+        );
+
+    wave<FvWallInfo<wallFace>>
+    (
+        mesh,
+        changedPatchAndFaces,
+        nCorrections,
+        distance,
+        FvFaceCellWave<FvWallInfo<wallFace>>::defaultTrackingData_
+    );
+
+    return nUnset;
+}
+
+
+template
+<
+    template<class> class WallInfoData,
+    template<class> class PatchField,
+    class GeoMesh,
+    class TrackingData
+>
+Foam::label Foam::fvPatchDistWave::calculate
+(
+    const fvMesh& mesh,
+    const labelHashSet& patchIDs,
+    GeometricField<scalar, PatchField, GeoMesh>& distance,
+    GeometricField
+        <typename WallInfoData<wallPoint>::dataType, PatchField, GeoMesh>&
+        data,
     TrackingData& td
 )
 {
-    // Initialise changedFacesInfo to face centres on patches
-    List<labelPair> changedPatchAndFaces;
-    List<PatchPointType> changedFacesInfo;
-    setChangedFaces
-    (
-        mesh,
-        patchIDs,
-        changedPatchAndFaces,
-        changedFacesInfo,
-        initialPatchData
-    );
-
-    // Do calculate patch distance by 'growing' from faces.
-    List<PatchPointType> internalFaceInfo(mesh.nInternalFaces());
-    List<List<PatchPointType>> patchFaceInfo
-    (
-        FvFaceCellWave<PatchPointType, TrackingData>::template
-        sizesListList<List<List<PatchPointType>>>
+    return
+        wave<WallInfoData<wallPoint>, TrackingData>
         (
-            FvFaceCellWave<PatchPointType, TrackingData>::template
-            listListSizes(mesh.boundary()),
-            PatchPointType()
-        )
-    );
-    List<PatchPointType> cellInfo(mesh.nCells());
-    FvFaceCellWave<PatchPointType, TrackingData> wave
+            mesh,
+            getChangedPatchAndFaces(mesh, patchIDs),
+            -1,
+            distance,
+            td,
+            data
+        );
+}
+
+
+template
+<
+    template<class> class WallInfoData,
+    template<class> class PatchField,
+    class GeoMesh,
+    class TrackingData
+>
+void Foam::fvPatchDistWave::correct
+(
+    const fvMesh& mesh,
+    const labelHashSet& patchIDs,
+    const label nCorrections,
+    GeometricField<scalar, PatchField, GeoMesh>& distance,
+    GeometricField
+        <typename WallInfoData<wallPoint>::dataType, PatchField, GeoMesh>&
+        data,
+    TrackingData& td
+)
+{
+    wave<WallInfoData<wallFace>, TrackingData>
     (
         mesh,
-        changedPatchAndFaces,
-        changedFacesInfo,
-        internalFaceInfo,
-        patchFaceInfo,
-        cellInfo,
-        mesh.globalData().nTotalCells() + 1, // max iterations
-        td
+        getChangedPatchAndFaces(mesh, patchIDs),
+        nCorrections,
+        distance,
+        td,
+        data
     );
+}
+
+
+template
+<
+    template<class> class WallInfoData,
+    template<class> class PatchField,
+    class GeoMesh,
+    class TrackingData
+>
+Foam::label Foam::fvPatchDistWave::calculateAndCorrect
+(
+    const fvMesh& mesh,
+    const labelHashSet& patchIDs,
+    const label nCorrections,
+    GeometricField<scalar, PatchField, GeoMesh>& distance,
+    GeometricField
+        <typename WallInfoData<wallPoint>::dataType, PatchField, GeoMesh>&
+        data,
+    TrackingData& td
+)
+{
+    const List<labelPair> changedPatchAndFaces =
+        getChangedPatchAndFaces(mesh, patchIDs);
 
-    // Copy distance into return field
     const label nUnset =
-        getCellValues
-        (
-            wave,
-            distance.primitiveFieldRef(),
-            &PatchPointType::template dist<TrackingData>
-        )
-      + getPatchValues
-        (
-            wave,
-            distance.boundaryFieldRef(),
-            &PatchPointType::template dist<TrackingData>,
-            small
-        );
-
-    // Copy data into the return field
-    getCellValues
-    (
-        wave,
-        data.primitiveFieldRef(),
-        &PatchPointType::template data<TrackingData>
-    );
-    getPatchValues
-    (
-        wave,
-        data.boundaryFieldRef(),
-        &PatchPointType::template data<TrackingData>
-    );
-
-    // Correct patch cells for true distance
-    if (correct)
-    {
-        Map<labelPair> nearestPatchAndFace(2*changedFacesInfo.size());
-        patchDistFuncs::correctBoundaryFaceCells
+        wave<WallInfoData<wallPoint>, TrackingData>
         (
             mesh,
-            patchIDs,
-            distance.primitiveFieldRef(),
-            nearestPatchAndFace
-        );
-        patchDistFuncs::correctBoundaryPointCells
-        (
-            mesh,
-            patchIDs,
-            distance.primitiveFieldRef(),
-            nearestPatchAndFace
+            getChangedPatchAndFaces(mesh, patchIDs),
+            -1,
+            distance,
+            td,
+            data
         );
 
-        // Transfer data from nearest face to cell
-        forAllConstIter(Map<labelPair>, nearestPatchAndFace, iter)
-        {
-            const label celli = iter.key();
-            const label patchi = iter().first();
-            const label patchFacei = iter().second();
-            data.primitiveFieldRef()[celli] =
-                wave.patchFaceInfo()[patchi][patchFacei].data();
-        }
-    }
+    wave<WallInfoData<wallFace>, TrackingData>
+    (
+        mesh,
+        changedPatchAndFaces,
+        nCorrections,
+        distance,
+        td,
+        data
+    );
 
     return nUnset;
 }
diff --git a/src/finiteVolume/fvMesh/wallDist/fvWallPointData/fvWallPointData.H b/src/finiteVolume/fvMesh/wallDist/fvWallPointData/fvWallPointData.H
deleted file mode 100644
index 3a09916a52..0000000000
--- a/src/finiteVolume/fvMesh/wallDist/fvWallPointData/fvWallPointData.H
+++ /dev/null
@@ -1,248 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-Class
-    Foam::fvWallPointData
-
-Description
-    Holds information (coordinate and normal) regarding nearest wall point.
-
-    Is like fvWallPoint but transfer extra (passive) data.
-    Used e.g. in wall distance calculation with wall reflection vectors.
-
-SourceFiles
-    fvWallPointDataI.H
-    fvWallPointData.C
-
-\*---------------------------------------------------------------------------*/
-
-#ifndef fvWallPointData_H
-#define fvWallPointData_H
-
-#include "fvWallPoint.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-namespace Foam
-{
-
-template<class Type> class fvWallPointData;
-
-// Forward declaration of friend functions and operators
-
-template<class Type>
-Istream& operator>>(Istream&, fvWallPointData<Type>&);
-
-template<class Type>
-Ostream& operator<<(Ostream&, const fvWallPointData<Type>&);
-
-
-/*---------------------------------------------------------------------------*\
-                        Class fvWallPointData Declaration
-\*---------------------------------------------------------------------------*/
-
-template<class Type>
-class fvWallPointData
-:
-    public fvWallPoint
-{
-    // Private Data
-
-        //- Data at nearest wall center
-        Type data_;
-
-
-    // Private Member Functions
-
-        //- Evaluate distance to point. Update distSqr, origin from whomever
-        //  is nearer pt. Return true if w2 is closer to point,
-        //  false otherwise.
-        template<class TrackingData>
-        inline bool update
-        (
-            const point&,
-            const fvWallPointData<Type>& w2,
-            const scalar tol,
-            TrackingData& td
-        );
-
-
-public:
-
-    typedef Type dataType;
-
-
-    // Constructors
-
-        //- Construct null
-        inline fvWallPointData();
-
-        //- Construct from origin, normal, distance
-        inline fvWallPointData
-        (
-            const point& origin,
-            const Type& data,
-            const scalar distSqr
-        );
-
-
-    // Member Functions
-
-        // Access
-
-            inline const Type& data() const;
-
-            inline Type& data();
-
-            template<class TrackingData>
-            inline const Type& data(TrackingData& td) const;
-
-
-        // Needed by meshWave
-
-            //- Transform across an interface
-            template<class TrackingData>
-            inline void transform
-            (
-                const fvPatch& patch,
-                const label patchFacei,
-                const transformer& transform,
-                TrackingData& td
-            );
-
-            //- Influence of neighbouring face.
-            //  Calls update(...) with cellCentre of celli
-            template<class TrackingData>
-            inline bool updateCell
-            (
-                const fvMesh& mesh,
-                const label thisCelli,
-                const labelPair& neighbourPatchAndFacei,
-                const fvWallPointData<Type>& neighbourWallInfo,
-                const scalar tol,
-                TrackingData& td
-            );
-
-            //- Influence of neighbouring cell.
-            //  Calls update(...) with faceCentre of facei
-            template<class TrackingData>
-            inline bool updateFace
-            (
-                const fvMesh& mesh,
-                const labelPair& thisPatchAndFacei,
-                const label neighbourCelli,
-                const fvWallPointData<Type>& neighbourWallInfo,
-                const scalar tol,
-                TrackingData& td
-            );
-
-            //- Influence of different value on same face.
-            //  Merge new and old info.
-            //  Calls update(...) with faceCentre of facei
-            template<class TrackingData>
-            inline bool updateFace
-            (
-                const fvMesh& mesh,
-                const labelPair& thisPatchAndFacei,
-                const fvWallPointData<Type>& neighbourWallInfo,
-                const scalar tol,
-                TrackingData& td
-            );
-
-
-    // IOstream Operators
-
-        friend Ostream& operator<< <Type>
-        (
-            Ostream&,
-            const fvWallPointData<Type>&
-        );
-
-        friend Istream& operator>> <Type>
-        (
-            Istream&,
-            fvWallPointData<Type>&
-        );
-};
-
-
-//- Data associated with fvWallPointData type are contiguous. List the usual
-//  ones.
-
-template<>
-inline bool contiguous<fvWallPointData<bool>>()
-{
-    return contiguous<fvWallPoint>();
-}
-template<>
-inline bool contiguous<fvWallPointData<label>>()
-{
-    return contiguous<fvWallPoint>();
-}
-template<>
-inline bool contiguous<fvWallPointData<scalar>>()
-{
-    return contiguous<fvWallPoint>();
-}
-template<>
-inline bool contiguous<fvWallPointData<vector>>()
-{
-    return contiguous<fvWallPoint>();
-}
-template<>
-inline bool contiguous<fvWallPointData<sphericalTensor>>()
-{
-    return contiguous<fvWallPoint>();
-}
-template<>
-inline bool contiguous<fvWallPointData<symmTensor>>()
-{
-    return contiguous<fvWallPoint>();
-}
-template<>
-inline bool contiguous<fvWallPointData<tensor>>()
-{
-    return contiguous<fvWallPoint>();
-}
-
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-
-} // End namespace Foam
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#ifdef NoRepository
-    #include "fvWallPointData.C"
-#endif
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#include "fvWallPointDataI.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#endif
-
-// ************************************************************************* //
diff --git a/src/finiteVolume/fvMesh/wallDist/fvWallPointData/fvWallPointDataI.H b/src/finiteVolume/fvMesh/wallDist/fvWallPointData/fvWallPointDataI.H
deleted file mode 100644
index 167733dfea..0000000000
--- a/src/finiteVolume/fvMesh/wallDist/fvWallPointData/fvWallPointDataI.H
+++ /dev/null
@@ -1,217 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-\*---------------------------------------------------------------------------*/
-
-#include "fvWallPointData.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-namespace Foam
-{
-
-// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
-
-template<class Type>
-template<class TrackingData>
-inline bool fvWallPointData<Type>::update
-(
-    const point& pt,
-    const fvWallPointData<Type>& w2,
-    const scalar tol,
-    TrackingData& td
-)
-{
-    scalar dist2 = magSqr(pt - w2.origin());
-
-    if (valid(td))
-    {
-        scalar diff = distSqr() - dist2;
-
-        if (diff < 0)
-        {
-            // already nearer to pt
-            return false;
-        }
-
-        if ((diff < small) || ((distSqr() > small) && (diff/distSqr() < tol)))
-        {
-            // don't propagate small changes
-            return false;
-        }
-    }
-
-    // Either *this is not yet valid or w2 is closer
-    {
-        // current not yet set so use any value
-        distSqr() = dist2;
-        origin() = w2.origin();
-        data_ = w2.data();
-
-        return true;
-    }
-}
-
-
-// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
-
-template<class Type>
-inline fvWallPointData<Type>::fvWallPointData()
-:
-    fvWallPoint(),
-    data_()
-{}
-
-
-template<class Type>
-inline fvWallPointData<Type>::fvWallPointData
-(
-    const point& origin,
-    const Type& data,
-    const scalar distSqr
-)
-:
-    fvWallPoint(origin, distSqr),
-    data_(data)
-{}
-
-
-// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
-
-template<class Type>
-inline const Type& fvWallPointData<Type>::data() const
-{
-    return data_;
-}
-
-
-template<class Type>
-inline Type& fvWallPointData<Type>::data()
-{
-    return data_;
-}
-
-
-template<class Type>
-template<class TrackingData>
-inline const Type& fvWallPointData<Type>::data(TrackingData& td) const
-{
-    return data_;
-}
-
-
-template<class Type>
-template<class TrackingData>
-inline void Foam::fvWallPointData<Type>::transform
-(
-    const fvPatch& patch,
-    const label patchFacei,
-    const transformer& transform,
-    TrackingData& td
-)
-{
-    fvWallPoint::transform(patch, patchFacei, transform, td);
-    data_ = transform.transform(data_);
-}
-
-
-template<class Type>
-template<class TrackingData>
-inline bool fvWallPointData<Type>::updateCell
-(
-    const fvMesh& mesh,
-    const label thisCelli,
-    const labelPair& neighbourPatchAndFacei,
-    const fvWallPointData<Type>& neighbourWallInfo,
-    const scalar tol,
-    TrackingData& td
-)
-{
-    return update
-    (
-        mesh.C()[thisCelli],
-        neighbourWallInfo,
-        tol,
-        td
-    );
-}
-
-
-template<class Type>
-template<class TrackingData>
-inline bool fvWallPointData<Type>::updateFace
-(
-    const fvMesh& mesh,
-    const labelPair& thisPatchAndFacei,
-    const label neighbourCelli,
-    const fvWallPointData<Type>& neighbourWallInfo,
-    const scalar tol,
-    TrackingData& td
-)
-{
-    const label thisPatchi = thisPatchAndFacei.first();
-    const label thisFacei = thisPatchAndFacei.second();
-
-    return update
-    (
-        thisPatchi == -1
-      ? mesh.Cf()[thisFacei]
-      : mesh.Cf().boundaryField()[thisPatchi][thisFacei],
-        neighbourWallInfo,
-        tol,
-        td
-    );
-}
-
-
-template<class Type>
-template<class TrackingData>
-inline bool fvWallPointData<Type>::updateFace
-(
-    const fvMesh& mesh,
-    const labelPair& thisPatchAndFacei,
-    const fvWallPointData<Type>& neighbourWallInfo,
-    const scalar tol,
-    TrackingData& td
-)
-{
-    const label thisPatchi = thisPatchAndFacei.first();
-    const label thisFacei = thisPatchAndFacei.second();
-
-    return update
-    (
-        thisPatchi == -1
-      ? mesh.Cf()[thisFacei]
-      : mesh.Cf().boundaryField()[thisPatchi][thisFacei],
-        neighbourWallInfo,
-        tol,
-        td
-    );
-}
-
-
-// ************************************************************************* //
-
-} // End namespace Foam
-
-// ************************************************************************* //
diff --git a/src/finiteVolume/fvMesh/wallDist/fvWallPointYPlus/fvWallPointYPlusI.H b/src/finiteVolume/fvMesh/wallDist/fvWallPointYPlus/fvWallPointYPlusI.H
deleted file mode 100644
index 025dcb027e..0000000000
--- a/src/finiteVolume/fvMesh/wallDist/fvWallPointYPlus/fvWallPointYPlusI.H
+++ /dev/null
@@ -1,187 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-\*---------------------------------------------------------------------------*/
-
-#include "fvWallPointYPlus.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-namespace Foam
-{
-
-// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
-
-// Update this with w2 if w2 nearer to pt.
-template<class TrackingData>
-inline bool fvWallPointYPlus::update
-(
-    const point& pt,
-    const fvWallPointYPlus& w2,
-    const scalar tol,
-    TrackingData& td
-)
-{
-    scalar dist2 = magSqr(pt - w2.origin());
-
-    if (valid(td))
-    {
-        scalar diff = distSqr() - dist2;
-
-        if (diff < 0)
-        {
-            // already nearer to pt
-            return false;
-        }
-
-        if ((diff < small) || ((distSqr() > small) && (diff/distSqr() < tol)))
-        {
-            // don't propagate small changes
-            return false;
-        }
-    }
-
-
-    // Either *this is not yet valid or w2 is closer
-    {
-        // only propagate if interesting (i.e. y+ < 100)
-        scalar yPlus = Foam::sqrt(dist2)/w2.data();
-
-        if (yPlus < td.yPlusCutOff)
-        {
-            // update with new values
-            distSqr() = dist2;
-            origin() = w2.origin();
-            data() = w2.data();
-
-            return true;
-        }
-        else
-        {
-            return false;
-        }
-    }
-}
-
-
-// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
-
-inline fvWallPointYPlus::fvWallPointYPlus()
-:
-    fvWallPointData<scalar>()
-{
-    // Important: The value of yStar where the meshWave does not come.
-    data() = 1.0;
-}
-
-
-inline fvWallPointYPlus::fvWallPointYPlus
-(
-    const point& origin,
-    const scalar yStar,
-    const scalar distSqr
-)
-:
-    fvWallPointData<scalar>(origin, yStar, distSqr)
-{}
-
-
-// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
-
-template<class TrackingData>
-inline bool fvWallPointYPlus::updateCell
-(
-    const fvMesh& mesh,
-    const label thisCelli,
-    const labelPair& neighbourPatchAndFacei,
-    const fvWallPointYPlus& neighbourWallInfo,
-    const scalar tol,
-    TrackingData& td
-)
-{
-    return update
-    (
-        mesh.C()[thisCelli],
-        neighbourWallInfo,
-        tol,
-        td
-    );
-}
-
-
-template<class TrackingData>
-inline bool fvWallPointYPlus::updateFace
-(
-    const fvMesh& mesh,
-    const labelPair& thisPatchAndFacei,
-    const label neighbourCelli,
-    const fvWallPointYPlus& neighbourWallInfo,
-    const scalar tol,
-    TrackingData& td
-)
-{
-    const label thisPatchi = thisPatchAndFacei.first();
-    const label thisFacei = thisPatchAndFacei.second();
-
-    return update
-    (
-        thisPatchi == -1
-      ? mesh.Cf()[thisFacei]
-      : mesh.Cf().boundaryField()[thisPatchi][thisFacei],
-        neighbourWallInfo,
-        tol,
-        td
-    );
-}
-
-
-template<class TrackingData>
-inline bool fvWallPointYPlus::updateFace
-(
-    const fvMesh& mesh,
-    const labelPair& thisPatchAndFacei,
-    const fvWallPointYPlus& neighbourWallInfo,
-    const scalar tol,
-    TrackingData& td
-)
-{
-    const label thisPatchi = thisPatchAndFacei.first();
-    const label thisFacei = thisPatchAndFacei.second();
-
-    return update
-    (
-        thisPatchi == -1
-      ? mesh.Cf()[thisFacei]
-      : mesh.Cf().boundaryField()[thisPatchi][thisFacei],
-        neighbourWallInfo,
-        tol,
-        td
-    );
-}
-
-
-// ************************************************************************* //
-
-} // End namespace Foam
-
-// ************************************************************************* //
diff --git a/src/finiteVolume/fvMesh/wallDist/nearWallDist/nearWallDist.C b/src/finiteVolume/fvMesh/wallDist/nearWallDist/nearWallDist.C
index db1ae0a9f2..0b55805354 100644
--- a/src/finiteVolume/fvMesh/wallDist/nearWallDist/nearWallDist.C
+++ b/src/finiteVolume/fvMesh/wallDist/nearWallDist/nearWallDist.C
@@ -24,7 +24,7 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "nearWallDist.H"
-#include "patchDistFuncs.H"
+#include "fvPatchDistWave.H"
 #include "wallPolyPatch.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
@@ -39,12 +39,24 @@ namespace Foam
 
 void Foam::nearWallDist::correct()
 {
-    patchDistFuncs::correctBoundaryFaceFaceCells
+    volScalarField yVf(volScalarField::New("y", mesh(), dimLength));
+
+    fvPatchDistWave::correct
     (
         mesh(),
         mesh().boundaryMesh().findPatchIDs<wallPolyPatch>(),
-        y_
+        2,
+        yVf
     );
+
+    forAll(y_, patchi)
+    {
+        const labelUList& faceCells = mesh().boundary()[patchi].faceCells();
+        forAll(y_[patchi], patchFacei)
+        {
+            y_[patchi][patchFacei] = yVf[faceCells[patchFacei]];
+        }
+    }
 }
 
 
diff --git a/src/finiteVolume/fvMesh/wallDist/patchDistMethods/meshWave/meshWavePatchDistMethod.C b/src/finiteVolume/fvMesh/wallDist/patchDistMethods/meshWave/meshWavePatchDistMethod.C
index cee1c61de4..2437170b37 100644
--- a/src/finiteVolume/fvMesh/wallDist/patchDistMethods/meshWave/meshWavePatchDistMethod.C
+++ b/src/finiteVolume/fvMesh/wallDist/patchDistMethods/meshWave/meshWavePatchDistMethod.C
@@ -27,7 +27,7 @@ License
 #include "fvMesh.H"
 #include "volFields.H"
 #include "fvPatchDistWave.H"
-#include "fvWallPointData.H"
+#include "FvWallInfoData.H"
 #include "emptyFvPatchFields.H"
 #include "addToRunTimeSelectionTable.H"
 
@@ -52,7 +52,7 @@ Foam::patchDistMethods::meshWave::meshWave
 )
 :
     patchDistMethod(mesh, patchIDs),
-    correctWalls_(dict.lookupOrDefault<Switch>("correctWalls", true))
+    nCorrectors_(dict.lookupOrDefault<label>("nCorrectors", 2))
 {}
 
 
@@ -60,11 +60,11 @@ Foam::patchDistMethods::meshWave::meshWave
 (
     const fvMesh& mesh,
     const labelHashSet& patchIDs,
-    const bool correctWalls
+    const label nCorrectors
 )
 :
     patchDistMethod(mesh, patchIDs),
-    correctWalls_(correctWalls)
+    nCorrectors_(nCorrectors)
 {}
 
 
@@ -75,12 +75,12 @@ bool Foam::patchDistMethods::meshWave::correct(volScalarField& y)
     y = dimensionedScalar(dimLength, great);
 
     const label nUnset =
-        fvPatchDistWave::wave<fvWallPoint>
+        fvPatchDistWave::calculateAndCorrect
         (
             mesh_,
             patchIDs_,
-            y,
-            correctWalls_
+            nCorrectors_,
+            y
         );
 
     // Update coupled and transform BCs
@@ -99,14 +99,13 @@ bool Foam::patchDistMethods::meshWave::correct
     y = dimensionedScalar(dimLength, great);
 
     const label nUnset =
-        fvPatchDistWave::wave<fvWallPointData<vector>>
+        fvPatchDistWave::calculateAndCorrect<FvWallInfoVector>
         (
             mesh_,
             patchIDs_,
-            n.boundaryField(),
+            nCorrectors_,
             y,
-            n,
-            correctWalls_
+            n
         );
 
     // Update coupled and transform BCs
diff --git a/src/finiteVolume/fvMesh/wallDist/patchDistMethods/meshWave/meshWavePatchDistMethod.H b/src/finiteVolume/fvMesh/wallDist/patchDistMethods/meshWave/meshWavePatchDistMethod.H
index af20834302..c26aae1701 100644
--- a/src/finiteVolume/fvMesh/wallDist/patchDistMethods/meshWave/meshWavePatchDistMethod.H
+++ b/src/finiteVolume/fvMesh/wallDist/patchDistMethods/meshWave/meshWavePatchDistMethod.H
@@ -31,8 +31,8 @@ Description
     For regular/un-distorted meshes this method is accurate but for skewed,
     non-orthogonal meshes it is approximate with the error increasing with the
     degree of mesh distortion.  The distance from the near-wall cells to the
-    boundary may optionally be corrected for mesh distortion by setting
-    correctWalls = true.
+    boundary may optionally be corrected for mesh distortion by setting a
+    number of correction iterations.
 
     Example of the wallDist specification in fvSchemes:
     \verbatim
@@ -40,6 +40,9 @@ Description
         {
             method meshWave;
 
+            // Number of corrections
+            nCorrectors 3;
+
             // Optional entry enabling the calculation
             // of the normal-to-wall field
             nRequired false;
@@ -78,7 +81,7 @@ class meshWave
     // Private Member Data
 
         //- Do accurate distance calculation for near-wall cells.
-        const bool correctWalls_;
+        const label nCorrectors_;
 
 
 public:
@@ -98,15 +101,13 @@ public:
             const labelHashSet& patchIDs
         );
 
-        //- Construct from mesh, fixed-value patch set and flag specifying
-        //  whether or not to correct wall.
-        //  Calculate for all cells. correctWalls : correct wall (face&point)
-        //  cells for correct distance, searching neighbours.
+        //- Construct from mesh, fixed-value patch set, and number of wall
+        //  correction iterations
         meshWave
         (
             const fvMesh& mesh,
             const labelHashSet& patchIDs,
-            const bool correctWalls = true
+            const label nCorrectors = 2
         );
 
         //- Disallow default bitwise copy construction
diff --git a/src/fvMotionSolver/motionDiffusivity/inverseDistance/inverseDistanceDiffusivity.C b/src/fvMotionSolver/motionDiffusivity/inverseDistance/inverseDistanceDiffusivity.C
index 8fc9576c6d..0766c1829c 100644
--- a/src/fvMotionSolver/motionDiffusivity/inverseDistance/inverseDistanceDiffusivity.C
+++ b/src/fvMotionSolver/motionDiffusivity/inverseDistance/inverseDistanceDiffusivity.C
@@ -26,7 +26,6 @@ License
 #include "inverseDistanceDiffusivity.H"
 #include "addToRunTimeSelectionTable.H"
 #include "fvPatchDistWave.H"
-#include "fvWallPoint.H"
 #include "HashSet.H"
 #include "surfaceInterpolate.H"
 #include "zeroGradientFvPatchFields.H"
@@ -85,12 +84,11 @@ Foam::inverseDistanceDiffusivity::operator()() const
 
     if (patchNames_.size())
     {
-        fvPatchDistWave::wave<fvWallPoint>
+        fvPatchDistWave::calculate
         (
             mesh(),
             mesh().boundaryMesh().patchSet(patchNames_),
-            y,
-            false
+            y
         );
     }
 
diff --git a/src/fvMotionSolver/motionDiffusivity/inverseFaceDistance/inverseFaceDistanceDiffusivity.C b/src/fvMotionSolver/motionDiffusivity/inverseFaceDistance/inverseFaceDistanceDiffusivity.C
index ccffc570bf..1d4ead34d6 100644
--- a/src/fvMotionSolver/motionDiffusivity/inverseFaceDistance/inverseFaceDistanceDiffusivity.C
+++ b/src/fvMotionSolver/motionDiffusivity/inverseFaceDistance/inverseFaceDistanceDiffusivity.C
@@ -25,8 +25,7 @@ License
 
 #include "inverseFaceDistanceDiffusivity.H"
 #include "surfaceFields.H"
-#include "FvFaceCellWave.H"
-#include "fvWallPoint.H"
+#include "fvPatchDistWave.H"
 #include "addToRunTimeSelectionTable.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
@@ -68,112 +67,51 @@ Foam::inverseFaceDistanceDiffusivity::~inverseFaceDistanceDiffusivity()
 Foam::tmp<Foam::surfaceScalarField>
 Foam::inverseFaceDistanceDiffusivity::operator()() const
 {
+    surfaceScalarField y
+    (
+        IOobject
+        (
+            "y",
+            mesh().time().timeName(),
+            mesh()
+        ),
+        mesh(),
+        dimensionedScalar(dimless, 1)
+    );
+
     const labelHashSet patchIDs(mesh().boundaryMesh().patchSet(patchNames_));
 
-    const surfaceVectorField::Boundary& CfBf = mesh().Cf().boundaryField();
-
-    // Create changed face information
-    List<labelPair> changedPatchAndFaces;
-    List<fvWallPoint> changedFacesInfo;
+    if (patchNames_.size())
     {
-        label changedFacei = 0;
-        forAllConstIter(labelHashSet, patchIDs, iter)
-        {
-            const label patchi = iter.key();
-            changedFacei += mesh().boundary()[patchi].size();
-        }
+        fvPatchDistWave::calculate
+        (
+            mesh(),
+            patchIDs,
+            y
+        );
 
-        changedPatchAndFaces.resize(changedFacei);
-        changedFacesInfo.resize(changedFacei);
-
-        changedFacei = 0;
+        // Use cell distance on faces that are part of the patch set. This
+        // avoids divide-by-zero issues.
         forAllConstIter(labelHashSet, patchIDs, iter)
         {
             const label patchi = iter.key();
 
-            forAll(mesh().boundary()[patchi], patchFacei)
+            const labelUList& patchCells =
+                mesh().boundary()[patchi].faceCells();
+
+            forAll(patchCells, patchFacei)
             {
-                changedPatchAndFaces[changedFacei] =
-                    labelPair(patchi, patchFacei);
-                changedFacesInfo[changedFacei] =
-                    fvWallPoint(CfBf[patchi][patchFacei], 0);
-
-                changedFacei ++;
+                y.boundaryFieldRef()[patchi][patchFacei] =
+                    mag
+                    (
+                       mesh().Cf().boundaryField()[patchi][patchFacei]
+                     - mesh().C()[patchCells[patchFacei]]
+                    );
             }
         }
     }
 
-    // Initialise wave storage
-    List<fvWallPoint> internalFaceInfo(mesh().nInternalFaces());
-    List<List<fvWallPoint>> patchFaceInfo
-    (
-        FvFaceCellWave<fvWallPoint>::template
-        sizesListList<List<List<fvWallPoint>>>
-        (
-            FvFaceCellWave<fvWallPoint>::template
-            listListSizes(mesh().boundary()),
-            fvWallPoint()
-        )
-    );
-    List<fvWallPoint> cellInfo(mesh().nCells());
-
-    // Wave through the mesh
-    FvFaceCellWave<fvWallPoint> wave
-    (
-        mesh(),
-        changedPatchAndFaces,
-        changedFacesInfo,
-        internalFaceInfo,
-        patchFaceInfo,
-        cellInfo,
-        mesh().globalData().nTotalCells() + 1 // max iterations
-    );
-
-    // Create the diffusivity field
-    tmp<surfaceScalarField> tfaceDiffusivity
-    (
-        new surfaceScalarField
-        (
-            IOobject
-            (
-                "faceDiffusivity",
-                mesh().time().timeName(),
-                mesh(),
-                IOobject::NO_READ,
-                IOobject::NO_WRITE
-            ),
-            mesh(),
-            dimensionedScalar(dimless, 1.0)
-        )
-    );
-    surfaceScalarField& faceDiffusivity = tfaceDiffusivity.ref();
-
-    // Convert waved distance data into diffusivities
-    forAll(internalFaceInfo, facei)
-    {
-        const scalar dist = internalFaceInfo[facei].dist(wave.data());
-        faceDiffusivity[facei] = 1/dist;
-    }
-    forAll(patchFaceInfo, patchi)
-    {
-        // Use cell distance on faces that are part of the patch set. This
-        // avoids divide-by-zero issues.
-        const bool useCellDist = patchIDs.found(patchi);
-
-        const labelUList& patchCells = mesh().boundary()[patchi].faceCells();
-
-        forAll(patchFaceInfo[patchi], patchFacei)
-        {
-            const scalar dist =
-                useCellDist
-              ? cellInfo[patchCells[patchFacei]].dist(wave.data())
-              : patchFaceInfo[patchi][patchFacei].dist(wave.data());
-
-            faceDiffusivity.boundaryFieldRef()[patchi][patchFacei] = 1/dist;
-        }
-    }
-
-    return tfaceDiffusivity;
+    return surfaceScalarField::New("faceDiffusivity", 1/y);
 }
 
 
diff --git a/src/meshTools/Make/files b/src/meshTools/Make/files
index d931e9bb9f..dbfd711b6d 100644
--- a/src/meshTools/Make/files
+++ b/src/meshTools/Make/files
@@ -44,8 +44,7 @@ cellClassification/cellInfo.C
 
 cellQuality/cellQuality.C
 
-patchDist/patchDistFuncs/patchDistFuncs.C
-patchDist/wallPoint/wallPoint.C
+patchDist/patchDistWave/patchDistWave.C
 
 cellFeatures/cellFeatures.C
 
diff --git a/src/meshTools/patchDist/patchDistFuncs/patchDistFuncs.C b/src/meshTools/patchDist/patchDistFuncs/patchDistFuncs.C
deleted file mode 100644
index 8e06c83a46..0000000000
--- a/src/meshTools/patchDist/patchDistFuncs/patchDistFuncs.C
+++ /dev/null
@@ -1,134 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-\*---------------------------------------------------------------------------*/
-
-#include "patchDistFuncs.H"
-#include "polyMesh.H"
-#include "wallPolyPatch.H"
-#include "polyBoundaryMesh.H"
-
-// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
-
-template<>
-Foam::patchDistFuncs::NoMap<Foam::labelPair>
-Foam::patchDistFuncs::NoMap<Foam::labelPair>::null =
-Foam::patchDistFuncs::NoMap<Foam::labelPair>();
-
-
-// * * * * * * * * * * * * * * * Global Functions  * * * * * * * * * * * * * //
-
-Foam::scalar Foam::patchDistFuncs::smallestDist
-(
-    const point& p,
-    const polyPatch& patch,
-    const labelUList& wallFaces,
-    label& minPatchFacei
-)
-{
-    const pointField& points = patch.points();
-
-    scalar minDist = great;
-    minPatchFacei = -1;
-
-    forAll(wallFaces, wallFacei)
-    {
-        const label patchFacei = wallFaces[wallFacei];
-
-        pointHit curHit = patch[patchFacei].nearestPoint(p, points);
-
-        if (curHit.distance() < minDist)
-        {
-            minDist = curHit.distance();
-            minPatchFacei = patchFacei;
-        }
-    }
-
-    return minDist;
-}
-
-
-void Foam::patchDistFuncs::getPointNeighbours
-(
-    const primitivePatch& patch,
-    const label patchFacei,
-    DynamicList<label>& neighbours
-)
-{
-    neighbours.clear();
-
-    // Add myself
-    neighbours.append(patchFacei);
-
-    // Add all face neighbours
-    const labelList& faceNeighbours = patch.faceFaces()[patchFacei];
-    forAll(faceNeighbours, faceNeighbourI)
-    {
-        neighbours.append(faceNeighbours[faceNeighbourI]);
-    }
-
-    // Remember part of neighbours that contains edge-connected faces.
-    const label nEdgeNbs = neighbours.size();
-
-    // Add all point-only neighbours by linear searching in edge neighbours.
-    // Assumes that point-only neighbours are not using multiple points on
-    // face.
-    const face& f = patch.localFaces()[patchFacei];
-    forAll(f, fp)
-    {
-        const label pointi = f[fp];
-
-        const labelList& pointNbs = patch.pointFaces()[pointi];
-
-        forAll(pointNbs, nbI)
-        {
-            const label facei = pointNbs[nbI];
-
-            // Check for facei in edge-neighbours part of neighbours
-            if (findIndex(SubList<label>(neighbours, nEdgeNbs), facei) == -1)
-            {
-                neighbours.append(facei);
-            }
-        }
-    }
-}
-
-
-Foam::label Foam::patchDistFuncs::maxPatchSize
-(
-    const polyMesh& mesh,
-    const labelHashSet& patchIDs
-)
-{
-    label maxSize = 0;
-
-    forAllConstIter(labelHashSet, patchIDs, iter)
-    {
-        maxSize = Foam::max(maxSize, mesh.boundaryMesh()[iter.key()].size());
-    }
-
-    return maxSize;
-}
-
-
-// ************************************************************************* //
diff --git a/src/meshTools/patchDist/patchDistFuncs/patchDistFuncs.H b/src/meshTools/patchDist/patchDistFuncs/patchDistFuncs.H
deleted file mode 100644
index 8da1882346..0000000000
--- a/src/meshTools/patchDist/patchDistFuncs/patchDistFuncs.H
+++ /dev/null
@@ -1,155 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-Class
-    Foam::patchDistFuncs
-
-Description
-    Collection of functions used in patch distance calculation.
-
-SourceFiles
-    patchDistFuncs.C
-    patchDistFuncsTemplates.C
-
-\*---------------------------------------------------------------------------*/
-
-#ifndef patchDistFuncs_H
-#define patchDistFuncs_H
-
-#include "scalarField.H"
-#include "HashSet.H"
-#include "Map.H"
-#include "wordReList.H"
-#include "scalarField.H"
-#include "FieldField.H"
-#include "point.H"
-#include "labelPair.H"
-#include "primitivePatch.H"
-#include "className.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-namespace Foam
-{
-
-// Forward declaration of classes
-class polyMesh;
-class polyPatch;
-class polyBoundaryMesh;
-
-namespace patchDistFuncs
-{
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-template<class Type>
-struct NoMap
-{
-    inline bool insert(const label, const Type&)
-    {
-        return false;
-    }
-
-    inline bool found(const label)
-    {
-        return false;
-    }
-
-    static NoMap<Type> null;
-};
-
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-//- Calculate smallest true distance (and face index) from pt to faces
-//  wallFaces.
-scalar smallestDist
-(
-    const point& p,
-    const polyPatch& patch,
-    const labelUList& wallFaces,
-    label& patchFacei
-);
-
-// Get point neighbours of patchFacei (including patchFacei). Note: Uses a
-// linear search to determine uniqueness. For polygonal faces this might be
-// quite inefficient.
-void getPointNeighbours
-(
-    const primitivePatch&,
-    const label patchFacei,
-    DynamicList<label>& neighbours
-);
-
-//- Size of largest patch (out of supplied subset of patches)
-label maxPatchSize(const polyMesh& mesh, const labelHashSet& patchIDs);
-
-//- Correct all cells connected to boundary (via face). Sets values in
-//  wallDistCorrected. Sets nearest wallFace in nearestPatchAndFace.
-template<template<class> class MapType=NoMap>
-void correctBoundaryFaceCells
-(
-    const polyMesh& mesh,
-    const labelHashSet& patchIDs,
-    scalarField& wallDistCorrected,
-    MapType<labelPair>& nearestPatchAndFace = NoMap<labelPair>::null
-);
-
-//- Correct all face-cells connected to boundary. Sets values in
-//  wallDistCorrected. Sets nearest wallFace in nearestPatchAndFace.
-template<template<class> class PatchField, template<class> class MapType=NoMap>
-void correctBoundaryFaceFaceCells
-(
-    const polyMesh& mesh,
-    const labelHashSet& patchIDs,
-    FieldField<PatchField, scalar>& wallDistCorrected,
-    MapType<labelPair>& nearestPatchAndFace = NoMap<labelPair>::null
-);
-
-//- Correct all cells connected to wall (via point). Sets values in
-//  wallDistCorrected. Uses/sets nearest wallFace in nearestPatchAndFace.
-template<template<class> class MapType=NoMap>
-void correctBoundaryPointCells
-(
-    const polyMesh& mesh,
-    const labelHashSet& patchIDs,
-    scalarField& wallDistCorrected,
-    MapType<labelPair>& nearestPatchAndFace = NoMap<labelPair>::null
-);
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace patchDistFuncs
-} // End namespace Foam
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#ifdef NoRepository
-    #include "patchDistFuncsTemplates.C"
-#endif
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#endif
-
-// ************************************************************************* //
diff --git a/src/meshTools/patchDist/patchDistFuncs/patchDistFuncsTemplates.C b/src/meshTools/patchDist/patchDistFuncs/patchDistFuncsTemplates.C
deleted file mode 100644
index 03be10a0b8..0000000000
--- a/src/meshTools/patchDist/patchDistFuncs/patchDistFuncsTemplates.C
+++ /dev/null
@@ -1,196 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-\*---------------------------------------------------------------------------*/
-
-#include "patchDistFuncs.H"
-#include "polyMesh.H"
-
-// * * * * * * * * * * * * * * * Global Functions  * * * * * * * * * * * * * //
-
-template<template<class> class MapType>
-void Foam::patchDistFuncs::correctBoundaryFaceCells
-(
-    const polyMesh& mesh,
-    const labelHashSet& patchIDs,
-    scalarField& wallDistCorrected,
-    MapType<labelPair>& nearestPatchAndFace
-)
-{
-    // Size neighbours array for maximum possible (= size of largest patch)
-    DynamicList<label> neighbours(maxPatchSize(mesh, patchIDs));
-
-    // Correct all cells with face on wall
-    const vectorField& cellCentres = mesh.cellCentres();
-
-    forAllConstIter(labelHashSet, patchIDs, iter)
-    {
-        const label patchi = iter.key();
-        const polyPatch& patch = mesh.boundaryMesh()[patchi];
-
-        // Check cells with face on wall
-        forAll(patch, patchFacei)
-        {
-            const label celli = patch.faceCells()[patchFacei];
-
-            getPointNeighbours
-            (
-                patch,
-                patchFacei,
-                neighbours
-            );
-
-            label minPatchFacei = -1;
-
-            wallDistCorrected[celli] =
-                smallestDist
-                (
-                    cellCentres[celli],
-                    patch,
-                    neighbours,
-                    minPatchFacei
-                );
-
-            // Store wallCell and its nearest neighbour
-            nearestPatchAndFace.insert
-            (
-                celli,
-                labelPair(patchi, minPatchFacei)
-            );
-        }
-    }
-}
-
-
-template<template<class> class PatchField, template<class> class MapType>
-void Foam::patchDistFuncs::correctBoundaryFaceFaceCells
-(
-    const polyMesh& mesh,
-    const labelHashSet& patchIDs,
-    FieldField<PatchField, scalar>& wallDistCorrected,
-    MapType<labelPair>& nearestPatchAndFace
-)
-{
-    // Size neighbours array for maximum possible (= size of largest patch)
-    DynamicList<label> neighbours(maxPatchSize(mesh, patchIDs));
-
-    // Correct all faces on a wall
-    const vectorField& cellCentres = mesh.cellCentres();
-
-    forAllConstIter(labelHashSet, patchIDs, iter)
-    {
-        const label patchi = iter.key();
-        const polyPatch& patch = mesh.boundaryMesh()[patchi];
-
-        // Check cells with face on wall
-        forAll(patch, patchFacei)
-        {
-            const label celli = patch.faceCells()[patchFacei];
-
-            getPointNeighbours
-            (
-                patch,
-                patchFacei,
-                neighbours
-            );
-
-            label minPatchFacei = -1;
-
-            wallDistCorrected[patchi][patchFacei] =
-                smallestDist
-                (
-                    cellCentres[celli],
-                    patch,
-                    neighbours,
-                    minPatchFacei
-                );
-
-            // Store wallCell and its nearest neighbour
-            nearestPatchAndFace.insert
-            (
-                celli,
-                labelPair(patchi, minPatchFacei)
-            );
-        }
-    }
-}
-
-
-template<template<class> class MapType>
-void Foam::patchDistFuncs::correctBoundaryPointCells
-(
-    const polyMesh& mesh,
-    const labelHashSet& patchIDs,
-    scalarField& wallDistCorrected,
-    MapType<labelPair>& nearestPatchAndFace
-)
-{
-    // Correct all (non-visited) cells with point on wall
-    const vectorField& cellCentres = mesh.cellCentres();
-
-    forAllConstIter(labelHashSet, patchIDs, iter)
-    {
-        const label patchi = iter.key();
-        const polyPatch& patch = mesh.boundaryMesh()[patchi];
-
-        const labelList& meshPoints = patch.meshPoints();
-        const labelListList& pointFaces = patch.pointFaces();
-
-        forAll(meshPoints, meshPointi)
-        {
-            const labelList& neighbours =
-                mesh.pointCells(meshPoints[meshPointi]);
-
-            forAll(neighbours, neighbourI)
-            {
-                const label celli = neighbours[neighbourI];
-
-                if (!nearestPatchAndFace.found(celli))
-                {
-                    const labelList& wallFaces = pointFaces[meshPointi];
-
-                    label minPatchFacei = -1;
-
-                    wallDistCorrected[celli] =
-                        smallestDist
-                        (
-                            cellCentres[celli],
-                            patch,
-                            wallFaces,
-                            minPatchFacei
-                        );
-
-                    // Store wallCell and its nearest neighbour
-                    nearestPatchAndFace.insert
-                    (
-                        celli,
-                        labelPair(patchi, minPatchFacei)
-                    );
-                }
-            }
-        }
-    }
-}
-
-
-// ************************************************************************* //
diff --git a/src/meshTools/patchDist/patchDistWave/patchDistWaveTemplates.C b/src/meshTools/patchDist/patchDistWave/patchDistWave.C
similarity index 50%
rename from src/meshTools/patchDist/patchDistWave/patchDistWaveTemplates.C
rename to src/meshTools/patchDist/patchDistWave/patchDistWave.C
index 5766c5c0da..bf216dc3bc 100644
--- a/src/meshTools/patchDist/patchDistWave/patchDistWaveTemplates.C
+++ b/src/meshTools/patchDist/patchDistWave/patchDistWave.C
@@ -24,18 +24,15 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "patchDistWave.H"
-#include "patchDistFuncs.H"
+#include "FaceCellWave.H"
+#include "wallPoint.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-template<class PatchPointType, class ... InitialPatchData>
-void Foam::patchDistWave::setChangedFaces
+Foam::labelList Foam::patchDistWave::getChangedFaces
 (
     const polyMesh& mesh,
-    const labelHashSet& patchIDs,
-    labelList& changedFaces,
-    List<PatchPointType>& changedFacesInfo,
-    const InitialPatchData& ... initialPatchData
+    const labelHashSet& patchIDs
 )
 {
     label nChangedFaces = 0;
@@ -44,9 +41,7 @@ void Foam::patchDistWave::setChangedFaces
         nChangedFaces += mesh.boundaryMesh()[iter.key()].size();
     }
 
-    changedFaces.resize(nChangedFaces);
-    changedFacesInfo.resize(nChangedFaces);
-
+    labelList changedFaces(nChangedFaces);
     label changedFacei = 0;
 
     forAllConstIter(labelHashSet, patchIDs, iter)
@@ -61,117 +56,65 @@ void Foam::patchDistWave::setChangedFaces
 
             changedFaces[changedFacei] = meshFacei;
 
-            changedFacesInfo[changedFacei] =
-                PatchPointType
-                (
-                    patch.faceCentres()[patchFacei],
-                    initialPatchData[patchi][patchFacei] ...,
-                    scalar(0)
-                );
-
             changedFacei++;
         }
     }
+
+    return changedFaces;
 }
 
 
-template
-<
-    class PatchPointType,
-    class TrackingData,
-    class DataType,
-    class DataMethod
->
-Foam::label Foam::patchDistWave::getCellValues
-(
-    FaceCellWave<PatchPointType, TrackingData>& waveInfo,
-    Field<DataType>& cellValues,
-    DataMethod method,
-    const DataType& stabiliseValue
-)
-{
-    const List<PatchPointType>& cellInfo = waveInfo.allCellInfo();
-
-    label nInvalid = 0;
-
-    forAll(cellInfo, celli)
-    {
-        cellValues[celli] =
-            (cellInfo[celli].*method)(waveInfo.data())
-          + stabiliseValue;
-
-        nInvalid += !cellInfo[celli].valid(waveInfo.data());
-    }
-
-    return nInvalid;
-}
-
-
-template<class PatchPointType, class TrackingData>
 Foam::label Foam::patchDistWave::wave
 (
     const polyMesh& mesh,
-    const labelHashSet& patchIDs,
-    scalarField& cellDistance,
-    const bool correct,
-    TrackingData& td
+    const labelList& changedFaces,
+    scalarField& cellDistance
 )
 {
     // Initialise changedFacesInfo to face centres on patches
-    List<PatchPointType> changedFacesInfo;
-    labelList changedFaces;
-    setChangedFaces
-    (
-        mesh,
-        patchIDs,
-        changedFaces,
-        changedFacesInfo
-    );
+    List<wallPoint> changedFacesInfo;
+    forAll(changedFaces, changedFacei)
+    {
+        const label facei = changedFaces[changedFacei];
+
+        changedFacesInfo[changedFacei] =
+            wallPoint(mesh.faceCentres()[facei], scalar(0));
+    }
 
     // Do calculate patch distance by 'growing' from faces.
-    List<PatchPointType> faceInfo(mesh.nFaces()), cellInfo(mesh.nCells());
-    FaceCellWave<PatchPointType, TrackingData> wave
+    List<wallPoint> faceInfo(mesh.nFaces()), cellInfo(mesh.nCells());
+    FaceCellWave<wallPoint> wave
     (
         mesh,
         changedFaces,
         changedFacesInfo,
         faceInfo,
         cellInfo,
-        mesh.globalData().nTotalCells() + 1, // max iterations
-        td
+        mesh.globalData().nTotalCells() + 1 // max iterations
     );
 
-    // Copy distance into return field
-    const label nUnset =
-        getCellValues
-        (
-            wave,
-            cellDistance,
-            &PatchPointType::template dist<TrackingData>
-        );
-
-    // Correct patch cells for true distance
-    if (correct)
+    // Copy distances into field
+    label nUnset = 0;
+    forAll(cellInfo, celli)
     {
-        Map<labelPair> nearestFace(2*changedFacesInfo.size());
-        patchDistFuncs::correctBoundaryFaceCells
-        (
-            mesh,
-            patchIDs,
-            cellDistance,
-            nearestFace
-        );
-        patchDistFuncs::correctBoundaryPointCells
-        (
-            mesh,
-            patchIDs,
-            cellDistance,
-            nearestFace
-        );
+        nUnset += !cellInfo[celli].valid(wave.data());
+
+        cellDistance[celli] = cellInfo[celli].dist(wave.data());
     }
 
     return nUnset;
 }
 
 
+Foam::label Foam::patchDistWave::calculate
+(
+    const polyMesh& mesh,
+    const labelHashSet& patchIDs,
+    scalarField& cellDistance
+)
+{
+    return wave(mesh, getChangedFaces(mesh, patchIDs), cellDistance);
+}
+
+
 // ************************************************************************* //
diff --git a/src/meshTools/patchDist/patchDistWave/patchDistWave.H b/src/meshTools/patchDist/patchDistWave/patchDistWave.H
index bbd8bb92ba..26f5a347e8 100644
--- a/src/meshTools/patchDist/patchDistWave/patchDistWave.H
+++ b/src/meshTools/patchDist/patchDistWave/patchDistWave.H
@@ -37,10 +37,6 @@ SourceFiles
 #define patchDistWave_H
 
 #include "polyMesh.H"
-#include "FaceCellWave.H"
-#include "Field.H"
-#include "FieldField.H"
-#include "UPtrList.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -51,42 +47,27 @@ namespace patchDistWave
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-//- Set initial set of changed faces
-template<class PatchPointType, class ... InitialPatchData>
-void setChangedFaces
+//- Get initial set of changed faces
+labelList getChangedFaces
 (
     const polyMesh& mesh,
-    const labelHashSet& patchIDs,
-    labelList& changedFaces,
-    List<PatchPointType>& faceDist,
-    const InitialPatchData& ... initialPatchData
+    const labelHashSet& patchIDs
 );
 
-//- Copy FaceCellWave values into the cell fields
-template
-<
-    class PatchPointType,
-    class TrackingData,
-    class DataType,
-    class DataMethod
->
-label getCellValues
-(
-    FaceCellWave<PatchPointType, TrackingData>& waveInfo,
-    Field<DataType>& cellValues,
-    DataMethod method,
-    const DataType& stabiliseValue = pTraits<DataType>::zero
-);
-
-//- Wave distance data from the patches to the cells
-template<class PatchPointType, class TrackingData = int>
+//- Wave distance data from faces
 label wave
+(
+    const polyMesh& mesh,
+    const labelList& changedFaces,
+    scalarField& cellDistance
+);
+
+//- Calculate distance data from patches
+label calculate
 (
     const polyMesh& mesh,
     const labelHashSet& patchIDs,
-    scalarField& cellDistance,
-    bool correct = true,
-    TrackingData& td = FaceCellWave<PatchPointType>::defaultTrackingData_
+    scalarField& cellDistance
 );
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@@ -96,12 +77,6 @@ label wave
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-#ifdef NoRepository
-    #include "patchDistWaveTemplates.C"
-#endif
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
 #endif
 
 // ************************************************************************* //
diff --git a/src/meshTools/patchDist/wallFace/wallFace.H b/src/meshTools/patchDist/wallFace/wallFace.H
new file mode 100644
index 0000000000..e4473f274b
--- /dev/null
+++ b/src/meshTools/patchDist/wallFace/wallFace.H
@@ -0,0 +1,253 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::wallFace
+
+Description
+    Holds information regarding nearest wall point. Used in wall distance
+    calculation.
+
+SourceFiles
+    wallFaceI.H
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef wallFace_H
+#define wallFace_H
+
+#include "pointField.H"
+#include "face.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// Forward declaration of classes
+class polyPatch;
+class polyMesh;
+class transformer;
+
+// Forward declaration of friend functions and operators
+template<class Derived>
+class WallFaceBase;
+template<class Derived>
+Ostream& operator<<(Ostream&, const WallFaceBase<Derived>&);
+template<class Derived>
+Istream& operator>>(Istream&, WallFaceBase<Derived>&);
+
+/*---------------------------------------------------------------------------*\
+                          Class WallFaceBase Declaration
+\*---------------------------------------------------------------------------*/
+
+template<class Derived>
+class WallFaceBase
+{
+    // Private Data
+
+        //- Face points
+        pointField points_;
+
+        //- Normal distance (squared) from cell center to face
+        scalar distSqr_;
+
+
+protected:
+
+    // Protected Member Functions
+
+        //- ...
+        template<class TrackingData>
+        inline bool update
+        (
+            const point& pt,
+            const WallFaceBase<Derived>& w2,
+            const scalar tol,
+            TrackingData& td
+        );
+
+
+public:
+
+    // Constructors
+
+        //- Construct null
+        inline WallFaceBase();
+
+        //- Construct from face, distance
+        inline WallFaceBase
+        (
+            const face& f,
+            const pointField& points,
+            const scalar distSqr
+        );
+
+        //- Construct from face, distance
+        inline WallFaceBase
+        (
+            const face& f,
+            const pointField& points,
+            const point& centre,
+            const scalar distSqr
+        );
+
+
+    // Member Functions
+
+        // Access
+
+            inline const pointField& points() const;
+
+            inline pointField& points();
+
+            inline scalar distSqr() const;
+
+            inline scalar& distSqr();
+
+            template<class TrackingData>
+            inline scalar dist(TrackingData& td) const;
+
+
+        // Needed by FaceCellWave
+
+            //- Check whether the WallFaceBase has been changed at all or still
+            //  contains original (invalid) value.
+            template<class TrackingData>
+            inline bool valid(TrackingData& td) const;
+
+            //- Check for identical geometrical data. Used for checking
+            //  consistency across cyclics.
+            template<class TrackingData>
+            inline bool sameGeometry
+            (
+                const polyMesh&,
+                const WallFaceBase<Derived>&,
+                const scalar,
+                TrackingData& td
+            ) const;
+
+            //- Transform across an interface
+            template<class TrackingData>
+            inline void transform
+            (
+                const polyPatch& patch,
+                const label patchFacei,
+                const transformer& transform,
+                TrackingData& td
+            );
+
+            //- Influence of neighbouring face
+            template<class TrackingData>
+            inline bool updateCell
+            (
+                const polyMesh&,
+                const label thisCelli,
+                const label neighbourFacei,
+                const WallFaceBase<Derived>& neighbourInfo,
+                const scalar tol,
+                TrackingData& td
+            );
+
+            //- Influence of neighbouring cell
+            template<class TrackingData>
+            inline bool updateFace
+            (
+                const polyMesh&,
+                const label thisFacei,
+                const label neighbourCelli,
+                const WallFaceBase<Derived>& neighbourInfo,
+                const scalar tol,
+                TrackingData& td
+            );
+
+            //- Influence of different value on same face
+            template<class TrackingData>
+            inline bool updateFace
+            (
+                const polyMesh&,
+                const label thisFacei,
+                const WallFaceBase<Derived>& neighbourInfo,
+                const scalar tol,
+                TrackingData& td
+            );
+
+            //- Test equality
+            template<class TrackingData>
+            inline bool equal
+            (
+                const WallFaceBase<Derived>&,
+                TrackingData& td
+            ) const;
+
+
+    // Member Operators
+
+        inline bool operator==(const WallFaceBase<Derived>&) const;
+        inline bool operator!=(const WallFaceBase<Derived>&) const;
+
+
+    // IOstream Operators
+
+        friend Ostream& operator<< <Derived>
+        (
+            Ostream&,
+            const WallFaceBase<Derived>&
+        );
+
+        friend Istream& operator>> <Derived>
+        (
+            Istream&,
+            WallFaceBase<Derived>&
+        );
+};
+
+/*---------------------------------------------------------------------------*\
+                          Class wallFace Declaration
+\*---------------------------------------------------------------------------*/
+
+class wallFace
+:
+    public WallFaceBase<wallFace>
+{
+    public:
+
+        using WallFaceBase<wallFace>::WallFaceBase;
+
+        template<class Derived> using type = WallFaceBase<Derived>;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#include "wallFaceI.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/meshTools/patchDist/wallFace/wallFaceI.H b/src/meshTools/patchDist/wallFace/wallFaceI.H
new file mode 100644
index 0000000000..ba4b9834a7
--- /dev/null
+++ b/src/meshTools/patchDist/wallFace/wallFaceI.H
@@ -0,0 +1,320 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     | Website:  https://openfoam.org
+    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "wallFace.H"
+#include "polyMesh.H"
+#include "transformer.H"
+
+// * * * * * * * * * * * *  Protected Member Functions * * * * * * * * * * * //
+
+template<class Derived>
+template<class TrackingData>
+inline bool Foam::WallFaceBase<Derived>::update
+(
+    const point& pt,
+    const WallFaceBase<Derived>& w2,
+    const scalar tol,
+    TrackingData& td
+)
+{
+    const scalar dist2 =
+        sqr
+        (
+            face(identity(w2.points().size()))
+           .nearestPoint(pt, w2.points())
+           .distance()
+        );
+
+    if (valid(td))
+    {
+        scalar diff = distSqr() - dist2;
+
+        if (diff < 0)
+        {
+            // already nearer to pt
+            return false;
+        }
+
+        if ((diff < small) || ((distSqr() > small) && (diff/distSqr() < tol)))
+        {
+            // don't propagate small changes
+            return false;
+        }
+    }
+
+    // Either *this is not yet valid or w2 is closer
+    distSqr() = dist2;
+    points() = w2.points();
+
+    return true;
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+template<class Derived>
+inline Foam::WallFaceBase<Derived>::WallFaceBase()
+:
+    points_(0),
+    distSqr_(-great)
+{}
+
+
+template<class Derived>
+inline Foam::WallFaceBase<Derived>::WallFaceBase
+(
+    const face& f,
+    const pointField& points,
+    const scalar distSqr
+)
+:
+    points_(f.points(points)),
+    distSqr_(distSqr)
+{}
+
+
+template<class Derived>
+inline Foam::WallFaceBase<Derived>::WallFaceBase
+(
+    const face& f,
+    const pointField& points,
+    const point& centre,
+    const scalar distSqr
+)
+:
+    points_(f.points(points)),
+    distSqr_(distSqr)
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+template<class Derived>
+inline const Foam::pointField& Foam::WallFaceBase<Derived>::points() const
+{
+    return points_;
+}
+
+
+template<class Derived>
+inline Foam::pointField& Foam::WallFaceBase<Derived>::points()
+{
+    return points_;
+}
+
+
+template<class Derived>
+inline Foam::scalar Foam::WallFaceBase<Derived>::distSqr() const
+{
+    return distSqr_;
+}
+
+
+template<class Derived>
+inline Foam::scalar& Foam::WallFaceBase<Derived>::distSqr()
+{
+    return distSqr_;
+}
+
+
+template<class Derived>
+template<class TrackingData>
+inline Foam::scalar Foam::WallFaceBase<Derived>::dist(TrackingData& td) const
+{
+    return valid(td) ? sqrt(distSqr_) : great;
+}
+
+
+template<class Derived>
+template<class TrackingData>
+inline bool Foam::WallFaceBase<Derived>::valid(TrackingData& td) const
+{
+    return distSqr_ > -small;
+}
+
+
+template<class Derived>
+template<class TrackingData>
+inline bool Foam::WallFaceBase<Derived>::sameGeometry
+(
+    const polyMesh&,
+    const WallFaceBase<Derived>& w2,
+    const scalar tol,
+    TrackingData& td
+) const
+{
+    scalar diff = mag(distSqr() - w2.distSqr());
+
+    if (diff < small)
+    {
+        return true;
+    }
+    else
+    {
+        if ((distSqr() > small) && ((diff/distSqr()) < tol))
+        {
+            return true;
+        }
+        else
+        {
+            return false;
+        }
+    }
+}
+
+
+template<class Derived>
+template<class TrackingData>
+inline void Foam::WallFaceBase<Derived>::transform
+(
+    const polyPatch& patch,
+    const label patchFacei,
+    const transformer& transform,
+    TrackingData& td
+)
+{
+    transform.transformPosition(points_, points_);
+}
+
+
+template<class Derived>
+template<class TrackingData>
+inline bool Foam::WallFaceBase<Derived>::updateCell
+(
+    const polyMesh& mesh,
+    const label thisCelli,
+    const label neighbourFacei,
+    const WallFaceBase<Derived>& neighbourWallInfo,
+    const scalar tol,
+    TrackingData& td
+)
+{
+    return
+        static_cast<Derived&>(*this).update
+        (
+            mesh.cellCentres()[thisCelli],
+            neighbourWallInfo,
+            tol,
+            td
+        );
+}
+
+
+template<class Derived>
+template<class TrackingData>
+inline bool Foam::WallFaceBase<Derived>::updateFace
+(
+    const polyMesh& mesh,
+    const label thisFacei,
+    const label neighbourCelli,
+    const WallFaceBase<Derived>& neighbourWallInfo,
+    const scalar tol,
+    TrackingData& td
+)
+{
+    return
+        static_cast<Derived&>(*this).update
+        (
+            mesh.faceCentres()[thisFacei],
+            neighbourWallInfo,
+            tol,
+            td
+        );
+}
+
+
+template<class Derived>
+template<class TrackingData>
+inline bool Foam::WallFaceBase<Derived>::updateFace
+(
+    const polyMesh& mesh,
+    const label thisFacei,
+    const WallFaceBase<Derived>& neighbourWallInfo,
+    const scalar tol,
+    TrackingData& td
+)
+{
+    return
+        static_cast<Derived&>(*this).update
+        (
+            mesh.faceCentres()[thisFacei],
+            neighbourWallInfo,
+            tol,
+            td
+        );
+}
+
+
+template<class Derived>
+template<class TrackingData>
+inline bool Foam::WallFaceBase<Derived>::equal
+(
+    const WallFaceBase<Derived>& rhs,
+    TrackingData& td
+) const
+{
+    return operator==(rhs);
+}
+
+
+// * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
+
+template<class Derived>
+inline bool Foam::WallFaceBase<Derived>::operator==
+(
+    const Foam::WallFaceBase<Derived>& rhs
+) const
+{
+    return points() == rhs.points();
+}
+
+
+template<class Derived>
+inline bool Foam::WallFaceBase<Derived>::operator!=
+(
+    const Foam::WallFaceBase<Derived>& rhs
+) const
+{
+    return !(*this == rhs);
+}
+
+
+// * * * * * * * * * * * * * * * Friend Operators  * * * * * * * * * * * * * //
+
+template<class Derived>
+Foam::Ostream& Foam::operator<<(Ostream& os, const WallFaceBase<Derived>& w)
+{
+    return os << w.points() << token::SPACE << w.distSqr();
+}
+
+
+template<class Derived>
+Foam::Istream& Foam::operator>>(Istream& is, WallFaceBase<Derived>& w)
+{
+    return is >> w.points() >> w.distSqr();
+}
+
+
+// ************************************************************************* //
diff --git a/src/meshTools/patchDist/wallPoint/wallPoint.H b/src/meshTools/patchDist/wallPoint/wallPoint.H
index 6e8f686ad4..f2d7ec7325 100644
--- a/src/meshTools/patchDist/wallPoint/wallPoint.H
+++ b/src/meshTools/patchDist/wallPoint/wallPoint.H
@@ -30,17 +30,14 @@ Description
 
 SourceFiles
     wallPointI.H
-    wallPoint.C
 
 \*---------------------------------------------------------------------------*/
 
 #ifndef wallPoint_H
 #define wallPoint_H
 
-#include "point.H"
-#include "label.H"
-#include "scalar.H"
-#include "tensor.H"
+#include "pointField.H"
+#include "face.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -52,20 +49,20 @@ class polyPatch;
 class polyMesh;
 class transformer;
 
-
 // Forward declaration of friend functions and operators
-
-class wallPoint;
-
-Ostream& operator<<(Ostream&, const wallPoint&);
-Istream& operator>>(Istream&, wallPoint&);
-
+template<class Derived>
+class WallPointBase;
+template<class Derived>
+Ostream& operator<<(Ostream&, const WallPointBase<Derived>&);
+template<class Derived>
+Istream& operator>>(Istream&, WallPointBase<Derived>&);
 
 /*---------------------------------------------------------------------------*\
-                          Class wallPoint Declaration
+                          Class WallPointBase Declaration
 \*---------------------------------------------------------------------------*/
 
-class wallPoint
+template<class Derived>
+class WallPointBase
 {
     // Private Data
 
@@ -87,7 +84,7 @@ protected:
         inline bool update
         (
             const point&,
-            const wallPoint& w2,
+            const WallPointBase<Derived>& w2,
             const scalar tol,
             TrackingData& td
         );
@@ -98,10 +95,19 @@ public:
     // Constructors
 
         //- Construct null
-        inline wallPoint();
+        inline WallPointBase();
 
         //- Construct from origin, distance
-        inline wallPoint(const point& origin, const scalar distSqr);
+        inline WallPointBase(const point& origin, const scalar distSqr);
+
+        //- Construct from face, distance
+        inline WallPointBase
+        (
+            const face& f,
+            const pointField& ps,
+            const point& centre,
+            const scalar distSqr
+        );
 
 
     // Member Functions
@@ -132,7 +138,7 @@ public:
             inline bool sameGeometry
             (
                 const polyMesh&,
-                const wallPoint&,
+                const WallPointBase<Derived>&,
                 const scalar,
                 TrackingData& td
             ) const;
@@ -154,7 +160,7 @@ public:
                 const polyMesh&,
                 const label thisCelli,
                 const label neighbourFacei,
-                const wallPoint& neighbourInfo,
+                const WallPointBase<Derived>& neighbourInfo,
                 const scalar tol,
                 TrackingData& td
             );
@@ -166,7 +172,7 @@ public:
                 const polyMesh&,
                 const label thisFacei,
                 const label neighbourCelli,
-                const wallPoint& neighbourInfo,
+                const WallPointBase<Derived>& neighbourInfo,
                 const scalar tol,
                 TrackingData& td
             );
@@ -177,27 +183,55 @@ public:
             (
                 const polyMesh&,
                 const label thisFacei,
-                const wallPoint& neighbourInfo,
+                const WallPointBase<Derived>& neighbourInfo,
                 const scalar tol,
                 TrackingData& td
             );
 
             //- Same (like operator==)
             template<class TrackingData>
-            inline bool equal(const wallPoint&, TrackingData& td) const;
+            inline bool equal
+            (
+                const WallPointBase<Derived>&,
+                TrackingData& td
+            ) const;
 
 
     // Member Operators
 
-        // Needed for List IO
-        inline bool operator==(const wallPoint&) const;
-        inline bool operator!=(const wallPoint&) const;
+        inline bool operator==(const WallPointBase<Derived>&) const;
+        inline bool operator!=(const WallPointBase<Derived>&) const;
 
 
     // IOstream Operators
 
-        friend Ostream& operator<<(Ostream&, const wallPoint&);
-        friend Istream& operator>>(Istream&, wallPoint&);
+        friend Ostream& operator<< <Derived>
+        (
+            Ostream&,
+            const WallPointBase<Derived>&
+        );
+
+        friend Istream& operator>> <Derived>
+        (
+            Istream&,
+            WallPointBase<Derived>&
+        );
+};
+
+
+/*---------------------------------------------------------------------------*\
+                          Class wallPoint Declaration
+\*---------------------------------------------------------------------------*/
+
+class wallPoint
+:
+    public WallPointBase<wallPoint>
+{
+    public:
+
+        using WallPointBase<wallPoint>::WallPointBase;
+
+        template<class Derived> using type = WallPointBase<Derived>;
 };
 
 
diff --git a/src/meshTools/patchDist/wallPoint/wallPointI.H b/src/meshTools/patchDist/wallPoint/wallPointI.H
index e5ecfb97c5..e88bfff619 100644
--- a/src/meshTools/patchDist/wallPoint/wallPointI.H
+++ b/src/meshTools/patchDist/wallPoint/wallPointI.H
@@ -23,126 +23,138 @@ License
 
 \*---------------------------------------------------------------------------*/
 
+#include "wallPoint.H"
 #include "polyMesh.H"
 #include "transformer.H"
 #include "SubField.H"
 
 // * * * * * * * * * * * *  Protected Member Functions * * * * * * * * * * * //
 
-// Update this with w2 if w2 nearer to pt.
+template<class Derived>
 template<class TrackingData>
-inline bool Foam::wallPoint::update
+inline bool Foam::WallPointBase<Derived>::update
 (
     const point& pt,
-    const wallPoint& w2,
+    const WallPointBase<Derived>& w2,
     const scalar tol,
     TrackingData& td
 )
 {
-    // Already done in calling algorithm
-    // if (w2.origin() == origin_)
-    //{
-    //    // Shortcut. Same input so same distance.
-    //    return false;
-    //}
+    const scalar dist2 = magSqr(pt - w2.origin());
 
-    scalar dist2 = magSqr(pt - w2.origin());
-
-    if (!valid(td))
+    if (valid(td))
     {
-        // current not yet set so use any value
-        distSqr_ = dist2;
-        origin_ = w2.origin();
+        const scalar diff = distSqr() - dist2;
 
-        return true;
+        if (diff < 0)
+        {
+            // already nearer to pt
+            return false;
+        }
+
+        if ((diff < small) || ((distSqr() > small) && (diff/distSqr() < tol)))
+        {
+            // don't propagate small changes
+            return false;
+        }
     }
 
-    scalar diff = distSqr_ - dist2;
+    // Either *this is not yet valid or w2 is closer
+    distSqr() = dist2;
+    origin() = w2.origin();
 
-    if (diff < 0)
-    {
-        // already nearer to pt
-        return false;
-    }
-
-    if ((diff < small) || ((distSqr_ > small) && (diff/distSqr_ < tol)))
-    {
-        // don't propagate small changes
-        return false;
-    }
-    else
-    {
-        // update with new values
-        distSqr_ = dist2;
-        origin_ = w2.origin();
-
-        return true;
-    }
+    return true;
 }
 
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
-inline Foam::wallPoint::wallPoint()
+template<class Derived>
+inline Foam::WallPointBase<Derived>::WallPointBase()
 :
     origin_(point::max),
     distSqr_(-great)
 {}
 
 
-inline Foam::wallPoint::wallPoint(const point& origin, const scalar distSqr)
+template<class Derived>
+inline Foam::WallPointBase<Derived>::WallPointBase
+(
+    const point& origin,
+    const scalar distSqr
+)
 :
     origin_(origin),
     distSqr_(distSqr)
 {}
 
 
+template<class Derived>
+inline Foam::WallPointBase<Derived>::WallPointBase
+(
+    const face& f,
+    const pointField& points,
+    const point& centre,
+    const scalar distSqr
+)
+:
+    origin_(centre),
+    distSqr_(distSqr)
+{}
+
+
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
-inline const Foam::point& Foam::wallPoint::origin() const
+template<class Derived>
+inline const Foam::point& Foam::WallPointBase<Derived>::origin() const
 {
     return origin_;
 }
 
 
-inline Foam::point& Foam::wallPoint::origin()
+template<class Derived>
+inline Foam::point& Foam::WallPointBase<Derived>::origin()
 {
     return origin_;
 }
 
 
-inline Foam::scalar Foam::wallPoint::distSqr() const
+template<class Derived>
+inline Foam::scalar Foam::WallPointBase<Derived>::distSqr() const
 {
     return distSqr_;
 }
 
 
-inline Foam::scalar& Foam::wallPoint::distSqr()
+template<class Derived>
+inline Foam::scalar& Foam::WallPointBase<Derived>::distSqr()
 {
     return distSqr_;
 }
 
 
+template<class Derived>
 template<class TrackingData>
-inline Foam::scalar Foam::wallPoint::dist(TrackingData& td) const
+inline Foam::scalar Foam::WallPointBase<Derived>::dist(TrackingData& td) const
 {
     return valid(td) ? sqrt(distSqr_) : great;
 }
 
 
+template<class Derived>
 template<class TrackingData>
-inline bool Foam::wallPoint::valid(TrackingData& td) const
+inline bool Foam::WallPointBase<Derived>::valid(TrackingData& td) const
 {
     return distSqr_ > -small;
 }
 
 
-// Checks for cyclic faces
+template<class Derived>
 template<class TrackingData>
-inline bool Foam::wallPoint::sameGeometry
+inline bool Foam::WallPointBase<Derived>::sameGeometry
 (
     const polyMesh&,
-    const wallPoint& w2,
+    const WallPointBase<Derived>& w2,
     const scalar tol,
     TrackingData& td
 ) const
@@ -167,8 +179,9 @@ inline bool Foam::wallPoint::sameGeometry
 }
 
 
+template<class Derived>
 template<class TrackingData>
-inline void Foam::wallPoint::transform
+inline void Foam::WallPointBase<Derived>::transform
 (
     const polyPatch& patch,
     const label patchFacei,
@@ -181,43 +194,43 @@ inline void Foam::wallPoint::transform
 }
 
 
-// Update this with w2 if w2 nearer to pt.
+template<class Derived>
 template<class TrackingData>
-inline bool Foam::wallPoint::updateCell
+inline bool Foam::WallPointBase<Derived>::updateCell
 (
     const polyMesh& mesh,
     const label thisCelli,
     const label neighbourFacei,
-    const wallPoint& neighbourWallInfo,
+    const WallPointBase<Derived>& neighbourWallInfo,
     const scalar tol,
     TrackingData& td
 )
 {
     return
-        update
+        static_cast<Derived&>(*this).update
         (
             mesh.cellCentres()[thisCelli],
             neighbourWallInfo,
             tol,
             td
         );
-    }
+}
 
 
-// Update this with w2 if w2 nearer to pt.
+template<class Derived>
 template<class TrackingData>
-inline bool Foam::wallPoint::updateFace
+inline bool Foam::WallPointBase<Derived>::updateFace
 (
     const polyMesh& mesh,
     const label thisFacei,
     const label neighbourCelli,
-    const wallPoint& neighbourWallInfo,
+    const WallPointBase<Derived>& neighbourWallInfo,
     const scalar tol,
     TrackingData& td
 )
 {
     return
-        update
+        static_cast<Derived&>(*this).update
         (
             mesh.faceCentres()[thisFacei],
             neighbourWallInfo,
@@ -226,19 +239,20 @@ inline bool Foam::wallPoint::updateFace
         );
 }
 
-// Update this with w2 if w2 nearer to pt.
+
+template<class Derived>
 template<class TrackingData>
-inline bool Foam::wallPoint::updateFace
+inline bool Foam::WallPointBase<Derived>::updateFace
 (
     const polyMesh& mesh,
     const label thisFacei,
-    const wallPoint& neighbourWallInfo,
+    const WallPointBase<Derived>& neighbourWallInfo,
     const scalar tol,
     TrackingData& td
 )
 {
     return
-        update
+        static_cast<Derived&>(*this).update
         (
             mesh.faceCentres()[thisFacei],
             neighbourWallInfo,
@@ -248,10 +262,11 @@ inline bool Foam::wallPoint::updateFace
 }
 
 
+template<class Derived>
 template<class TrackingData>
-inline bool Foam::wallPoint::equal
+inline bool Foam::WallPointBase<Derived>::equal
 (
-    const wallPoint& rhs,
+    const WallPointBase<Derived>& rhs,
     TrackingData& td
 ) const
 {
@@ -261,16 +276,40 @@ inline bool Foam::wallPoint::equal
 
 // * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
 
-inline bool Foam::wallPoint::operator==(const Foam::wallPoint& rhs) const
+template<class Derived>
+inline bool Foam::WallPointBase<Derived>::operator==
+(
+    const Foam::WallPointBase<Derived>& rhs
+) const
 {
     return origin() == rhs.origin();
 }
 
 
-inline bool Foam::wallPoint::operator!=(const Foam::wallPoint& rhs) const
+template<class Derived>
+inline bool Foam::WallPointBase<Derived>::operator!=
+(
+    const Foam::WallPointBase<Derived>& rhs
+) const
 {
     return !(*this == rhs);
 }
 
 
+// * * * * * * * * * * * * * * * Friend Operators  * * * * * * * * * * * * * //
+
+template<class Derived>
+Foam::Ostream& Foam::operator<<(Ostream& os, const WallPointBase<Derived>& w)
+{
+    return os << w.origin() << token::SPACE << w.distSqr();
+}
+
+
+template<class Derived>
+Foam::Istream& Foam::operator>>(Istream& is, WallPointBase<Derived>& w)
+{
+    return is >> w.origin() >> w.distSqr();
+}
+
+
 // ************************************************************************* //
diff --git a/src/meshTools/sets/cellSources/patchDistanceToCell/patchDistanceToCell.C b/src/meshTools/sets/cellSources/patchDistanceToCell/patchDistanceToCell.C
index 4580147e32..9678b39995 100644
--- a/src/meshTools/sets/cellSources/patchDistanceToCell/patchDistanceToCell.C
+++ b/src/meshTools/sets/cellSources/patchDistanceToCell/patchDistanceToCell.C
@@ -43,7 +43,7 @@ void Foam::patchDistanceToCell::combine(topoSet& set, const bool add) const
 {
     // Mesh wave to determine wall distance
     scalarField distance(mesh_.nCells());
-    patchDistWave::wave<wallPoint>
+    patchDistWave::calculate
     (
         mesh_,
         mesh_.boundaryMesh().patchSet(patches_),