diff --git a/applications/utilities/mesh/generation/blockMesh/mergePatchPairs.H b/applications/utilities/mesh/generation/blockMesh/mergePatchPairs.H
index aa55debfb2..b60e16a4e3 100644
--- a/applications/utilities/mesh/generation/blockMesh/mergePatchPairs.H
+++ b/applications/utilities/mesh/generation/blockMesh/mergePatchPairs.H
@@ -101,8 +101,7 @@
                     new slidingInterface
                     (
                         "couple" + name(pairI),
-                        pairI,
-                        polyMeshAttacher,
+                        mesh,
                         mergeName + "MasterZone",
                         mergeName + "SlaveZone",
                         mergeName + "CutPointZone",
diff --git a/applications/utilities/mesh/generation/extrudeMesh/extrudeMesh.C b/applications/utilities/mesh/generation/extrudeMesh/extrudeMesh.C
index ac32641ecd..644607203d 100644
--- a/applications/utilities/mesh/generation/extrudeMesh/extrudeMesh.C
+++ b/applications/utilities/mesh/generation/extrudeMesh/extrudeMesh.C
@@ -37,7 +37,6 @@ Description
 #include "argList.H"
 #include "Time.H"
 #include "polyTopoChange.H"
-#include "polyTopoChanger.H"
 #include "edgeCollapser.H"
 #include "perfectInterface.H"
 #include "addPatchCellLayer.H"
@@ -883,9 +882,6 @@ int main(int argc, char *argv[])
 
 
 
-        polyTopoChanger stitcher(mesh);
-        stitcher.setSize(1);
-
         const word cutZoneName("originalCutFaceZone");
 
         List<faceZone*> fz
@@ -907,8 +903,7 @@ int main(int argc, char *argv[])
         perfectInterface perfectStitcher
         (
             "couple",
-            0,
-            stitcher,
+            mesh,
             cutZoneName,
             word::null,         // dummy patch name
             word::null          // dummy patch name
diff --git a/applications/utilities/mesh/manipulation/splitMesh/Make/files b/applications/utilities/mesh/manipulation/splitMesh/Make/files
deleted file mode 100644
index 9edd2f7dd3..0000000000
--- a/applications/utilities/mesh/manipulation/splitMesh/Make/files
+++ /dev/null
@@ -1,4 +0,0 @@
-regionSide.C
-splitMesh.C
-
-EXE = $(FOAM_APPBIN)/splitMesh
diff --git a/applications/utilities/mesh/manipulation/splitMesh/Make/options b/applications/utilities/mesh/manipulation/splitMesh/Make/options
deleted file mode 100644
index df36a8a743..0000000000
--- a/applications/utilities/mesh/manipulation/splitMesh/Make/options
+++ /dev/null
@@ -1,8 +0,0 @@
-EXE_INC = \
-    -I$(LIB_SRC)/dynamicMesh/lnInclude \
-    -I$(LIB_SRC)/meshTools/lnInclude
-
-EXE_LIBS = \
-    -ldynamicMesh \
-    -lgenericPatches \
-    -lmeshTools
diff --git a/applications/utilities/mesh/manipulation/splitMesh/regionSide.C b/applications/utilities/mesh/manipulation/splitMesh/regionSide.C
deleted file mode 100644
index 219ef0a418..0000000000
--- a/applications/utilities/mesh/manipulation/splitMesh/regionSide.C
+++ /dev/null
@@ -1,454 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2018 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 "regionSide.H"
-#include "meshTools.H"
-#include "primitiveMesh.H"
-
-
-// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
-
-namespace Foam
-{
-
-defineTypeNameAndDebug(regionSide, 0);
-
-}
-
-// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
-
-// Step across edge onto other face on cell
-Foam::label Foam::regionSide::otherFace
-(
-    const primitiveMesh& mesh,
-    const label celli,
-    const label facei,
-    const label edgeI
-)
-{
-    label f0I, f1I;
-
-    meshTools::getEdgeFaces(mesh, celli, edgeI, f0I, f1I);
-
-    if (f0I == facei)
-    {
-        return f1I;
-    }
-    else
-    {
-        return f0I;
-    }
-}
-
-
-// Step across point to other edge on face
-Foam::label Foam::regionSide::otherEdge
-(
-    const primitiveMesh& mesh,
-    const label facei,
-    const label edgeI,
-    const label pointi
-)
-{
-    const edge& e = mesh.edges()[edgeI];
-
-    // Get other point on edge.
-    label freePointi = e.otherVertex(pointi);
-
-    const labelList& fEdges = mesh.faceEdges()[facei];
-
-    forAll(fEdges, fEdgeI)
-    {
-        const label otherEdgeI = fEdges[fEdgeI];
-        const edge& otherE = mesh.edges()[otherEdgeI];
-
-        if
-        (
-            (
-                otherE.start() == pointi
-             && otherE.end() != freePointi
-            )
-         || (
-                otherE.end() == pointi
-             && otherE.start() != freePointi
-            )
-        )
-        {
-            // otherE shares one (but not two) points with e.
-            return otherEdgeI;
-        }
-    }
-
-    FatalErrorInFunction
-        << "Cannot find other edge on face " << facei << " that uses point "
-        << pointi << " but not point " << freePointi << endl
-        << "Edges on face:" << fEdges
-        << " verts:" << UIndirectList<edge>(mesh.edges(), fEdges)()
-        << " Vertices on face:"
-        << mesh.faces()[facei]
-        << " Vertices on original edge:" << e << abort(FatalError);
-
-    return -1;
-}
-
-
-// Step from facei (on side celli) to connected face & cell without crossing
-// fenceEdges.
-void Foam::regionSide::visitConnectedFaces
-(
-    const primitiveMesh& mesh,
-    const labelHashSet& region,
-    const labelHashSet& fenceEdges,
-    const label celli,
-    const label facei,
-    labelHashSet& visitedFace
-)
-{
-    if (!visitedFace.found(facei))
-    {
-        if (debug)
-        {
-            Info<< "visitConnectedFaces : celli:" << celli << " facei:"
-                << facei << "  isOwner:" << (celli == mesh.faceOwner()[facei])
-                << endl;
-        }
-
-        // Mark as visited
-        visitedFace.insert(facei);
-
-        // Mark which side of face was visited.
-        if (celli == mesh.faceOwner()[facei])
-        {
-            sideOwner_.insert(facei);
-        }
-
-
-        // Visit all neighbouring faces on faceSet. Stay on this 'side' of
-        // face by doing edge-face-cell walk.
-        const labelList& fEdges = mesh.faceEdges()[facei];
-
-        forAll(fEdges, fEdgeI)
-        {
-            label edgeI = fEdges[fEdgeI];
-
-            if (!fenceEdges.found(edgeI))
-            {
-                // Step along faces on edge from cell to cell until
-                // we hit face on faceSet.
-
-                // Find face reachable from edge
-                label otherFacei = otherFace(mesh, celli, facei, edgeI);
-
-                if (mesh.isInternalFace(otherFacei))
-                {
-                    label otherCelli = celli;
-
-                    // Keep on crossing faces/cells until back on face on
-                    // surface
-                    while (!region.found(otherFacei))
-                    {
-                        visitedFace.insert(otherFacei);
-
-                        if (debug)
-                        {
-                            Info<< "visitConnectedFaces : celli:" << celli
-                                << " found insideEdgeFace:" << otherFacei
-                                << endl;
-                        }
-
-
-                        // Cross otherFacei into neighbouring cell
-                        otherCelli =
-                            meshTools::otherCell
-                            (
-                                mesh,
-                                otherCelli,
-                                otherFacei
-                            );
-
-                        otherFacei =
-                                otherFace
-                                (
-                                    mesh,
-                                    otherCelli,
-                                    otherFacei,
-                                    edgeI
-                                );
-                    }
-
-                    visitConnectedFaces
-                    (
-                        mesh,
-                        region,
-                        fenceEdges,
-                        otherCelli,
-                        otherFacei,
-                        visitedFace
-                    );
-                }
-            }
-        }
-    }
-}
-
-
-// From edge on face connected to point on region (regionPointi) cross
-// to all other edges using this point by walking across faces
-// Does not cross regionEdges so stays on one side
-// of region
-void Foam::regionSide::walkPointConnectedFaces
-(
-    const primitiveMesh& mesh,
-    const labelHashSet& regionEdges,
-    const label regionPointi,
-    const label startFacei,
-    const label startEdgeI,
-    labelHashSet& visitedEdges
-)
-{
-    // Mark as visited
-    insidePointFaces_.insert(startFacei);
-
-    if (debug)
-    {
-        Info<< "walkPointConnectedFaces : regionPointi:" << regionPointi
-            << " facei:" << startFacei
-            << " edgeI:" << startEdgeI << " verts:"
-            << mesh.edges()[startEdgeI]
-            << endl;
-    }
-
-    // Cross facei i.e. get edge not startEdgeI which uses regionPointi
-    label edgeI = otherEdge(mesh, startFacei, startEdgeI, regionPointi);
-
-    if (!regionEdges.found(edgeI))
-    {
-        if (!visitedEdges.found(edgeI))
-        {
-            visitedEdges.insert(edgeI);
-
-            if (debug)
-            {
-                Info<< "Crossed face from "
-                    << " edgeI:" << startEdgeI << " verts:"
-                    << mesh.edges()[startEdgeI]
-                    << " to edge:" << edgeI << " verts:"
-                    << mesh.edges()[edgeI]
-                    << endl;
-            }
-
-            // Cross edge to all faces connected to it.
-
-            const labelList& eFaces = mesh.edgeFaces()[edgeI];
-
-            forAll(eFaces, eFacei)
-            {
-                label facei = eFaces[eFacei];
-
-                walkPointConnectedFaces
-                (
-                    mesh,
-                    regionEdges,
-                    regionPointi,
-                    facei,
-                    edgeI,
-                    visitedEdges
-                );
-            }
-        }
-    }
-}
-
-
-// Find all faces reachable from all non-fence points and staying on
-// regionFaces side.
-void Foam::regionSide::walkAllPointConnectedFaces
-(
-    const primitiveMesh& mesh,
-    const labelHashSet& regionFaces,
-    const labelHashSet& fencePoints
-)
-{
-    //
-    // Get all (internal and external) edges on region.
-    //
-    labelHashSet regionEdges(4*regionFaces.size());
-
-    forAllConstIter(labelHashSet, regionFaces, iter)
-    {
-        const label facei = iter.key();
-        const labelList& fEdges = mesh.faceEdges()[facei];
-
-        forAll(fEdges, fEdgeI)
-        {
-            regionEdges.insert(fEdges[fEdgeI]);
-        }
-    }
-
-
-    //
-    // Visit all internal points on surface.
-    //
-
-    // Storage for visited points
-    labelHashSet visitedPoint(4*regionFaces.size());
-
-    // Insert fence points so we don't visit them
-    forAllConstIter(labelHashSet, fencePoints, iter)
-    {
-        visitedPoint.insert(iter.key());
-    }
-
-    labelHashSet visitedEdges(2*fencePoints.size());
-
-
-    if (debug)
-    {
-        Info<< "Excluding visit of points:" << visitedPoint << endl;
-    }
-
-    forAllConstIter(labelHashSet, regionFaces, iter)
-    {
-        const label facei = iter.key();
-
-        // Get side of face.
-        label celli;
-
-        if (sideOwner_.found(facei))
-        {
-            celli = mesh.faceOwner()[facei];
-        }
-        else
-        {
-            celli = mesh.faceNeighbour()[facei];
-        }
-
-        // Find starting point and edge on face.
-        const labelList& fEdges = mesh.faceEdges()[facei];
-
-        forAll(fEdges, fEdgeI)
-        {
-            label edgeI = fEdges[fEdgeI];
-
-            // Get the face 'perpendicular' to facei on region.
-            label otherFacei = otherFace(mesh, celli, facei, edgeI);
-
-            // Edge
-            const edge& e = mesh.edges()[edgeI];
-
-            if (!visitedPoint.found(e.start()))
-            {
-                Info<< "Determining visibility from point " << e.start()
-                    << endl;
-
-                visitedPoint.insert(e.start());
-
-                // edgeI = otherEdge(mesh, otherFacei, edgeI, e.start());
-
-                walkPointConnectedFaces
-                (
-                    mesh,
-                    regionEdges,
-                    e.start(),
-                    otherFacei,
-                    edgeI,
-                    visitedEdges
-                );
-            }
-            if (!visitedPoint.found(e.end()))
-            {
-                Info<< "Determining visibility from point " << e.end()
-                    << endl;
-
-                visitedPoint.insert(e.end());
-
-                // edgeI = otherEdge(mesh, otherFacei, edgeI, e.end());
-
-                walkPointConnectedFaces
-                (
-                    mesh,
-                    regionEdges,
-                    e.end(),
-                    otherFacei,
-                    edgeI,
-                    visitedEdges
-                );
-            }
-        }
-    }
-}
-
-
-// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
-
-// Construct from components
-Foam::regionSide::regionSide
-(
-    const primitiveMesh& mesh,
-    const labelHashSet& region,         // faces of region
-    const labelHashSet& fenceEdges,     // outside edges
-    const label startCelli,
-    const label startFacei
-)
-:
-    sideOwner_(region.size()),
-    insidePointFaces_(region.size())
-{
-    // Storage for visited faces
-    labelHashSet visitedFace(region.size());
-
-    // Visit all faces on this side of region.
-    // Mark for each face whether owner (or neighbour) has been visited.
-    // Sets sideOwner_
-    visitConnectedFaces
-    (
-        mesh,
-        region,
-        fenceEdges,
-        startCelli,
-        startFacei,
-        visitedFace
-    );
-
-    //
-    // Visit all internal points on region and mark faces visitable from these.
-    // Sets insidePointFaces_.
-    //
-
-    labelHashSet fencePoints(fenceEdges.size());
-
-    forAllConstIter(labelHashSet, fenceEdges, iter)
-    {
-        const edge& e = mesh.edges()[iter.key()];
-
-        fencePoints.insert(e.start());
-        fencePoints.insert(e.end());
-    }
-
-    walkAllPointConnectedFaces(mesh, region, fencePoints);
-}
-
-
-// ************************************************************************* //
diff --git a/applications/utilities/mesh/manipulation/splitMesh/regionSide.H b/applications/utilities/mesh/manipulation/splitMesh/regionSide.H
deleted file mode 100644
index e7a8ba44a3..0000000000
--- a/applications/utilities/mesh/manipulation/splitMesh/regionSide.H
+++ /dev/null
@@ -1,174 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2020 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::regionSide
-
-Description
-    Determines the 'side' for every face and connected to a
-    singly-connected (through edges) region of faces. Gets set of faces and
-    a list of mesh edges ('fenceEdges') which should not be crossed.
-    Used in splitting a mesh region.
-
-    Determines:
-    - For every face on the surface: whether the owner was visited
-      from starting face.
-    - List of faces using an internal point of the region visitable by
-      edge-face-edge walking from the correct side of the region.
-
-SourceFiles
-    regionSide.C
-
-\*---------------------------------------------------------------------------*/
-
-#ifndef regionSide_H
-#define regionSide_H
-
-#include "HashSet.H"
-#include "typeInfo.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-namespace Foam
-{
-
-// Forward declaration of classes
-class primitiveMesh;
-
-/*---------------------------------------------------------------------------*\
-                         Class regionSide Declaration
-\*---------------------------------------------------------------------------*/
-
-class regionSide
-{
-    // Private Data
-
-        //- For every face on region tells whether the owner is on the
-        //  'regionside'.
-        labelHashSet sideOwner_;
-
-        //- Contains the faces using an internal point and visited face
-        labelHashSet insidePointFaces_;
-
-
-    // Private Member Functions
-
-        //- Step across point to other edge on face
-        static label otherEdge
-        (
-            const primitiveMesh& mesh,
-            const label facei,
-            const label edgeI,
-            const label pointi
-        );
-
-        //- From facei, side celli, cross to other faces/cells by
-        //  face-cell walking and store visited faces and update sideOwner_.
-        void visitConnectedFaces
-        (
-            const primitiveMesh& mesh,
-            const labelHashSet& region,
-            const labelHashSet& fenceEdges,
-            const label celli,
-            const label facei,
-            labelHashSet& visitedFace
-        );
-
-        //- From edge on face connected to point on region (regionPointi) cross
-        //  to all other edges using this point by walking across faces
-        //  Does not cross regionEdges so stays on one side of region
-        void walkPointConnectedFaces
-        (
-            const primitiveMesh& mesh,
-            const labelHashSet& regionEdges,
-            const label regionPointi,
-            const label startFacei,
-            const label startEdgeI,
-            labelHashSet& visitedEdges
-        );
-
-        //- Visits all internal points on region and marks edges reachable
-        //  from sideOwner side (using walkPointConnectedFaces)
-        void walkAllPointConnectedFaces
-        (
-            const primitiveMesh& mesh,
-            const labelHashSet& regionFaces,
-            const labelHashSet& fenceEdges
-        );
-
-public:
-
-    //- Runtime type information
-    ClassName("regionSide");
-
-    // Static Functions
-
-        //- Step across edge onto other face on cell
-        static label otherFace
-        (
-            const primitiveMesh& mesh,
-            const label celli,
-            const label excludeFacei,
-            const label edgeI
-        );
-
-
-    // Constructors
-
-        //- Construct from components
-        regionSide
-        (
-            const primitiveMesh& mesh,
-            const labelHashSet& region,
-            const labelHashSet& fenceEdges,   // labels of fence edges
-            const label startCell,
-            const label startFace
-        );
-
-
-    // Member Functions
-
-        // Access
-
-            const labelHashSet& sideOwner() const
-            {
-                return sideOwner_;
-            }
-
-            const labelHashSet& insidePointFaces() const
-            {
-                return insidePointFaces_;
-            }
-
-};
-
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#endif
-
-// ************************************************************************* //
diff --git a/applications/utilities/mesh/manipulation/splitMesh/splitMesh.C b/applications/utilities/mesh/manipulation/splitMesh/splitMesh.C
deleted file mode 100644
index 28285d4ab6..0000000000
--- a/applications/utilities/mesh/manipulation/splitMesh/splitMesh.C
+++ /dev/null
@@ -1,292 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2023 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/>.
-
-Application
-    splitMesh
-
-Description
-    Splits mesh by making internal faces external. Uses attachDetach.
-
-    Generates a meshModifier of the form:
-
-    Splitter
-    {
-        type                       attachDetach;
-        faceZoneName               membraneFaces;
-        masterPatchName            masterPatch;
-        slavePatchName             slavePatch;
-        triggerTimes               runTime.value();
-    }
-
-    so will detach at the current time and split all faces in membraneFaces
-    into masterPatch and slavePatch (which have to be present but of 0 size)
-
-\*---------------------------------------------------------------------------*/
-
-#include "argList.H"
-#include "polyMesh.H"
-#include "Time.H"
-#include "polyTopoChange.H"
-#include "polyTopoChangeMap.H"
-#include "faceSet.H"
-#include "attachDetach.H"
-#include "attachPolyTopoChanger.H"
-#include "regionSide.H"
-#include "primitiveFacePatch.H"
-
-using namespace Foam;
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-// Find edge between points v0 and v1.
-label findEdge(const primitiveMesh& mesh, const label v0, const label v1)
-{
-    const labelList& pEdges = mesh.pointEdges()[v0];
-
-    forAll(pEdges, pEdgeI)
-    {
-        label edgeI = pEdges[pEdgeI];
-
-        const edge& e = mesh.edges()[edgeI];
-
-        if (e.otherVertex(v0) == v1)
-        {
-            return edgeI;
-        }
-    }
-
-    FatalErrorInFunction
-        << "Cannot find edge between mesh points " << v0 << " and " << v1
-        << abort(FatalError);
-
-    return -1;
-}
-
-
-// Checks whether patch present
-void checkPatch(const polyBoundaryMesh& bMesh, const word& name)
-{
-    const label patchi = bMesh.findPatchID(name);
-
-    if (patchi == -1)
-    {
-        FatalErrorInFunction
-            << "Cannot find patch " << name << nl
-            << "It should be present but of zero size" << endl
-            << "Valid patches are " << bMesh.names()
-            << exit(FatalError);
-    }
-
-    if (bMesh[patchi].size())
-    {
-        FatalErrorInFunction
-            << "Patch " << name << " is present but non-zero size"
-            << exit(FatalError);
-    }
-}
-
-
-
-int main(int argc, char *argv[])
-{
-    argList::noParallel();
-    #include "addOverwriteOption.H"
-
-    argList::validArgs.append("faceSet");
-    argList::validArgs.append("masterPatch");
-    argList::validArgs.append("slavePatch");
-
-    #include "setRootCase.H"
-    #include "createTimeNoFunctionObjects.H"
-    #include "createPolyMesh.H"
-    const word oldInstance = mesh.pointsInstance();
-
-    const word setName = args[1];
-    const word masterPatch = args[2];
-    const word slavePatch = args[3];
-    const bool overwrite = args.optionFound("overwrite");
-
-    // List of faces to split
-    faceSet facesSet(mesh, setName);
-
-    Info<< "Read " << facesSet.size() << " faces to split" << endl << endl;
-
-
-    // Convert into labelList and check
-
-    labelList faces(facesSet.toc());
-
-    forAll(faces, i)
-    {
-        if (!mesh.isInternalFace(faces[i]))
-        {
-            FatalErrorInFunction
-            << "Face " << faces[i] << " in faceSet " << setName
-            << " is not an internal face."
-            << exit(FatalError);
-        }
-    }
-
-
-    // Check for empty master and slave patches
-    checkPatch(mesh.boundaryMesh(), masterPatch);
-    checkPatch(mesh.boundaryMesh(), slavePatch);
-
-
-    //
-    // Find 'side' of all faces on splitregion. Uses regionSide which needs
-    // set of edges on side of this region. Use PrimitivePatch to find these.
-    //
-
-    // Addressing on faces only in mesh vertices.
-    primitiveFacePatch fPatch
-    (
-        faceList
-        (
-            UIndirectList<face>
-            (
-                mesh.faces(),
-                faces
-            )
-        ),
-        mesh.points()
-    );
-
-    const labelList& meshPoints = fPatch.meshPoints();
-
-    // Mark all fence edges : edges on boundary of fPatch but not on boundary
-    // of polyMesh
-    labelHashSet fenceEdges(fPatch.size());
-
-    const labelListList& allEdgeFaces = fPatch.edgeFaces();
-
-    forAll(allEdgeFaces, patchEdgeI)
-    {
-        if (allEdgeFaces[patchEdgeI].size() == 1)
-        {
-            const edge& e = fPatch.edges()[patchEdgeI];
-
-            label edgeI =
-                findEdge
-                (
-                    mesh,
-                    meshPoints[e.start()],
-                    meshPoints[e.end()]
-                );
-
-            fenceEdges.insert(edgeI);
-        }
-    }
-
-    // Find sides reachable from 0th face of faceSet
-    label startFacei = faces[0];
-
-    regionSide regionInfo
-    (
-        mesh,
-        facesSet,
-        fenceEdges,
-        mesh.faceOwner()[startFacei],
-        startFacei
-    );
-
-    // Determine flip state for all faces in faceSet
-    boolList zoneFlip(faces.size());
-
-    forAll(faces, i)
-    {
-        zoneFlip[i] = !regionInfo.sideOwner().found(faces[i]);
-    }
-
-
-    // Create and add face zones and mesh modifiers
-    List<pointZone*> pz(0);
-    List<faceZone*> fz(1);
-    List<cellZone*> cz(0);
-
-    fz[0] =
-        new faceZone
-        (
-            "membraneFaces",
-            faces,
-            zoneFlip,
-            0,
-            mesh.faceZones()
-        );
-
-    Info<< "Adding point and face zones" << endl;
-    mesh.addZones(pz, fz, cz);
-
-    attachPolyTopoChanger splitter(mesh);
-    splitter.setSize(1);
-
-    // Add the sliding interface mesh modifier to start working at current
-    // time
-    splitter.set
-    (
-        0,
-        new attachDetach
-        (
-            "Splitter",
-            0,
-            splitter,
-            "membraneFaces",
-            masterPatch,
-            slavePatch,
-            scalarField(1, runTime.value())
-        )
-    );
-
-    Info<< nl << "Constructed topologyModifier:" << endl;
-    splitter[0].writeDict(Info);
-
-    if (!overwrite)
-    {
-        runTime++;
-    }
-
-    splitter.attach();
-
-    if (overwrite)
-    {
-        mesh.setInstance(oldInstance);
-    }
-    else
-    {
-        mesh.setInstance(runTime.name());
-    }
-
-    Info<< "Writing mesh to " << runTime.name() << endl;
-    if (!mesh.write())
-    {
-        FatalErrorInFunction
-            << "Failed writing polyMesh."
-            << exit(FatalError);
-    }
-
-    Info<< "End\n" << endl;
-    return 0;
-}
-
-
-// ************************************************************************* //
diff --git a/applications/utilities/mesh/manipulation/stitchMesh/stitchMesh.C b/applications/utilities/mesh/manipulation/stitchMesh/stitchMesh.C
index 928a8ecd75..cc46dfed48 100644
--- a/applications/utilities/mesh/manipulation/stitchMesh/stitchMesh.C
+++ b/applications/utilities/mesh/manipulation/stitchMesh/stitchMesh.C
@@ -358,8 +358,7 @@ int main(int argc, char *argv[])
             new perfectInterface
             (
                 "couple",
-                0,
-                stitcher,
+                mesh,
                 cutZoneName,
                 masterPatchName,
                 slavePatchName
@@ -412,8 +411,7 @@ int main(int argc, char *argv[])
             new slidingInterface
             (
                 "couple",
-                0,
-                stitcher,
+                mesh,
                 mergePatchName + "MasterZone",
                 mergePatchName + "SlaveZone",
                 mergePatchName + "CutPointZone",
diff --git a/src/dynamicMesh/Make/files b/src/dynamicMesh/Make/files
index 267ab7bd27..422f590557 100644
--- a/src/dynamicMesh/Make/files
+++ b/src/dynamicMesh/Make/files
@@ -18,17 +18,9 @@ $(hexRef8)/hexRef8Data.C
 $(hexRef8)/refinementHistory.C
 
 polyTopoChanger/polyTopoChanger/polyTopoChanger.C
+polyTopoChanger/polyMeshModifier/polyMeshModifier.C
 polyTopoChanger/attachPolyTopoChanger/attachPolyTopoChanger.C
 
-polyMeshModifier = polyTopoChanger/polyMeshModifier
-$(polyMeshModifier)/polyMeshModifier.C
-$(polyMeshModifier)/polyMeshModifierNew.C
-
-polyTopoChanger/attachDetach/attachDetach.C
-polyTopoChanger/attachDetach/attachInterface.C
-polyTopoChanger/attachDetach/detachInterface.C
-polyTopoChanger/attachDetach/attachDetachPointMatchMap.C
-
 enrichedPatch = polyTopoChanger/slidingInterface/enrichedPatch
 $(enrichedPatch)/enrichedPatch.C
 $(enrichedPatch)/enrichedPatchPointMap.C
diff --git a/src/dynamicMesh/meshCut/meshModifiers/multiDirRefinement/multiDirRefinement.C b/src/dynamicMesh/meshCut/meshModifiers/multiDirRefinement/multiDirRefinement.C
index fe66460a1a..63119c5993 100644
--- a/src/dynamicMesh/meshCut/meshModifiers/multiDirRefinement/multiDirRefinement.C
+++ b/src/dynamicMesh/meshCut/meshModifiers/multiDirRefinement/multiDirRefinement.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2022 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2023 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -25,7 +25,6 @@ License
 
 #include "multiDirRefinement.H"
 #include "polyMesh.H"
-#include "polyTopoChanger.H"
 #include "Time.H"
 #include "undoableMeshCutter.H"
 #include "hexCellLooper.H"
@@ -42,7 +41,7 @@ License
 
 namespace Foam
 {
-defineTypeNameAndDebug(multiDirRefinement, 0);
+    defineTypeNameAndDebug(multiDirRefinement, 0);
 }
 
 
diff --git a/src/dynamicMesh/polyTopoChanger/attachDetach/attachDetach.C b/src/dynamicMesh/polyTopoChanger/attachDetach/attachDetach.C
deleted file mode 100644
index ac371f1edf..0000000000
--- a/src/dynamicMesh/polyTopoChanger/attachDetach/attachDetach.C
+++ /dev/null
@@ -1,483 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2023 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/>.
-
-Description
-    Attach/detach boundary mesh modifier.  This modifier takes a set of
-    internal faces and converts them into boundary faces and vice versa
-    based on the given activation switch.
-
-\*---------------------------------------------------------------------------*/
-
-#include "attachDetach.H"
-#include "polyTopoChanger.H"
-#include "polyMesh.H"
-#include "Time.H"
-#include "primitiveMesh.H"
-#include "polyTopoChange.H"
-#include "addToRunTimeSelectionTable.H"
-
-// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
-
-namespace Foam
-{
-    defineTypeNameAndDebug(attachDetach, 0);
-    addToRunTimeSelectionTable
-    (
-        polyMeshModifier,
-        attachDetach,
-        dictionary
-    );
-}
-
-
-// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
-
-void Foam::attachDetach::checkDefinition()
-{
-    if
-    (
-        !faceZoneID_.active()
-     || !masterPatchID_.active()
-     || !slavePatchID_.active()
-    )
-    {
-        FatalErrorInFunction
-            << "Not all zones and patches needed in the definition "
-            << "have been found.  Please check your mesh definition."
-            << abort(FatalError);
-    }
-
-    const polyMesh& mesh = topoChanger().mesh();
-
-    if (debug)
-    {
-        Pout<< "Attach/detach object " << name() << " :" << nl
-            << "    faceZoneID:   " << faceZoneID_ << nl
-            << "    masterPatchID: " << masterPatchID_ << nl
-            << "    slavePatchID: " << slavePatchID_ << endl;
-    }
-
-    // Check the sizes and set up state
-    if
-    (
-        mesh.boundaryMesh()[masterPatchID_.index()].empty()
-     && mesh.boundaryMesh()[slavePatchID_.index()].empty()
-    )
-    {
-        // Boundary is attached
-        if (debug)
-        {
-            Pout<< "    Attached on construction" << endl;
-        }
-
-        state_ = ATTACHED;
-
-        // Check if there are faces in the master zone
-        if (mesh.faceZones()[faceZoneID_.index()].empty())
-        {
-            FatalErrorInFunction
-                << "mesh definition."
-                << abort(FatalError);
-        }
-
-        // Check that all the faces in the face zone are internal
-        if (debug)
-        {
-            const labelList& addr = mesh.faceZones()[faceZoneID_.index()];
-
-            DynamicList<label> bouFacesInZone(addr.size());
-
-            forAll(addr, facei)
-            {
-                if (!mesh.isInternalFace(addr[facei]))
-                {
-                    bouFacesInZone.append(addr[facei]);
-                }
-            }
-
-            if (bouFacesInZone.size())
-            {
-                FatalErrorInFunction
-                    << "Found boundary faces in the zone defining "
-                    << "attach/detach boundary "
-                    << " for object " << name()
-                    << " : .  This is not allowed." << nl
-                    << "Boundary faces: " << bouFacesInZone
-                    << abort(FatalError);
-            }
-        }
-    }
-    else
-    {
-        // Boundary is detached
-        if (debug)
-        {
-            Pout<< "    Detached on construction" << endl;
-        }
-
-        state_ = DETACHED;
-
-        // Check that the sizes of master and slave patch are identical
-        // and identical to the size of the face zone
-        if
-        (
-            (
-                mesh.boundaryMesh()[masterPatchID_.index()].size()
-             != mesh.boundaryMesh()[slavePatchID_.index()].size()
-            )
-         || (
-                mesh.boundaryMesh()[masterPatchID_.index()].size()
-             != mesh.faceZones()[faceZoneID_.index()].size()
-            )
-        )
-        {
-            FatalErrorInFunction
-                << "Problem with sizes in mesh modifier. The face zone,"
-                << " master and slave patch should have the same size"
-                << " for object " << name() << ". " << nl
-                << "Zone size: "
-                << mesh.faceZones()[faceZoneID_.index()].size()
-                << " Master patch size: "
-                << mesh.boundaryMesh()[masterPatchID_.index()].size()
-                << " Slave patch size: "
-                << mesh.boundaryMesh()[slavePatchID_.index()].size()
-                << abort(FatalError);
-        }
-
-        // Check that all the faces belong to either master or slave patch
-        if (debug)
-        {
-            const labelList& addr = mesh.faceZones()[faceZoneID_.index()];
-
-            DynamicList<label> zoneProblemFaces(addr.size());
-
-            forAll(addr, facei)
-            {
-                label facePatch =
-                    mesh.boundaryMesh().whichPatch(addr[facei]);
-
-                if
-                (
-                    facePatch != masterPatchID_.index()
-                 && facePatch != slavePatchID_.index()
-                )
-                {
-                    zoneProblemFaces.append(addr[facei]);
-                }
-            }
-
-            if (zoneProblemFaces.size())
-            {
-                FatalErrorInFunction
-                    << "Found faces in the zone defining "
-                    << "attach/detach boundary which do not belong to "
-                    << "either master or slave patch.  "
-                    << "This is not allowed." << nl
-                    << "Problem faces: " << zoneProblemFaces
-                    << abort(FatalError);
-            }
-        }
-    }
-
-    // Check that trigger times are in ascending order
-    bool triggersOK = true;
-
-    for (label i = 0; i < triggerTimes_.size() - 1; i++)
-    {
-        triggersOK = triggersOK && (triggerTimes_[i] < triggerTimes_[i + 1]);
-    }
-
-    if
-    (
-        !triggersOK
-     || (triggerTimes_.empty() && !manualTrigger())
-    )
-    {
-        FatalErrorInFunction
-            << "Problem with definition of trigger times: "
-            << triggerTimes_
-            << abort(FatalError);
-    }
-}
-
-
-void Foam::attachDetach::clearAddressing() const
-{
-    deleteDemandDrivenData(pointMatchMapPtr_);
-}
-
-
-// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
-
-Foam::attachDetach::attachDetach
-(
-    const word& name,
-    const label index,
-    const polyTopoChanger& mme,
-    const word& faceZoneName,
-    const word& masterPatchName,
-    const word& slavePatchName,
-    const scalarField& triggerTimes,
-    const bool manualTrigger
-)
-:
-    polyMeshModifier(name, index, mme, true),
-    faceZoneID_(faceZoneName, mme.mesh().faceZones()),
-    masterPatchID_(masterPatchName, mme.mesh().boundaryMesh()),
-    slavePatchID_(slavePatchName, mme.mesh().boundaryMesh()),
-    triggerTimes_(triggerTimes),
-    manualTrigger_(manualTrigger),
-    triggerIndex_(0),
-    state_(UNKNOWN),
-    trigger_(false),
-    pointMatchMapPtr_(nullptr)
-{
-    checkDefinition();
-}
-
-
-Foam::attachDetach::attachDetach
-(
-    const word& name,
-    const dictionary& dict,
-    const label index,
-    const polyTopoChanger& mme
-)
-:
-    polyMeshModifier(name, index, mme, Switch(dict.lookup("active"))),
-    faceZoneID_
-    (
-        dict.lookup("faceZoneName"),
-        mme.mesh().faceZones()
-    ),
-    masterPatchID_
-    (
-        dict.lookup("masterPatchName"),
-        mme.mesh().boundaryMesh()
-    ),
-    slavePatchID_
-    (
-        dict.lookup("slavePatchName"),
-        mme.mesh().boundaryMesh()
-    ),
-    triggerTimes_(dict.lookup("triggerTimes")),
-    manualTrigger_(dict.lookup("manualTrigger")),
-    triggerIndex_(0),
-    state_(UNKNOWN),
-    trigger_(false),
-    pointMatchMapPtr_(nullptr)
-{
-    checkDefinition();
-}
-
-
-// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
-
-Foam::attachDetach::~attachDetach()
-{
-    clearAddressing();
-}
-
-
-// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
-
-bool Foam::attachDetach::setAttach() const
-{
-    if (!attached())
-    {
-        trigger_ = true;
-    }
-    else
-    {
-        trigger_ = false;
-    }
-
-    return trigger_;
-}
-
-
-bool Foam::attachDetach::setDetach() const
-{
-    if (attached())
-    {
-        trigger_ = true;
-    }
-    else
-    {
-        trigger_ = false;
-    }
-
-    return trigger_;
-}
-
-
-bool Foam::attachDetach::changeTopology() const
-{
-    if (manualTrigger())
-    {
-        if (debug)
-        {
-            Pout<< "bool attachDetach::changeTopology() const "
-                << " for object " << name() << " : "
-                << "Manual trigger" << endl;
-        }
-
-        return trigger_;
-    }
-
-    // To deal with multiple calls within the same time step, return true
-    // if trigger is already set
-    if (trigger_)
-    {
-        if (debug)
-        {
-            Pout<< "bool attachDetach::changeTopology() const "
-                << " for object " << name() << " : "
-                << "Already triggered for current time step" << endl;
-        }
-
-        return true;
-    }
-
-    // If the end of the list of trigger times has been reached, no
-    // new topological changes will happen
-    if (triggerIndex_ >= triggerTimes_.size())
-    {
-        if (debug)
-        {
-            Pout<< "bool attachDetach::changeTopology() const "
-                << " for object " << name() << " : "
-                << "Reached end of trigger list" << endl;
-        }
-        return false;
-    }
-
-    if (debug)
-    {
-        Pout<< "bool attachDetach::changeTopology() const "
-            << " for object " << name() << " : "
-            << "Triggering attach/detach topology change." << nl
-            << "Current time: " << topoChanger().mesh().time().value()
-            << " current trigger time: " << triggerTimes_[triggerIndex_]
-            << " trigger index: " << triggerIndex_ << endl;
-    }
-
-    // Check if the time is greater than the currentTime.  If so, increment
-    // the current lookup and request topology change
-    if (topoChanger().mesh().time().value() >= triggerTimes_[triggerIndex_])
-    {
-        trigger_ = true;
-
-        // Increment the trigger index
-        triggerIndex_++;
-
-        return true;
-    }
-
-    // No topological change
-    return false;
-}
-
-
-void Foam::attachDetach::setRefinement(polyTopoChange& ref) const
-{
-    // Insert the attach/detach instructions into the topological change
-
-    if (trigger_)
-    {
-        // Clear point addressing from previous attach/detach event
-        clearAddressing();
-
-        if (state_ == ATTACHED)
-        {
-            detachInterface(ref);
-
-            // Set the state to detached
-            state_ = DETACHED;
-        }
-        else if (state_ == DETACHED)
-        {
-            attachInterface(ref);
-
-            // Set the state to attached
-            state_ = ATTACHED;
-        }
-        else
-        {
-            FatalErrorInFunction
-                << "Requested attach/detach event and current state "
-                << "is not known."
-                << abort(FatalError);
-        }
-
-        trigger_ = false;
-    }
-}
-
-
-void Foam::attachDetach::topoChange(const polyTopoChangeMap&)
-{
-    // Mesh has changed topologically.  Update local topological data
-    const polyMesh& mesh = topoChanger().mesh();
-
-    faceZoneID_.update(mesh.faceZones());
-    masterPatchID_.update(mesh.boundaryMesh());
-    slavePatchID_.update(mesh.boundaryMesh());
-
-    clearAddressing();
-}
-
-
-void Foam::attachDetach::write(Ostream& os) const
-{
-    os  << nl << type() << nl
-        << name()<< nl
-        << faceZoneID_.name() << nl
-        << masterPatchID_.name() << nl
-        << slavePatchID_.name() << nl
-        << triggerTimes_ << endl;
-}
-
-
-void Foam::attachDetach::writeDict(Ostream& os) const
-{
-    os  << nl << name() << nl << token::BEGIN_BLOCK << nl
-        << "    type " << type()
-        << token::END_STATEMENT << nl
-        << "    faceZoneName " << faceZoneID_.name()
-        << token::END_STATEMENT << nl
-        << "    masterPatchName " << masterPatchID_.name()
-        << token::END_STATEMENT << nl
-        << "    slavePatchName " << slavePatchID_.name()
-        << token::END_STATEMENT << nl
-        << "    triggerTimes " << triggerTimes_
-        << token::END_STATEMENT << nl
-        << "    manualTrigger " << manualTrigger()
-        << token::END_STATEMENT << nl
-        << "    active " << active()
-        << token::END_STATEMENT << nl
-        << token::END_BLOCK << endl;
-}
-
-
-// ************************************************************************* //
diff --git a/src/dynamicMesh/polyTopoChanger/attachDetach/attachDetach.H b/src/dynamicMesh/polyTopoChanger/attachDetach/attachDetach.H
deleted file mode 100644
index 89df9bdbc7..0000000000
--- a/src/dynamicMesh/polyTopoChanger/attachDetach/attachDetach.H
+++ /dev/null
@@ -1,247 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2023 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::attachDetach
-
-Description
-    Attach/detach boundary mesh modifier.  This modifier takes a set of
-    internal faces and converts them into boundary faces and vice versa
-    based on the given activation switch.
-
-    The patch is oriented using the flip map in the face zone.  The
-    oriented faces are put into the master patch and their mirror
-    images into the slave.
-
-SourceFiles
-    attachDetach.C
-    attachInterface.C
-    detachInterface.C
-    attachDetachPointMatchMap.C
-
-\*---------------------------------------------------------------------------*/
-
-#ifndef attachDetach_H
-#define attachDetach_H
-
-#include "polyMeshModifier.H"
-#include "polyPatchDynamicID.H"
-#include "ZoneDynamicIDs.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-namespace Foam
-{
-
-/*---------------------------------------------------------------------------*\
-                        Class attachDetach Declaration
-\*---------------------------------------------------------------------------*/
-
-class attachDetach
-:
-    public polyMeshModifier
-{
-    // Data types
-
-        //- State of the modifier
-        enum modifierState
-        {
-            UNKNOWN,
-            ATTACHED,
-            DETACHED
-        };
-
-
-    // Private Data
-
-        //- Master face zone ID
-        faceZoneDynamicID faceZoneID_;
-
-        //- Master patch ID.  Holds faces with original orientation
-        polyPatchDynamicID masterPatchID_;
-
-        //- Slave patch ID.  Holds mirrored faces
-        polyPatchDynamicID slavePatchID_;
-
-        //- List of trigger times
-        scalarField triggerTimes_;
-
-        //- Use manual trigger
-        Switch manualTrigger_;
-
-        //- Trigger time index
-        mutable label triggerIndex_;
-
-        //- State of the modifier
-        mutable modifierState state_;
-
-        //- Attach/detach trigger
-        mutable bool trigger_;
-
-
-        // Private addressing data.  Created on topology change
-
-            //- Map of matching points
-            mutable Map<label>* pointMatchMapPtr_;
-
-
-    // Private Member Functions
-
-        //- Check validity of construction data
-        void checkDefinition();
-
-        // Topological changes
-
-            //- Attach interface
-            void attachInterface(polyTopoChange&) const;
-
-            //- Detach interface
-            void detachInterface(polyTopoChange&) const;
-
-            //- Calculate point match addressing
-            void calcPointMatchMap() const;
-
-            //- Return point match map
-            const Map<label>& pointMatchMap() const;
-
-            //- Clear addressing
-            void clearAddressing() const;
-
-
-    // Static Data Members
-
-        //- Relative vertex position tolerance
-        static const scalar positionDifference_;
-
-
-public:
-
-    //- Runtime type information
-    TypeName("attachDetach");
-
-
-    // Constructors
-
-        //- Construct from components
-        attachDetach
-        (
-            const word& name,
-            const label index,
-            const polyTopoChanger& mme,
-            const word& faceZoneName,
-            const word& masterPatchName,
-            const word& slavePatchName,
-            const scalarField& triggerTimes,
-            const bool manualTrigger = false
-        );
-
-        //- Construct from dictionary
-        attachDetach
-        (
-            const word& name,
-            const dictionary& dict,
-            const label index,
-            const polyTopoChanger& mesh
-        );
-
-        //- Disallow default bitwise copy construction
-        attachDetach(const attachDetach&) = delete;
-
-
-    //- Destructor
-    virtual ~attachDetach();
-
-
-    // Member Functions
-
-        //- Return master patch ID
-        const polyPatchDynamicID& masterPatchID() const
-        {
-            return masterPatchID_;
-        }
-
-        //- Return slave patch ID
-        const polyPatchDynamicID& slavePatchID() const
-        {
-            return slavePatchID_;
-        }
-
-        //- Is the interface attached?
-        bool attached() const
-        {
-            return state_ == ATTACHED;
-        }
-
-        const Switch& manualTrigger() const
-        {
-            return manualTrigger_;
-        }
-
-        // Manually set attach.  Use only with manual trigger
-        bool setAttach() const;
-
-        // Manually set detach.  Use only with manual trigger
-        bool setDetach() const;
-
-        //- Check for topology change
-        virtual bool changeTopology() const;
-
-        //- Insert the layer addition/removal instructions
-        //  into the topological change
-        virtual void setRefinement(polyTopoChange&) const;
-
-        //- Modify motion points to comply with the topological change
-        virtual void modifyMotionPoints(pointField& motionPoints) const;
-
-        //- Force recalculation of locally stored data on topological change
-        virtual void topoChange(const polyTopoChangeMap&);
-
-        //- Get reference to trigger times
-        const scalarField& triggerTimes() const
-        {
-            return triggerTimes_;
-        }
-
-        //- Write
-        virtual void write(Ostream&) const;
-
-        //- Write dictionary
-        virtual void writeDict(Ostream&) const;
-
-
-    // Member Operators
-
-        //- Disallow default bitwise assignment
-        void operator=(const attachDetach&) = delete;
-};
-
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#endif
-
-// ************************************************************************* //
diff --git a/src/dynamicMesh/polyTopoChanger/attachDetach/attachDetachPointMatchMap.C b/src/dynamicMesh/polyTopoChanger/attachDetach/attachDetachPointMatchMap.C
deleted file mode 100644
index 344322a265..0000000000
--- a/src/dynamicMesh/polyTopoChanger/attachDetach/attachDetachPointMatchMap.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-2023 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 "attachDetach.H"
-#include "polyMesh.H"
-#include "primitiveMesh.H"
-#include "primitiveFacePatch.H"
-#include "polyTopoChanger.H"
-
-// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
-
-const Foam::Map<Foam::label>&
-Foam::attachDetach::pointMatchMap() const
-{
-    if (!pointMatchMapPtr_)
-    {
-        calcPointMatchMap();
-    }
-
-    return *pointMatchMapPtr_;
-}
-
-
-void Foam::attachDetach::calcPointMatchMap() const
-{
-    if (debug)
-    {
-        Pout<< "void attachDetach::calcPointMatchMap() const "
-            << " for object " << name() << " : "
-            << "Calculating point matching" << endl;
-    }
-
-    if (pointMatchMapPtr_)
-    {
-        FatalErrorInFunction
-            << "Point match map already calculated for object " << name()
-            << abort(FatalError);
-    }
-
-    const polyMesh& mesh = topoChanger().mesh();
-    const faceList& faces = mesh.faces();
-
-    const polyPatch& masterPatch = mesh.boundaryMesh()[masterPatchID_.index()];
-    const polyPatch& slavePatch = mesh.boundaryMesh()[slavePatchID_.index()];
-
-    // Create the reverse patch out of the slave patch
-    primitiveFacePatch reverseSlavePatch
-    (
-        faceList(slavePatch.size()),
-        mesh.points()
-    );
-
-    const label slavePatchStart = slavePatch.start();
-
-    forAll(reverseSlavePatch, facei)
-    {
-        reverseSlavePatch[facei] =
-            faces[slavePatchStart + facei].reverseFace();
-    }
-
-    // Create point merge list and remove merged points
-    const labelList& masterMeshPoints = masterPatch.meshPoints();
-    const labelList& slaveMeshPoints = reverseSlavePatch.meshPoints();
-
-    const faceList& masterLocalFaces = masterPatch.localFaces();
-    const faceList& slaveLocalFaces = reverseSlavePatch.localFaces();
-
-    pointMatchMapPtr_ = new Map<label>(2*slaveMeshPoints.size());
-    Map<label>& removedPointMap = *pointMatchMapPtr_;
-
-    forAll(masterLocalFaces, facei)
-    {
-        const face& curMasterPoints = masterLocalFaces[facei];
-        const face& curSlavePoints = slaveLocalFaces[facei];
-
-        forAll(curMasterPoints, pointi)
-        {
-            // If the master and slave point labels are the same, the
-            // point remains.  Otherwise, the slave point is removed and
-            // replaced by the master
-            if
-            (
-                masterMeshPoints[curMasterPoints[pointi]]
-             != slaveMeshPoints[curSlavePoints[pointi]]
-            )
-            {
-                // Pout<< "Matching slave point "
-                //     << slaveMeshPoints[curSlavePoints[pointi]]
-                //     << " with "
-                //     << masterMeshPoints[curMasterPoints[pointi]]
-                //     << endl;
-
-                // Grab the addressing
-                removedPointMap.insert
-                (
-                    slaveMeshPoints[curSlavePoints[pointi]],
-                    masterMeshPoints[curMasterPoints[pointi]]
-                );
-            }
-        }
-    }
-
-    if (debug)
-    {
-        Pout<< "void attachDetach::calcPointMatchMap() const "
-            << " for object " << name() << " : "
-            << "Finished calculating point matching" << endl;
-    }
-}
-
-
-// ************************************************************************* //
diff --git a/src/dynamicMesh/polyTopoChanger/attachDetach/attachInterface.C b/src/dynamicMesh/polyTopoChanger/attachDetach/attachInterface.C
deleted file mode 100644
index 1a36e83667..0000000000
--- a/src/dynamicMesh/polyTopoChanger/attachDetach/attachInterface.C
+++ /dev/null
@@ -1,296 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2023 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 "attachDetach.H"
-#include "polyMesh.H"
-#include "primitiveMesh.H"
-#include "polyTopoChange.H"
-#include "polyTopoChanger.H"
-
-// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
-
-const Foam::scalar Foam::attachDetach::positionDifference_ = 1e-8;
-
-// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
-
-void Foam::attachDetach::attachInterface
-(
-    polyTopoChange& ref
-) const
-{
-    // Algorithm:
-    // 1. Create the reverse patch out of the slave faces.
-    // 2. Go through all the mesh points from the master and slave patch.
-    //    If the point labels are different, insert them into the point
-    //    renumbering list and remove them from the mesh.
-    // 3. Remove all faces from the slave patch
-    // 4. Modify all the faces from the master patch by making them internal
-    //    between the faceCell cells for the two patches.  If the master owner
-    //    is higher than the slave owner, turn the face around
-    // 5. Get all the faces attached to the slave patch points.
-    //    If they have not been removed, renumber them using the
-    //    point renumbering list.
-
-    if (debug)
-    {
-        Pout<< "void attachDetach::attachInterface("
-            << "polyTopoChange& ref) const "
-            << " for object " << name() << " : "
-            << "Attaching interface" << endl;
-    }
-
-    const polyMesh& mesh = topoChanger().mesh();
-    const faceList& faces = mesh.faces();
-    const labelList& own = mesh.faceOwner();
-    const labelList& nei = mesh.faceNeighbour();
-
-    const polyPatch& masterPatch = mesh.boundaryMesh()[masterPatchID_.index()];
-    const polyPatch& slavePatch = mesh.boundaryMesh()[slavePatchID_.index()];
-
-    const label masterPatchStart = masterPatch.start();
-    const label slavePatchStart = slavePatch.start();
-
-    const labelList& slaveMeshPoints = slavePatch.meshPoints();
-
-    const Map<label>& removedPointMap = pointMatchMap();
-
-    const labelList removedPoints = removedPointMap.toc();
-
-    forAll(removedPoints, pointi)
-    {
-        // Pout<< "Removing point:" << removedPoints[pointi]
-        //    << " currently at:" << ref.points()[removedPoints[pointi]]
-        //    << endl;
-
-        ref.removePoint(removedPoints[pointi], -1);
-    }
-
-// Pout<< "Points to be mapped: " << removedPoints << endl;
-    // Remove all faces from the slave patch
-    forAll(slavePatch, i)
-    {
-        // Pout<< "Removing face " << i + slavePatchStart
-        //    << " with verts:" << ref.faces()[i + slavePatchStart]
-        //    << " at:"
-        //    <<  UIndirectList<point>
-        //        (
-        //            ref.points(),
-        //            ref.faces()[i + slavePatchStart]
-        //        )
-        //    << endl;
-        ref.removeFace(i + slavePatchStart, -1);
-    }
-
-    // Modify the faces from the master patch
-    const labelList& masterFaceCells = masterPatch.faceCells();
-    const labelList& slaveFaceCells = slavePatch.faceCells();
-
-    const boolList& mfFlip = mesh.faceZones()[faceZoneID_.index()].flipMap();
-
-    forAll(masterFaceCells, facei)
-    {
-        // If slave neighbour is greater than master, face does not need
-        // turning.  Modify it to become internal
-        if (masterFaceCells[facei] < slaveFaceCells[facei])
-        {
-            ref.modifyFace
-            (
-                faces[masterPatchStart + facei], // modified face
-                masterPatchStart + facei,    // label of face being modified
-                masterFaceCells[facei],          // owner
-                slaveFaceCells[facei],           // neighbour
-                false,                           // face flip
-                -1,                              // patch for face
-                faceZoneID_.index(),             // zone for face
-                mfFlip[facei]                    // face flip in zone
-            );
-        }
-        else
-        {
-            // Flip required
-            ref.modifyFace
-            (
-                faces[masterPatchStart + facei].reverseFace(), // mod face
-                masterPatchStart + facei,    // label of face being modified
-                slaveFaceCells[facei],        // owner
-                masterFaceCells[facei],       // neighbour
-                true,                         // face flip
-                -1,                           // patch for face
-                faceZoneID_.index(),          // zone for face
-                !mfFlip[facei]                // face flip in zone
-            );
-        }
-    }
-
-    // Renumber faces affected by point removal
-// Pout<< "slaveMeshPoints: " << slaveMeshPoints << endl;
-    // Make a map of faces that need to be renumbered
-    labelHashSet facesToModifyMap
-    (
-        slaveMeshPoints.size()*primitiveMesh::facesPerPoint_
-    );
-
-    const labelListList& pf = mesh.pointFaces();
-
-    // Grab all the faces off the points in the slave patch.  If the face has
-    //  not been removed, add it to the map of faces to renumber
-    forAll(slaveMeshPoints, pointi)
-    {
-        const labelList& curFaces = pf[slaveMeshPoints[pointi]];
-
-        forAll(curFaces, facei)
-        {
-            if (!ref.faceRemoved(curFaces[facei]))
-            {
-                facesToModifyMap.insert(curFaces[facei]);
-            }
-        }
-    }
-
-    // Grab the faces to be renumbered
-    const labelList ftm = facesToModifyMap.toc();
-
-    forAll(ftm, facei)
-    {
-        // For every face to modify, copy the face and re-map the vertices.
-        // It is known all the faces will be changed since they hang off
-        // re-mapped vertices
-        label curFaceID = ftm[facei];
-
-        face newFace(faces[curFaceID]);
-
-        forAll(newFace, pointi)
-        {
-            Map<label>::const_iterator rpmIter =
-                removedPointMap.find(newFace[pointi]);
-
-            if (rpmIter != removedPointMap.end())
-            {
-                // Point mapped. Replace it
-                newFace[pointi] = rpmIter();
-            }
-        }
-
-        // Pout<< "face label: " << curFaceID
-        //     << " old face: " << faces[curFaceID]
-        //     << " new face: " << newFace
-        //     << endl;
-
-        // Get face zone and its flip
-        label modifiedFaceZone = mesh.faceZones().whichZone(curFaceID);
-        bool modifiedFaceZoneFlip = false;
-
-        if (modifiedFaceZone >= 0)
-        {
-            modifiedFaceZoneFlip =
-                mesh.faceZones()[modifiedFaceZone].flipMap()
-                [
-                    mesh.faceZones()[modifiedFaceZone].whichFace(curFaceID)
-                ];
-        }
-
-
-        label patchID = mesh.boundaryMesh().whichPatch(curFaceID);
-        label neiCell;
-        if (patchID == -1)
-        {
-            neiCell = nei[curFaceID];
-        }
-        else
-        {
-            neiCell = -1;
-        }
-
-
-        // Modify the face
-        ref.modifyFace
-        (
-            newFace,                // modified face
-            curFaceID,              // label of face being modified
-            own[curFaceID],         // owner
-            neiCell,                // neighbour
-            false,                  // face flip
-            patchID,                // patch for face
-            modifiedFaceZone,       // zone for face
-            modifiedFaceZoneFlip    // face flip in zone
-        );
-    }
-
-    if (debug)
-    {
-        Pout<< "void attachDetach::attachInterface("
-            << "polyTopoChange& ref) const "
-            << " for object " << name() << " : "
-            << "Finished attaching interface" << endl;
-    }
-}
-
-
-void Foam::attachDetach::modifyMotionPoints
-(
-    pointField& motionPoints
-) const
-{
-    const Map<label>& removedPointMap = pointMatchMap();
-
-    const labelList removedPoints = removedPointMap.toc();
-
-    if (debug)
-    {
-        Pout<< "void attachDetach::modifyMotionPoints("
-            << "pointField& motionPoints) const "
-            << " for object " << name() << " : "
-            << "Adjusting motion points." << endl;
-
-        // Calculate the difference in motion point positions
-        scalar pointDiff = 0;
-
-        forAll(removedPoints, pointi)
-        {
-            pointDiff +=
-                mag
-                (
-                    motionPoints[removedPoints[pointi]]
-                  - motionPoints[removedPointMap.find(removedPoints[pointi])()]
-                );
-        }
-
-        if (pointDiff > removedPoints.size()*positionDifference_)
-        {
-            Pout<< "Point motion difference = " << pointDiff << endl;
-        }
-    }
-
-    // Put the slave point on top of the master point
-    forAll(removedPoints, pointi)
-    {
-        motionPoints[removedPoints[pointi]] =
-            motionPoints[removedPointMap.find(removedPoints[pointi])()];
-    }
-
-}
-
-
-// ************************************************************************* //
diff --git a/src/dynamicMesh/polyTopoChanger/attachDetach/detachInterface.C b/src/dynamicMesh/polyTopoChanger/attachDetach/detachInterface.C
deleted file mode 100644
index c978879c79..0000000000
--- a/src/dynamicMesh/polyTopoChanger/attachDetach/detachInterface.C
+++ /dev/null
@@ -1,459 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2023 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 "attachDetach.H"
-#include "polyMesh.H"
-#include "primitiveMesh.H"
-#include "polyTopoChange.H"
-#include "polyTopoChanger.H"
-
-// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
-
-void Foam::attachDetach::detachInterface
-(
-    polyTopoChange& ref
-) const
-{
-    // Algorithm:
-    // 1. Create new points for points of the master face zone
-    // 2. Modify all faces of the master zone, by putting them into the master
-    //    patch (look for orientation) and their renumbered mirror images
-    //    into the slave patch
-    // 3. Create a point renumbering list, giving a new point index for original
-    //    points in the face patch
-    // 4. Grab all faces in cells on the master side and renumber them
-    //    using the point renumbering list.  Exclude the ones that belong to
-    //    the master face zone
-    //
-    // Note on point creation:
-    // In order to take into account the issues related to partial
-    // blocking in an attach/detach mesh modifier, special treatment
-    // is required for the duplication of points on the edge of the
-    // face zone.  Points which are shared only by internal edges need
-    // not to be duplicated, as this would propagate the discontinuity
-    // in the mesh beyond the face zone.  Therefore, before creating
-    // the new points, check the external edge loop.  For each edge
-    // check if the edge is internal (i.e. does not belong to a
-    // patch); if so, exclude both of its points from duplication.
-
-    if (debug)
-    {
-        Pout<< "void attachDetach::detachInterface("
-            << "polyTopoChange& ref) const "
-            << " for object " << name() << " : "
-            << "Detaching interface" << endl;
-    }
-
-    const polyMesh& mesh = topoChanger().mesh();
-    const meshFaceZones& meshZones = mesh.faceZones();
-
-    // Check that zone is in increasing order (needed since adding faces
-    // in same order - otherwise polyTopoChange face ordering will mess up
-    // correspondence)
-    if (debug)
-    {
-        const labelList& faceLabels = meshZones[faceZoneID_.index()];
-        if (faceLabels.size() > 0)
-        {
-            for (label i = 1; i < faceLabels.size(); i++)
-            {
-                if (faceLabels[i] <= faceLabels[i-1])
-                {
-                    FatalErrorInFunction
-                        << "faceZone " << meshZones[faceZoneID_.index()].name()
-                        << " does not have mesh face labels in"
-                        << " increasing order." << endl
-                        << "Face label " << faceLabels[i]
-                        << " at position " << i
-                        << " is smaller than the previous value "
-                        << faceLabels[i-1]
-                        << exit(FatalError);
-                }
-            }
-        }
-    }
-
-
-
-    const primitiveFacePatch& masterFaceLayer =
-        meshZones[faceZoneID_.index()]();
-    const pointField& points = mesh.points();
-    const labelListList& meshEdgeFaces = mesh.edgeFaces();
-
-    const labelList& mp = masterFaceLayer.meshPoints();
-    const edgeList& zoneLocalEdges = masterFaceLayer.edges();
-
-    const labelList& meshEdges = meshZones[faceZoneID_.index()].meshEdges();
-
-    // Create the points
-
-    labelList addedPoints(mp.size(), -1);
-
-    // Go through boundary edges of the master patch.  If all the faces from
-    // this patch are internal, mark the points in the addedPoints lookup
-    // with their original labels to stop duplication
-    label nIntEdges = masterFaceLayer.nInternalEdges();
-
-    for (label curEdgeID = nIntEdges; curEdgeID < meshEdges.size(); curEdgeID++)
-    {
-        const labelList& curFaces = meshEdgeFaces[meshEdges[curEdgeID]];
-
-        bool edgeIsInternal = true;
-
-        forAll(curFaces, facei)
-        {
-            if (!mesh.isInternalFace(curFaces[facei]))
-            {
-                // The edge belongs to a boundary face
-                edgeIsInternal = false;
-                break;
-            }
-        }
-
-        if (edgeIsInternal)
-        {
-            const edge& e = zoneLocalEdges[curEdgeID];
-
-            // Reset the point creation
-            addedPoints[e.start()] = mp[e.start()];
-            addedPoints[e.end()] = mp[e.end()];
-        }
-    }
-// Pout<< "addedPoints before point creation: " << addedPoints << endl;
-
-    // Create new points for face zone
-    forAll(addedPoints, pointi)
-    {
-        if (addedPoints[pointi] < 0)
-        {
-            addedPoints[pointi] = ref.addPoint
-            (
-                points[mp[pointi]],        // point
-                mp[pointi],                // master point
-                -1,                        // zone ID
-                true                       // supports a cell
-            );
-            // Pout<< "Adding point " << addedPoints[pointi]
-            //    << " coord1:" << points[mp[pointi]]
-            //    << " coord2:" << masterFaceLayer.localPoints()[pointi]
-            //    << " for original point " << mp[pointi] << endl;
-        }
-    }
-
-    // Modify faces in the master zone and duplicate for the slave zone
-
-    const labelList& mf = meshZones[faceZoneID_.index()];
-    const boolList& mfFlip = meshZones[faceZoneID_.index()].flipMap();
-    const faceList& zoneFaces = masterFaceLayer.localFaces();
-
-    const faceList& faces = mesh.faces();
-    const labelList& own = mesh.faceOwner();
-    const labelList& nei = mesh.faceNeighbour();
-
-    forAll(mf, facei)
-    {
-        const label curFaceID = mf[facei];
-
-        // Build the face for the slave patch by renumbering
-        const face oldFace = zoneFaces[facei].reverseFace();
-
-        face newFace(oldFace.size());
-
-        forAll(oldFace, pointi)
-        {
-            newFace[pointi] = addedPoints[oldFace[pointi]];
-        }
-
-        if (mfFlip[facei])
-        {
-            // Face needs to be flipped for the master patch
-            ref.modifyFace
-            (
-                faces[curFaceID].reverseFace(), // modified face
-                curFaceID,                   // label of face being modified
-                nei[curFaceID],                 // owner
-                -1,                             // neighbour
-                true,                           // face flip
-                masterPatchID_.index(),         // patch for face
-                faceZoneID_.index(),            // zone for face
-                !mfFlip[facei]                  // face flip in zone
-            );
-
-            // Add renumbered face into the slave patch
-            // label addedFacei =
-            ref.addFace
-            (
-                newFace,                        // face
-                own[curFaceID],                 // owner
-                -1,                             // neighbour
-                -1,                             // master point
-                -1,                             // master edge
-                curFaceID,                      // master face
-                false,                          // flip flux
-                slavePatchID_.index(),          // patch to add the face to
-                -1,                             // zone for face
-                false                           // zone flip
-            );
-            //{
-            //    pointField newPts(ref.points());
-            // Pout<< "Flip.  Modifying face: " << ref.faces()[curFaceID]
-            //    << " fc:" <<  ref.faces()[curFaceID].centre(newPts)
-            //    << " next to cell: " << nei[curFaceID]
-            //    << " and adding face: " << newFace
-            //    << " fc:" << ref.faces()[addedFacei].centre(newPts)
-            //    << " next to cell: " << own[curFaceID] << endl;
-            //}
-        }
-        else
-        {
-            // No flip
-            ref.modifyFace
-            (
-                faces[curFaceID],         // modified face
-                curFaceID,                // label of face being modified
-                own[curFaceID],           // owner
-                -1,                       // neighbour
-                false,                    // face flip
-                masterPatchID_.index(),   // patch for face
-                faceZoneID_.index(),      // zone for face
-                mfFlip[facei]             // face flip in zone
-            );
-
-            // Add renumbered face into the slave patch
-            // label addedFacei =
-            ref.addFace
-            (
-                newFace,                        // face
-                nei[curFaceID],                 // owner
-                -1,                             // neighbour
-                -1,                             // master point
-                -1,                             // master edge
-                curFaceID,                      // master face
-                true,                           // flip flux
-                slavePatchID_.index(),          // patch to add the face to
-                -1,                             // zone for face
-                false                           // face flip in zone
-            );
-            //{
-            //    pointField newPts(ref.points());
-            // Pout<< "No flip.  Modifying face: " << ref.faces()[curFaceID]
-            //    << " fc:" <<  ref.faces()[curFaceID].centre(newPts)
-            //    << " next to cell: " << own[curFaceID]
-            //    << " and adding face: " << newFace
-            //    << " fc:" << ref.faces()[addedFacei].centre(newPts)
-            //    << " next to cell: " << nei[curFaceID] << endl;
-            //}
-        }
-    }
-
-    // Modify the remaining faces of the master cells to reconnect to the new
-    // layer of faces.
-
-    // Algorithm: Go through all the cells of the master zone and make
-    // a map of faces to avoid duplicates.  Do not insert the faces in
-    // the master patch (as they have already been dealt with).  Make
-    // a master layer point renumbering map, which for every point in
-    // the master layer gives its new label. Loop through all faces in
-    // the map and attempt to renumber them using the master layer
-    // point renumbering map.  Once the face is renumbered, compare it
-    // with the original face; if they are the same, the face has not
-    // changed; if not, modify the face but keep all of its old
-    // attributes (apart from the vertex numbers).
-
-    // Create the map of faces in the master cell layer
-    const labelList& mc =
-        mesh.faceZones()[faceZoneID_.index()].masterCells();
-
-    labelHashSet masterCellFaceMap(6*mc.size());
-
-    const cellList& cells = mesh.cells();
-
-    forAll(mc, celli)
-    {
-        const labelList& curFaces = cells[mc[celli]];
-
-        forAll(curFaces, facei)
-        {
-            // Check if the face belongs to the master patch; if not add it
-            if (meshZones.whichZone(curFaces[facei]) != faceZoneID_.index())
-            {
-                masterCellFaceMap.insert(curFaces[facei]);
-            }
-        }
-    }
-
-    // Extend the map to include first neighbours of the master cells to
-    // deal with multiple corners.
-    { // Protection and memory management
-        // Make a map of master cells for quick reject
-        labelHashSet mcMap(2*mc.size());
-
-        forAll(mc, mcI)
-        {
-            mcMap.insert(mc[mcI]);
-        }
-
-        // Go through all the faces in the masterCellFaceMap.  If the
-        // cells around them are not already used, add all of their
-        // faces to the map
-        const labelList mcf = masterCellFaceMap.toc();
-
-        forAll(mcf, mcfI)
-        {
-            // Do the owner side
-            const label ownCell = own[mcf[mcfI]];
-
-            if (!mcMap.found(ownCell))
-            {
-                // Cell not found. Add its faces to the map
-                const cell& curFaces = cells[ownCell];
-
-                forAll(curFaces, facei)
-                {
-                    masterCellFaceMap.insert(curFaces[facei]);
-                }
-            }
-
-            // Do the neighbour side if face is internal
-            if (mesh.isInternalFace(mcf[mcfI]))
-            {
-                const label neiCell = nei[mcf[mcfI]];
-
-                if (!mcMap.found(neiCell))
-                {
-                    // Cell not found. Add its faces to the map
-                    const cell& curFaces = cells[neiCell];
-
-                    forAll(curFaces, facei)
-                    {
-                        masterCellFaceMap.insert(curFaces[facei]);
-                    }
-                }
-            }
-        }
-    }
-
-    // Create the master layer point map
-    Map<label> masterLayerPointMap(2*mp.size());
-
-    forAll(mp, pointi)
-    {
-        masterLayerPointMap.insert
-        (
-            mp[pointi],
-            addedPoints[pointi]
-        );
-    }
-
-    // Grab the list of faces of the master layer
-    const labelList masterCellFaces = masterCellFaceMap.toc();
-
-    forAll(masterCellFaces, facei)
-    {
-        // Attempt to renumber the face using the masterLayerPointMap.
-        // Missing point remain the same
-
-        const label curFaceID = masterCellFaces[facei];
-
-        const face& oldFace = faces[curFaceID];
-
-        face newFace(oldFace.size());
-
-        bool changed = false;
-
-        forAll(oldFace, pointi)
-        {
-            if (masterLayerPointMap.found(oldFace[pointi]))
-            {
-                changed = true;
-
-                newFace[pointi] = masterLayerPointMap.find(oldFace[pointi])();
-            }
-            else
-            {
-                newFace[pointi] = oldFace[pointi];
-            }
-        }
-
-        // If the face has changed, create a modification entry
-        if (changed)
-        {
-            if (mesh.isInternalFace(curFaceID))
-            {
-                ref.modifyFace
-                (
-                    newFace,                    // face
-                    curFaceID,                  // master face
-                    own[curFaceID],             // owner
-                    nei[curFaceID],             // neighbour
-                    false,                      // flip flux
-                    -1,                         // patch for face
-                    -1,                         // zone for face
-                    false                       // face zone flip
-                );
-
-                // Pout<< "modifying stick-out face. Internal Old face: "
-                //     << oldFace
-                //     << " new face: " << newFace
-                //     << " own: " << own[curFaceID]
-                //     << " nei: " << nei[curFaceID]
-                //     << endl;
-            }
-            else
-            {
-                ref.modifyFace
-                (
-                    newFace,                     // face
-                    curFaceID,                   // master face
-                    own[curFaceID],              // owner
-                    -1,                          // neighbour
-                    false,                       // flip flux
-                    mesh.boundaryMesh().whichPatch(curFaceID), // patch
-                    -1,                           // zone for face
-                    false                         // face zone flip
-                );
-
-                // Pout<< "modifying stick-out face. Boundary Old face: "
-                //     << oldFace
-                //     << " new face: " << newFace
-                //     << " own: " << own[curFaceID]
-                //     << " patch: "
-                //     << mesh.boundaryMesh().whichPatch(curFaceID)
-                //     << endl;
-            }
-        }
-    }
-
-    if (debug)
-    {
-        Pout<< "void attachDetach::detachInterface("
-            << "polyTopoChange& ref) const "
-            << " for object " << name() << " : "
-            << "Finished detaching interface" << endl;
-    }
-}
-
-
-// ************************************************************************* //
diff --git a/src/dynamicMesh/polyTopoChanger/perfectInterface/perfectInterface.C b/src/dynamicMesh/polyTopoChanger/perfectInterface/perfectInterface.C
index 4a9d23f36c..cf02504706 100644
--- a/src/dynamicMesh/polyTopoChanger/perfectInterface/perfectInterface.C
+++ b/src/dynamicMesh/polyTopoChanger/perfectInterface/perfectInterface.C
@@ -28,7 +28,6 @@ Description
 \*---------------------------------------------------------------------------*/
 
 #include "perfectInterface.H"
-#include "polyTopoChanger.H"
 #include "polyMesh.H"
 #include "polyTopoChange.H"
 #include "addToRunTimeSelectionTable.H"
@@ -41,12 +40,6 @@ Description
 namespace Foam
 {
     defineTypeNameAndDebug(perfectInterface, 0);
-    addToRunTimeSelectionTable
-    (
-        polyMeshModifier,
-        perfectInterface,
-        dictionary
-    );
 }
 
 
@@ -78,44 +71,16 @@ Foam::pointField Foam::perfectInterface::calcFaceCentres
 Foam::perfectInterface::perfectInterface
 (
     const word& name,
-    const label index,
-    const polyTopoChanger& mme,
+    const polyMesh& mesh,
     const word& faceZoneName,
     const word& masterPatchName,
     const word& slavePatchName
 )
 :
-    polyMeshModifier(name, index, mme, true),
-    faceZoneID_(faceZoneName, mme.mesh().faceZones()),
-    masterPatchID_(masterPatchName, mme.mesh().boundaryMesh()),
-    slavePatchID_(slavePatchName, mme.mesh().boundaryMesh())
-{}
-
-
-Foam::perfectInterface::perfectInterface
-(
-    const word& name,
-    const dictionary& dict,
-    const label index,
-    const polyTopoChanger& mme
-)
-:
-    polyMeshModifier(name, index, mme, readBool(dict.lookup("active"))),
-    faceZoneID_
-    (
-        dict.lookup("faceZoneName"),
-        mme.mesh().faceZones()
-    ),
-    masterPatchID_
-    (
-        dict.lookup("masterPatchName"),
-        mme.mesh().boundaryMesh()
-    ),
-    slavePatchID_
-    (
-        dict.lookup("slavePatchName"),
-        mme.mesh().boundaryMesh()
-    )
+    polyMeshModifier(name, mesh),
+    faceZoneID_(faceZoneName, mesh.faceZones()),
+    masterPatchID_(masterPatchName, mesh.boundaryMesh()),
+    slavePatchID_(slavePatchName, mesh.boundaryMesh())
 {}
 
 
@@ -129,23 +94,7 @@ Foam::perfectInterface::~perfectInterface()
 
 bool Foam::perfectInterface::changeTopology() const
 {
-    // If modifier is inactive, skip change
-    if (!active())
-    {
-        if (debug)
-        {
-            Pout<< "bool perfectInterface::changeTopology() const "
-                << "for object " << name() << " : "
-                << "Inactive" << endl;
-        }
-
-        return false;
-    }
-    else
-    {
-        // I want topo change every time step.
-        return true;
-    }
+    return true;
 }
 
 
@@ -156,7 +105,7 @@ void Foam::perfectInterface::setRefinement
     polyTopoChange& ref
 ) const
 {
-    const polyMesh& mesh = topoChanger().mesh();
+    const polyMesh& mesh = this->mesh();
 
     const polyBoundaryMesh& patches = mesh.boundaryMesh();
 
@@ -432,7 +381,7 @@ void Foam::perfectInterface::setRefinement(polyTopoChange& ref) const
      && faceZoneID_.active()
     )
     {
-        const polyMesh& mesh = topoChanger().mesh();
+        const polyMesh& mesh = this->mesh();
 
         const polyBoundaryMesh& patches = mesh.boundaryMesh();
         const polyPatch& patch0 = patches[masterPatchID_.index()];
@@ -468,7 +417,7 @@ void Foam::perfectInterface::modifyMotionPoints(pointField& motionPoints) const
 void Foam::perfectInterface::topoChange(const polyTopoChangeMap& map)
 {
     // Mesh has changed topologically.  Update local topological data
-    const polyMesh& mesh = topoChanger().mesh();
+    const polyMesh& mesh = this->mesh();
 
     faceZoneID_.update(mesh.faceZones());
     masterPatchID_.update(mesh.boundaryMesh());
@@ -476,37 +425,4 @@ void Foam::perfectInterface::topoChange(const polyTopoChangeMap& map)
 }
 
 
-void Foam::perfectInterface::write(Ostream& os) const
-{
-    os  << nl << type() << nl
-        << name()<< nl
-        << faceZoneID_.name() << nl
-        << masterPatchID_.name() << nl
-        << slavePatchID_.name() << endl;
-}
-
-
-void Foam::perfectInterface::writeDict(Ostream& os) const
-{
-    os  << nl << name() << nl << token::BEGIN_BLOCK << nl
-
-        << "    type " << type()
-        << token::END_STATEMENT << nl
-
-        << "    active " << active()
-        << token::END_STATEMENT << nl
-
-        << "    faceZoneName " << faceZoneID_.name()
-        << token::END_STATEMENT << nl
-
-        << "    masterPatchName " << masterPatchID_.name()
-        << token::END_STATEMENT << nl
-
-        << "    slavePatchName " << slavePatchID_.name()
-        << token::END_STATEMENT << nl
-
-        << token::END_BLOCK << endl;
-}
-
-
 // ************************************************************************* //
diff --git a/src/dynamicMesh/polyTopoChanger/perfectInterface/perfectInterface.H b/src/dynamicMesh/polyTopoChanger/perfectInterface/perfectInterface.H
index 1304059475..209f7edcf8 100644
--- a/src/dynamicMesh/polyTopoChanger/perfectInterface/perfectInterface.H
+++ b/src/dynamicMesh/polyTopoChanger/perfectInterface/perfectInterface.H
@@ -90,22 +90,12 @@ public:
         perfectInterface
         (
             const word& name,
-            const label index,
-            const polyTopoChanger& mme,
+            const polyMesh& mesh,
             const word& faceZoneName,
             const word& masterPatchName,
             const word& slavePatchName
         );
 
-        //- Construct from dictionary
-        perfectInterface
-        (
-            const word& name,
-            const dictionary& dict,
-            const label index,
-            const polyTopoChanger& mme
-        );
-
         //- Disallow default bitwise copy construction
         perfectInterface(const perfectInterface&) = delete;
 
@@ -140,12 +130,6 @@ public:
         //- Force recalculation of locally stored data on topological change
         virtual void topoChange(const polyTopoChangeMap&);
 
-        //- Write
-        virtual void write(Ostream&) const;
-
-        //- Write dictionary
-        virtual void writeDict(Ostream&) const;
-
 
     // Member Operators
 
diff --git a/src/dynamicMesh/polyTopoChanger/polyMeshModifier/polyMeshModifier.C b/src/dynamicMesh/polyTopoChanger/polyMeshModifier/polyMeshModifier.C
index a774be75f4..fe179933e8 100644
--- a/src/dynamicMesh/polyTopoChanger/polyMeshModifier/polyMeshModifier.C
+++ b/src/dynamicMesh/polyTopoChanger/polyMeshModifier/polyMeshModifier.C
@@ -27,8 +27,6 @@ Description
 \*---------------------------------------------------------------------------*/
 
 #include "polyMeshModifier.H"
-#include "dictionary.H"
-#include "polyTopoChanger.H"
 #include "polyMesh.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
@@ -36,25 +34,18 @@ Description
 namespace Foam
 {
     defineTypeNameAndDebug(polyMeshModifier, 0);
-
-    defineRunTimeSelectionTable(polyMeshModifier, dictionary);
 }
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
-// Construct from components
 Foam::polyMeshModifier::polyMeshModifier
 (
     const word& name,
-    const label index,
-    const polyTopoChanger& mme,
-    const bool act
+    const polyMesh& mesh
 )
 :
     name_(name),
-    index_(index),
-    topoChanger_(mme),
-    active_(act)
+    mesh_(mesh)
 {}
 
 
@@ -66,19 +57,9 @@ Foam::polyMeshModifier::~polyMeshModifier()
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
-const Foam::polyTopoChanger& Foam::polyMeshModifier::topoChanger() const
+const Foam::polyMesh& Foam::polyMeshModifier::mesh() const
 {
-    return topoChanger_;
-}
-
-
-// * * * * * * * * * * * * * * * Friend Operators  * * * * * * * * * * * * * //
-
-Foam::Ostream& Foam::operator<<(Ostream& os, const polyMeshModifier& pmm)
-{
-    pmm.write(os);
-    os.check("Ostream& operator<<(Ostream& f, const polyMeshModifier& pmm)");
-    return os;
+    return mesh_;
 }
 
 
diff --git a/src/dynamicMesh/polyTopoChanger/polyMeshModifier/polyMeshModifier.H b/src/dynamicMesh/polyTopoChanger/polyMeshModifier/polyMeshModifier.H
index 5dd412f468..a4f96ce4e7 100644
--- a/src/dynamicMesh/polyTopoChanger/polyMeshModifier/polyMeshModifier.H
+++ b/src/dynamicMesh/polyTopoChanger/polyMeshModifier/polyMeshModifier.H
@@ -35,15 +35,8 @@ SourceFiles
 #ifndef polyMeshModifier_H
 #define polyMeshModifier_H
 
-#include "label.H"
-#include "word.H"
-#include "Switch.H"
 #include "typeInfo.H"
-#include "runTimeSelectionTables.H"
-#include "autoPtr.H"
-#include "pointField.H"
-#include "faceList.H"
-#include "cellList.H"
+#include "pointFieldFwd.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -51,18 +44,11 @@ namespace Foam
 {
 
 // Forward declaration of classes
-class polyTopoChanger;
+class polyMesh;
 class polyTopoChange;
 class polyTopoChangeMap;
 
 
-// Forward declaration of friend functions and operators
-
-class polyMeshModifier;
-
-Ostream& operator<<(Ostream&, const polyMeshModifier&);
-
-
 /*---------------------------------------------------------------------------*\
                       Class polyMeshModifier Declaration
 \*---------------------------------------------------------------------------*/
@@ -74,14 +60,8 @@ class polyMeshModifier
         //- Name of modifier
         word name_;
 
-        //- Index of modifier
-        label index_;
-
-        //- Reference to morph engine
-        const polyTopoChanger& topoChanger_;
-
-        //- Activation switch
-        mutable Switch active_;
+        //- Reference to mesh
+        const polyMesh& mesh_;
 
 
 public:
@@ -92,50 +72,19 @@ public:
         TypeName("meshModifier");
 
 
-    // Declare run-time constructor selection tables
-
-        declareRunTimeSelectionTable
-        (
-            autoPtr,
-            polyMeshModifier,
-            dictionary,
-            (
-                const word& name,
-                const dictionary& dict,
-                const label index,
-                const polyTopoChanger& mme
-            ),
-            (name, dict, index, mme)
-        );
-
-
     // Constructors
 
         //- Construct from components
         polyMeshModifier
         (
             const word& name,
-            const label index,
-            const polyTopoChanger& mme,
-            const bool act
+            const polyMesh& mme
         );
 
         //- Disallow default bitwise copy construction
         polyMeshModifier(const polyMeshModifier&) = delete;
 
 
-    // Selectors
-
-        //- Select constructed from dictionary
-        static autoPtr<polyMeshModifier> New
-        (
-            const word& name,
-            const dictionary& dict,
-            const label index,
-            const polyTopoChanger& mme
-        );
-
-
     //- Destructor
     virtual ~polyMeshModifier();
 
@@ -148,14 +97,8 @@ public:
             return name_;
         }
 
-        //- Return the index of this modifier
-        label index() const
-        {
-            return index_;
-        }
-
-        //- Return reference to morph engine
-        const polyTopoChanger& topoChanger() const;
+        //- Return reference to mesh
+        const polyMesh& mesh() const;
 
         //- Check for topology change
         virtual bool changeTopology() const = 0;
@@ -170,42 +113,10 @@ public:
         virtual void topoChange(const polyTopoChangeMap&) = 0;
 
 
-        // Activation and deactivation
-
-            const Switch& active() const
-            {
-                return active_;
-            }
-
-            //- Activate mesh modifier
-            void enable() const
-            {
-                active_ = true;
-            }
-
-            //- Activate mesh modifier
-            void disable() const
-            {
-                active_ = false;
-            }
-
-
-        //- Write
-        virtual void write(Ostream&) const = 0;
-
-        //- Write dictionary
-        virtual void writeDict(Ostream&) const = 0;
-
-
     // Member Operators
 
         //- Disallow default bitwise assignment
         void operator=(const polyMeshModifier&) = delete;
-
-
-    // Ostream Operator
-
-        friend Ostream& operator<<(Ostream&, const polyMeshModifier&);
 };
 
 
diff --git a/src/dynamicMesh/polyTopoChanger/polyMeshModifier/polyMeshModifierNew.C b/src/dynamicMesh/polyTopoChanger/polyMeshModifier/polyMeshModifierNew.C
deleted file mode 100644
index c87f098ce5..0000000000
--- a/src/dynamicMesh/polyTopoChanger/polyMeshModifier/polyMeshModifierNew.C
+++ /dev/null
@@ -1,65 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     | Website:  https://openfoam.org
-    \\  /    A nd           | Copyright (C) 2011-2023 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 "polyMeshModifier.H"
-#include "dictionary.H"
-
-// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
-
-Foam::autoPtr<Foam::polyMeshModifier> Foam::polyMeshModifier::New
-(
-    const word& name,
-    const dictionary& dict,
-    const label index,
-    const polyTopoChanger& mme
-)
-{
-    if (debug)
-    {
-        InfoInFunction << "Constructing polyMeshModifier" << endl;
-    }
-
-    const word modifierType(dict.lookup("type"));
-
-    dictionaryConstructorTable::iterator cstrIter =
-        dictionaryConstructorTablePtr_->find(modifierType);
-
-    if (cstrIter == dictionaryConstructorTablePtr_->end())
-    {
-        FatalIOErrorInFunction
-        (
-            dict
-        )   << "Unknown polyMeshModifier type "
-            << modifierType << nl << nl
-            << "Valid polyMeshModifier types are :" << endl
-            << dictionaryConstructorTablePtr_->sortedToc()
-            << exit(FatalIOError);
-    }
-
-    return autoPtr<polyMeshModifier>(cstrIter()(name, dict, index, mme));
-}
-
-
-// ************************************************************************* //
diff --git a/src/dynamicMesh/polyTopoChanger/polyTopoChanger/polyTopoChanger.C b/src/dynamicMesh/polyTopoChanger/polyTopoChanger/polyTopoChanger.C
index 8640f3d8da..e5319973b2 100644
--- a/src/dynamicMesh/polyTopoChanger/polyTopoChanger/polyTopoChanger.C
+++ b/src/dynamicMesh/polyTopoChanger/polyTopoChanger/polyTopoChanger.C
@@ -54,36 +54,24 @@ bool Foam::polyTopoChanger::changeTopology() const
 
     forAll(topoChanges, morphI)
     {
-        if (topoChanges[morphI].active())
+        bool curTriggerChange = topoChanges[morphI].changeTopology();
+
+        if (debug)
         {
-            bool curTriggerChange = topoChanges[morphI].changeTopology();
+            Info<< "Modifier " << morphI << " named "
+                << topoChanges[morphI].name();
 
-            if (debug)
+            if (curTriggerChange)
             {
-                Info<< "Modifier " << morphI << " named "
-                    << topoChanges[morphI].name();
-
-                if (curTriggerChange)
-                {
-                    Info<< " morphing" << endl;
-                }
-                else
-                {
-                    Info<< " unchanged" << endl;
-                }
+                Info<< " morphing" << endl;
             }
-
-            triggerChange = triggerChange || curTriggerChange;
-        }
-        else
-        {
-            if (debug)
+            else
             {
-                Info<< "Modifier " << morphI  << " named "
-                    << topoChanges[morphI].name() << " inactive" << endl;
+                Info<< " unchanged" << endl;
             }
         }
 
+        triggerChange = triggerChange || curTriggerChange;
     }
 
     return triggerChange;
@@ -101,10 +89,7 @@ Foam::polyTopoChanger::topoChangeRequest() const
 
     forAll(topoChanges, morphI)
     {
-        if (topoChanges[morphI].active())
-        {
-            topoChanges[morphI].setRefinement(ref);
-        }
+        topoChanges[morphI].setRefinement(ref);
     }
 
     return autoPtr<polyTopoChange>(refPtr);
diff --git a/src/dynamicMesh/polyTopoChanger/slidingInterface/coupleSlidingInterface.C b/src/dynamicMesh/polyTopoChanger/slidingInterface/coupleSlidingInterface.C
index e1510f4439..ea537ac0ee 100644
--- a/src/dynamicMesh/polyTopoChanger/slidingInterface/coupleSlidingInterface.C
+++ b/src/dynamicMesh/polyTopoChanger/slidingInterface/coupleSlidingInterface.C
@@ -32,7 +32,6 @@ License
 #include "pointHit.H"
 #include "triPointRef.H"
 #include "plane.H"
-#include "polyTopoChanger.H"
 #include "polyAddPoint.H"
 #include "polyRemovePoint.H"
 #include "polyAddFace.H"
@@ -74,7 +73,7 @@ void Foam::slidingInterface::coupleInterface(polyTopoChange& ref) const
             << "Coupling sliding interface " << name() << endl;
     }
 
-    const polyMesh& mesh = topoChanger().mesh();
+    const polyMesh& mesh = this->mesh();
 
     const pointField& points = mesh.points();
     const faceList& faces = mesh.faces();
diff --git a/src/dynamicMesh/polyTopoChanger/slidingInterface/decoupleSlidingInterface.C b/src/dynamicMesh/polyTopoChanger/slidingInterface/decoupleSlidingInterface.C
index 60998020aa..eca1df477d 100644
--- a/src/dynamicMesh/polyTopoChanger/slidingInterface/decoupleSlidingInterface.C
+++ b/src/dynamicMesh/polyTopoChanger/slidingInterface/decoupleSlidingInterface.C
@@ -27,7 +27,6 @@ License
 #include "polyMesh.H"
 #include "primitiveMesh.H"
 #include "polyTopoChange.H"
-#include "polyTopoChanger.H"
 #include "polyModifyFace.H"
 #include "polyModifyPoint.H"
 
@@ -60,7 +59,7 @@ void Foam::slidingInterface::decoupleInterface
     // Clear previous couple
     clearCouple(ref);
 
-    const polyMesh& mesh = topoChanger().mesh();
+    const polyMesh& mesh = this->mesh();
     const faceList& faces = mesh.faces();
     const cellList& cells = mesh.cells();
 
diff --git a/src/dynamicMesh/polyTopoChanger/slidingInterface/slidingInterface.C b/src/dynamicMesh/polyTopoChanger/slidingInterface/slidingInterface.C
index 65858e746f..e195b0e7cf 100644
--- a/src/dynamicMesh/polyTopoChanger/slidingInterface/slidingInterface.C
+++ b/src/dynamicMesh/polyTopoChanger/slidingInterface/slidingInterface.C
@@ -24,7 +24,6 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "slidingInterface.H"
-#include "polyTopoChanger.H"
 #include "polyMesh.H"
 #include "polyTopoChange.H"
 #include "addToRunTimeSelectionTable.H"
@@ -39,12 +38,6 @@ License
 namespace Foam
 {
     defineTypeNameAndDebug(slidingInterface, 0);
-    addToRunTimeSelectionTable
-    (
-        polyMeshModifier,
-        slidingInterface,
-        dictionary
-    );
 
     template<>
     const char* Foam::NamedEnum
@@ -67,7 +60,7 @@ Foam::slidingInterface::typeOfMatchNames_;
 
 void Foam::slidingInterface::checkDefinition()
 {
-    const polyMesh& mesh = topoChanger().mesh();
+    const polyMesh& mesh = this->mesh();
 
     if
     (
@@ -116,13 +109,10 @@ void Foam::slidingInterface::clearOut() const
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
-
-// Construct from components
 Foam::slidingInterface::slidingInterface
 (
     const word& name,
-    const label index,
-    const polyTopoChanger& mme,
+    const polyMesh& mesh,
     const word& masterFaceZoneName,
     const word& slaveFaceZoneName,
     const word& cutPointZoneName,
@@ -134,36 +124,36 @@ Foam::slidingInterface::slidingInterface
     const intersection::algorithm algo
 )
 :
-    polyMeshModifier(name, index, mme, true),
+    polyMeshModifier(name, mesh),
     masterFaceZoneID_
     (
         masterFaceZoneName,
-        mme.mesh().faceZones()
+        mesh.faceZones()
     ),
     slaveFaceZoneID_
     (
         slaveFaceZoneName,
-        mme.mesh().faceZones()
+        mesh.faceZones()
     ),
     cutPointZoneID_
     (
         cutPointZoneName,
-        mme.mesh().pointZones()
+        mesh.pointZones()
     ),
     cutFaceZoneID_
     (
         cutFaceZoneName,
-        mme.mesh().faceZones()
+        mesh.faceZones()
     ),
     masterPatchID_
     (
         masterPatchName,
-        mme.mesh().boundaryMesh()
+        mesh.boundaryMesh()
     ),
     slavePatchID_
     (
         slavePatchName,
-        mme.mesh().boundaryMesh()
+        mesh.boundaryMesh()
     ),
     matchType_(tom),
     coupleDecouple_(coupleDecouple),
@@ -208,105 +198,6 @@ Foam::slidingInterface::slidingInterface
 }
 
 
-// Construct from components
-Foam::slidingInterface::slidingInterface
-(
-    const word& name,
-    const dictionary& dict,
-    const label index,
-    const polyTopoChanger& mme
-)
-:
-    polyMeshModifier(name, index, mme, Switch(dict.lookup("active"))),
-    masterFaceZoneID_
-    (
-        dict.lookup("masterFaceZoneName"),
-        mme.mesh().faceZones()
-    ),
-    slaveFaceZoneID_
-    (
-        dict.lookup("slaveFaceZoneName"),
-        mme.mesh().faceZones()
-    ),
-    cutPointZoneID_
-    (
-        dict.lookup("cutPointZoneName"),
-        mme.mesh().pointZones()
-    ),
-    cutFaceZoneID_
-    (
-        dict.lookup("cutFaceZoneName"),
-        mme.mesh().faceZones()
-    ),
-    masterPatchID_
-    (
-        dict.lookup("masterPatchName"),
-        mme.mesh().boundaryMesh()
-    ),
-    slavePatchID_
-    (
-        dict.lookup("slavePatchName"),
-        mme.mesh().boundaryMesh()
-    ),
-    matchType_(typeOfMatchNames_.read((dict.lookup("typeOfMatch")))),
-    coupleDecouple_(dict.lookup("coupleDecouple")),
-    attached_(dict.lookup("attached")),
-    projectionAlgo_
-    (
-        intersection::algorithmNames_.read(dict.lookup("projection"))
-    ),
-    trigger_(false),
-    cutFaceMasterPtr_(nullptr),
-    cutFaceSlavePtr_(nullptr),
-    masterFaceCellsPtr_(nullptr),
-    slaveFaceCellsPtr_(nullptr),
-    masterStickOutFacesPtr_(nullptr),
-    slaveStickOutFacesPtr_(nullptr),
-    retiredPointMapPtr_(nullptr),
-    cutPointEdgePairMapPtr_(nullptr),
-    slavePointPointHitsPtr_(nullptr),
-    slavePointEdgeHitsPtr_(nullptr),
-    slavePointFaceHitsPtr_(nullptr),
-    masterPointEdgeHitsPtr_(nullptr),
-    projectedSlavePointsPtr_(nullptr)
-{
-    // Optionally default tolerances from dictionary
-    setTolerances(dict);
-
-    checkDefinition();
-
-    // If the interface is attached, the master and slave face zone addressing
-    // needs to be read in; otherwise it will be created
-    if (attached_)
-    {
-        if (debug)
-        {
-            Pout<< "slidingInterface::slidingInterface(...) "
-                << " for object " << name << " : "
-                << "Interface attached.  Reading master and slave face zones "
-                << "and retired point lookup." << endl;
-        }
-
-        // The face zone addressing is written out in the definition dictionary
-        masterFaceCellsPtr_ = new labelList(dict.lookup("masterFaceCells"));
-        slaveFaceCellsPtr_ = new labelList(dict.lookup("slaveFaceCells"));
-
-        masterStickOutFacesPtr_ =
-            new labelList(dict.lookup("masterStickOutFaces"));
-        slaveStickOutFacesPtr_ =
-            new labelList(dict.lookup("slaveStickOutFaces"));
-
-        retiredPointMapPtr_ = new Map<label>(dict.lookup("retiredPointMap"));
-        cutPointEdgePairMapPtr_ =
-            new Map<Pair<edge>>(dict.lookup("cutPointEdgePairMap"));
-    }
-    else
-    {
-        calcAttachedAddressing();
-    }
-}
-
-
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 
 Foam::slidingInterface::~slidingInterface()
@@ -362,7 +253,7 @@ bool Foam::slidingInterface::changeTopology() const
     if
     (
         attached_
-     && !topoChanger().mesh().changing()
+     && !mesh().changing()
     )
     {
         // If the mesh is not moving or morphing and the interface is
@@ -419,7 +310,7 @@ void Foam::slidingInterface::modifyMotionPoints(pointField& motionPoints) const
             << "Adjusting motion points." << endl;
     }
 
-    const polyMesh& mesh = topoChanger().mesh();
+    const polyMesh& mesh = this->mesh();
 
     // Get point from the cut zone
     const labelList& cutPoints = mesh.pointZones()[cutPointZoneID_.index()];
@@ -653,7 +544,7 @@ void Foam::slidingInterface::topoChange(const polyTopoChangeMap& m)
     }
 
     // Mesh has changed topologically.  Update local topological data
-    const polyMesh& mesh = topoChanger().mesh();
+    const polyMesh& mesh = this->mesh();
 
     masterFaceZoneID_.update(mesh.faceZones());
     slaveFaceZoneID_.update(mesh.faceZones());
@@ -743,81 +634,4 @@ void Foam::slidingInterface::setTolerances(const dictionary&dict, bool report)
 }
 
 
-void Foam::slidingInterface::write(Ostream& os) const
-{
-    os  << nl << type() << nl
-        << name()<< nl
-        << masterFaceZoneID_.name() << nl
-        << slaveFaceZoneID_.name() << nl
-        << cutPointZoneID_.name() << nl
-        << cutFaceZoneID_.name() << nl
-        << masterPatchID_.name() << nl
-        << slavePatchID_.name() << nl
-        << typeOfMatchNames_[matchType_] << nl
-        << coupleDecouple_ << nl
-        << attached_ << endl;
-}
-
-
-// To write out all those tolerances
-#define WRITE_NON_DEFAULT(name) \
-    if ( name ## _ != name ## Default_ )\
-    { \
-        os << "    " #name " " <<  name ## _ << token::END_STATEMENT << nl; \
-    }
-
-
-void Foam::slidingInterface::writeDict(Ostream& os) const
-{
-    os  << nl << name() << nl << token::BEGIN_BLOCK << nl
-        << "    type " << type() << token::END_STATEMENT << nl
-        << "    masterFaceZoneName " << masterFaceZoneID_.name()
-        << token::END_STATEMENT << nl
-        << "    slaveFaceZoneName " << slaveFaceZoneID_.name()
-        << token::END_STATEMENT << nl
-        << "    cutPointZoneName " << cutPointZoneID_.name()
-        << token::END_STATEMENT << nl
-        << "    cutFaceZoneName " << cutFaceZoneID_.name()
-        << token::END_STATEMENT << nl
-        << "    masterPatchName " << masterPatchID_.name()
-        << token::END_STATEMENT << nl
-        << "    slavePatchName " << slavePatchID_.name()
-        << token::END_STATEMENT << nl
-        << "    typeOfMatch " << typeOfMatchNames_[matchType_]
-        << token::END_STATEMENT << nl
-        << "    coupleDecouple " << coupleDecouple_
-        << token::END_STATEMENT << nl
-        << "    projection " << intersection::algorithmNames_[projectionAlgo_]
-        << token::END_STATEMENT << nl
-        << "    attached " << attached_
-        << token::END_STATEMENT << nl
-        << "    active " << active()
-        << token::END_STATEMENT << nl;
-
-    if (attached_)
-    {
-        writeEntry(os, "masterFaceCells", *masterFaceCellsPtr_);
-        writeEntry(os, "slaveFaceCells", *slaveFaceCellsPtr_);
-        writeEntry(os, "masterStickOutFaces", *masterStickOutFacesPtr_);
-        writeEntry(os, "slaveStickOutFaces", *slaveStickOutFacesPtr_);
-
-         os << "    retiredPointMap " << retiredPointMap()
-            << token::END_STATEMENT << nl
-            << "    cutPointEdgePairMap " << cutPointEdgePairMap()
-            << token::END_STATEMENT << nl;
-    }
-
-    WRITE_NON_DEFAULT(pointMergeTol)
-    WRITE_NON_DEFAULT(edgeMergeTol)
-    WRITE_NON_DEFAULT(nFacesPerSlaveEdge)
-    WRITE_NON_DEFAULT(edgeFaceEscapeLimit)
-    WRITE_NON_DEFAULT(integralAdjTol)
-    WRITE_NON_DEFAULT(edgeMasterCatchFraction)
-    WRITE_NON_DEFAULT(edgeCoPlanarTol)
-    WRITE_NON_DEFAULT(edgeEndCutoffTol)
-
-    os  << token::END_BLOCK << endl;
-}
-
-
 // ************************************************************************* //
diff --git a/src/dynamicMesh/polyTopoChanger/slidingInterface/slidingInterface.H b/src/dynamicMesh/polyTopoChanger/slidingInterface/slidingInterface.H
index ecf0659432..4ae040fa86 100644
--- a/src/dynamicMesh/polyTopoChanger/slidingInterface/slidingInterface.H
+++ b/src/dynamicMesh/polyTopoChanger/slidingInterface/slidingInterface.H
@@ -309,8 +309,7 @@ public:
         slidingInterface
         (
             const word& name,
-            const label index,
-            const polyTopoChanger& mme,
+            const polyMesh& mesh,
             const word& masterFaceZoneName,
             const word& slaveFaceZoneName,
             const word& cutPointZoneName,
@@ -323,15 +322,6 @@ public:
                 intersection::algorithm::visible
         );
 
-        //- Construct from dictionary
-        slidingInterface
-        (
-            const word& name,
-            const dictionary& dict,
-            const label index,
-            const polyTopoChanger& mme
-        );
-
         //- Disallow default bitwise copy construction
         slidingInterface(const slidingInterface&) = delete;
 
@@ -373,12 +363,6 @@ public:
         //- Set the tolerances from the values in a dictionary
         void setTolerances(const dictionary&, bool report=false);
 
-        //- Write
-        virtual void write(Ostream&) const;
-
-        //- Write dictionary
-        virtual void writeDict(Ostream&) const;
-
 
     // Member Operators
 
diff --git a/src/dynamicMesh/polyTopoChanger/slidingInterface/slidingInterfaceAttachedAddressing.C b/src/dynamicMesh/polyTopoChanger/slidingInterface/slidingInterfaceAttachedAddressing.C
index a18ee0f6ba..e12e6b52d4 100644
--- a/src/dynamicMesh/polyTopoChanger/slidingInterface/slidingInterfaceAttachedAddressing.C
+++ b/src/dynamicMesh/polyTopoChanger/slidingInterface/slidingInterfaceAttachedAddressing.C
@@ -26,7 +26,6 @@ License
 #include "slidingInterface.H"
 #include "polyMesh.H"
 #include "polyTopoChangeMap.H"
-#include "polyTopoChanger.H"
 
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 
@@ -45,7 +44,7 @@ void Foam::slidingInterface::calcAttachedAddressing() const
         // Clear existing addressing
         clearAttachedAddressing();
 
-        const polyMesh& mesh = topoChanger().mesh();
+        const polyMesh& mesh = this->mesh();
         const labelList& own = mesh.faceOwner();
         const labelList& nei = mesh.faceNeighbour();
         const meshFaceZones& faceZones = mesh.faceZones();
diff --git a/src/dynamicMesh/polyTopoChanger/slidingInterface/slidingInterfaceClearCouple.C b/src/dynamicMesh/polyTopoChanger/slidingInterface/slidingInterfaceClearCouple.C
index 4430d6e94b..12a4b83694 100644
--- a/src/dynamicMesh/polyTopoChanger/slidingInterface/slidingInterfaceClearCouple.C
+++ b/src/dynamicMesh/polyTopoChanger/slidingInterface/slidingInterfaceClearCouple.C
@@ -26,7 +26,6 @@ License
 #include "slidingInterface.H"
 #include "polyTopoChange.H"
 #include "polyMesh.H"
-#include "polyTopoChanger.H"
 #include "polyRemovePoint.H"
 #include "polyRemoveFace.H"
 
@@ -46,7 +45,7 @@ void Foam::slidingInterface::clearCouple
 
     // Remove all points from the point zone
 
-    const polyMesh& mesh = topoChanger().mesh();
+    const polyMesh& mesh = this->mesh();
 
     const labelList& cutPointZoneLabels =
         mesh.pointZones()[cutPointZoneID_.index()];
diff --git a/src/dynamicMesh/polyTopoChanger/slidingInterface/slidingInterfaceProjectPoints.C b/src/dynamicMesh/polyTopoChanger/slidingInterface/slidingInterfaceProjectPoints.C
index e54629f517..0801ae6d18 100644
--- a/src/dynamicMesh/polyTopoChanger/slidingInterface/slidingInterfaceProjectPoints.C
+++ b/src/dynamicMesh/polyTopoChanger/slidingInterface/slidingInterfaceProjectPoints.C
@@ -26,7 +26,6 @@ License
 #include "slidingInterface.H"
 #include "polyMesh.H"
 #include "line.H"
-#include "polyTopoChanger.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
@@ -87,7 +86,7 @@ bool Foam::slidingInterface::projectPoints() const
     //    on the master and leave the slave point where it started
     //    from and the miss is recorded.
 
-    const polyMesh& mesh = topoChanger().mesh();
+    const polyMesh& mesh = this->mesh();
 
     const primitiveFacePatch& masterPatch =
         mesh.faceZones()[masterFaceZoneID_.index()]();