Add the OpenFOAM source tree

applications/utilities/mesh/advanced/modifyMesh/Make/files

@@ -0,0 +1,4 @@
+cellSplitter.C
+modifyMesh.C
+
+EXE = $(FOAM_APPBIN)/modifyMesh

applications/utilities/mesh/advanced/modifyMesh/Make/options

@@ -0,0 +1,7 @@
+EXE_INC = \
+    -I$(LIB_SRC)/meshTools/lnInclude \
+    -I$(LIB_SRC)/dynamicMesh/lnInclude
+
+EXE_LIBS = \
+    -lmeshTools \
+    -ldynamicMesh

applications/utilities/mesh/advanced/modifyMesh/cellSplitter.C

@@ -0,0 +1,491 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2012 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 "cellSplitter.H"
+#include "polyMesh.H"
+#include "polyTopoChange.H"
+#include "polyAddCell.H"
+#include "polyAddFace.H"
+#include "polyAddPoint.H"
+#include "polyModifyFace.H"
+#include "mapPolyMesh.H"
+#include "meshTools.H"
+
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+defineTypeNameAndDebug(cellSplitter, 0);
+}
+
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+void Foam::cellSplitter::getFaceInfo
+(
+    const label faceI,
+    label& patchID,
+    label& zoneID,
+    label& zoneFlip
+) const
+{
+    patchID = -1;
+
+    if (!mesh_.isInternalFace(faceI))
+    {
+        patchID = mesh_.boundaryMesh().whichPatch(faceI);
+    }
+
+    zoneID = mesh_.faceZones().whichZone(faceI);
+
+    zoneFlip = false;
+
+    if (zoneID >= 0)
+    {
+        const faceZone& fZone = mesh_.faceZones()[zoneID];
+
+        zoneFlip = fZone.flipMap()[fZone.whichFace(faceI)];
+    }
+}
+
+
+// Find the new owner of faceI (since the original cell has been split into
+// newCells
+Foam::label Foam::cellSplitter::newOwner
+(
+    const label faceI,
+    const Map<labelList>& cellToCells
+) const
+{
+    label oldOwn = mesh_.faceOwner()[faceI];
+
+    Map<labelList>::const_iterator fnd = cellToCells.find(oldOwn);
+
+    if (fnd == cellToCells.end())
+    {
+        // Unsplit cell
+        return oldOwn;
+    }
+    else
+    {
+        // Look up index of face in the cells' faces.
+
+        const labelList& newCells = fnd();
+
+        const cell& cFaces = mesh_.cells()[oldOwn];
+
+        return newCells[findIndex(cFaces, faceI)];
+    }
+}
+
+
+Foam::label Foam::cellSplitter::newNeighbour
+(
+    const label faceI,
+    const Map<labelList>& cellToCells
+) const
+{
+    label oldNbr = mesh_.faceNeighbour()[faceI];
+
+    Map<labelList>::const_iterator fnd = cellToCells.find(oldNbr);
+
+    if (fnd == cellToCells.end())
+    {
+        // Unsplit cell
+        return oldNbr;
+    }
+    else
+    {
+        // Look up index of face in the cells' faces.
+
+        const labelList& newCells = fnd();
+
+        const cell& cFaces = mesh_.cells()[oldNbr];
+
+        return newCells[findIndex(cFaces, faceI)];
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+// Construct from components
+Foam::cellSplitter::cellSplitter(const polyMesh& mesh)
+:
+    mesh_(mesh),
+    addedPoints_()
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::cellSplitter::~cellSplitter()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+void Foam::cellSplitter::setRefinement
+(
+    const Map<point>& cellToMidPoint,
+    polyTopoChange& meshMod
+)
+{
+    addedPoints_.clear();
+    addedPoints_.resize(cellToMidPoint.size());
+
+
+    //
+    // Introduce cellToMidPoints.
+    //
+
+    forAllConstIter(Map<point>, cellToMidPoint, iter)
+    {
+        label cellI = iter.key();
+
+        label anchorPoint = mesh_.cellPoints()[cellI][0];
+
+        label addedPointI =
+            meshMod.setAction
+            (
+                polyAddPoint
+                (
+                    iter(),         // point
+                    anchorPoint,    // master point
+                    -1,             // zone for point
+                    true            // supports a cell
+                )
+            );
+        addedPoints_.insert(cellI, addedPointI);
+
+        //Pout<< "Added point " << addedPointI
+        //    << iter() << " in cell " << cellI << " with centre "
+        //    << mesh_.cellCentres()[cellI] << endl;
+    }
+
+
+    //
+    // Add cells (first one is modified original cell)
+    //
+
+    Map<labelList> cellToCells(cellToMidPoint.size());
+
+    forAllConstIter(Map<point>, cellToMidPoint, iter)
+    {
+        label cellI = iter.key();
+
+        const cell& cFaces = mesh_.cells()[cellI];
+
+        // Cells created for this cell.
+        labelList newCells(cFaces.size());
+
+        // First pyramid is the original cell
+        newCells[0] = cellI;
+
+        // Add other pyramids
+        for (label i = 1; i < cFaces.size(); i++)
+        {
+            label addedCellI =
+                meshMod.setAction
+                (
+                    polyAddCell
+                    (
+                        -1,     // master point
+                        -1,     // master edge
+                        -1,     // master face
+                        cellI,  // master cell
+                        -1      // zone
+                    )
+                );
+
+            newCells[i] = addedCellI;
+        }
+
+        cellToCells.insert(cellI, newCells);
+
+        //Pout<< "Split cell " << cellI
+        //    << " with centre " << mesh_.cellCentres()[cellI] << nl
+        //    << " faces:" << cFaces << nl
+        //    << " into :" << newCells << endl;
+    }
+
+
+    //
+    // Introduce internal faces. These go from edges of the cell to the mid
+    // point.
+    //
+
+    forAllConstIter(Map<point>, cellToMidPoint, iter)
+    {
+        label cellI = iter.key();
+
+        label midPointI = addedPoints_[cellI];
+
+        const cell& cFaces = mesh_.cells()[cellI];
+
+        const labelList& cEdges = mesh_.cellEdges()[cellI];
+
+        forAll(cEdges, i)
+        {
+            label edgeI = cEdges[i];
+            const edge& e = mesh_.edges()[edgeI];
+
+            // Get the faces on the cell using the edge
+            label face0, face1;
+            meshTools::getEdgeFaces(mesh_, cellI, edgeI, face0, face1);
+
+            // Get the cells on both sides of the face by indexing into cFaces.
+            // (since newly created cells are stored in cFaces order)
+            const labelList& newCells = cellToCells[cellI];
+
+            label cell0 = newCells[findIndex(cFaces, face0)];
+            label cell1 = newCells[findIndex(cFaces, face1)];
+
+            if (cell0 < cell1)
+            {
+                // Construct face to midpoint that is pointing away from
+                // (pyramid split off from) cellI
+
+                const face& f0 = mesh_.faces()[face0];
+
+                label index = findIndex(f0, e[0]);
+
+                bool edgeInFaceOrder = (f0[f0.fcIndex(index)] == e[1]);
+
+                // Check if cellI is the face owner
+
+                face newF(3);
+                if (edgeInFaceOrder == (mesh_.faceOwner()[face0] == cellI))
+                {
+                    // edge used in face order.
+                    newF[0] = e[1];
+                    newF[1] = e[0];
+                    newF[2] = midPointI;
+                }
+                else
+                {
+                    newF[0] = e[0];
+                    newF[1] = e[1];
+                    newF[2] = midPointI;
+                }
+
+                // Now newF points away from cell0
+                meshMod.setAction
+                (
+                    polyAddFace
+                    (
+                        newF,                       // face
+                        cell0,                      // owner
+                        cell1,                      // neighbour
+                        -1,                         // master point
+                        -1,                         // master edge
+                        face0,                      // master face for addition
+                        false,                      // flux flip
+                        -1,                         // patch for face
+                        -1,                         // zone for face
+                        false                       // face zone flip
+                    )
+                );
+            }
+            else
+            {
+                // Construct face to midpoint that is pointing away from
+                // (pyramid split off from) cellI
+
+                const face& f1 = mesh_.faces()[face1];
+
+                label index = findIndex(f1, e[0]);
+
+                bool edgeInFaceOrder = (f1[f1.fcIndex(index)] == e[1]);
+
+                // Check if cellI is the face owner
+
+                face newF(3);
+                if (edgeInFaceOrder == (mesh_.faceOwner()[face1] == cellI))
+                {
+                    // edge used in face order.
+                    newF[0] = e[1];
+                    newF[1] = e[0];
+                    newF[2] = midPointI;
+                }
+                else
+                {
+                    newF[0] = e[0];
+                    newF[1] = e[1];
+                    newF[2] = midPointI;
+                }
+
+                // Now newF points away from cell1
+                meshMod.setAction
+                (
+                    polyAddFace
+                    (
+                        newF,                       // face
+                        cell1,                      // owner
+                        cell0,                      // neighbour
+                        -1,                         // master point
+                        -1,                         // master edge
+                        face0,                      // master face for addition
+                        false,                      // flux flip
+                        -1,                         // patch for face
+                        -1,                         // zone for face
+                        false                       // face zone flip
+                    )
+                );
+            }
+        }
+    }
+
+
+    //
+    // Update all existing faces for split owner or neighbour.
+    //
+
+
+    // Mark off affected face.
+    boolList faceUpToDate(mesh_.nFaces(), true);
+
+    forAllConstIter(Map<point>, cellToMidPoint, iter)
+    {
+        label cellI = iter.key();
+
+        const cell& cFaces = mesh_.cells()[cellI];
+
+        forAll(cFaces, i)
+        {
+            label faceI = cFaces[i];
+
+            faceUpToDate[faceI] = false;
+        }
+    }
+
+    forAll(faceUpToDate, faceI)
+    {
+        if (!faceUpToDate[faceI])
+        {
+            const face& f = mesh_.faces()[faceI];
+
+            if (mesh_.isInternalFace(faceI))
+            {
+                label newOwn = newOwner(faceI, cellToCells);
+                label newNbr = newNeighbour(faceI, cellToCells);
+
+                if (newOwn < newNbr)
+                {
+                    meshMod.setAction
+                    (
+                        polyModifyFace
+                        (
+                            f,
+                            faceI,
+                            newOwn,         // owner
+                            newNbr,         // neighbour
+                            false,          // flux flip
+                            -1,             // patch for face
+                            false,          // remove from zone
+                            -1,             // zone for face
+                            false           // face zone flip
+                        )
+                    );
+                }
+                else
+                {
+                    meshMod.setAction
+                    (
+                        polyModifyFace
+                        (
+                            f.reverseFace(),
+                            faceI,
+                            newNbr,         // owner
+                            newOwn,         // neighbour
+                            false,          // flux flip
+                            -1,             // patch for face
+                            false,          // remove from zone
+                            -1,             // zone for face
+                            false           // face zone flip
+                        )
+                    );
+                }
+
+            }
+            else
+            {
+                label newOwn = newOwner(faceI, cellToCells);
+
+                label patchID, zoneID, zoneFlip;
+                getFaceInfo(faceI, patchID, zoneID, zoneFlip);
+
+                meshMod.setAction
+                (
+                    polyModifyFace
+                    (
+                        mesh_.faces()[faceI],
+                        faceI,
+                        newOwn,         // owner
+                        -1,             // neighbour
+                        false,          // flux flip
+                        patchID,        // patch for face
+                        false,          // remove from zone
+                        zoneID,         // zone for face
+                        zoneFlip        // face zone flip
+                    )
+                );
+            }
+
+            faceUpToDate[faceI] = true;
+        }
+    }
+}
+
+
+void Foam::cellSplitter::updateMesh(const mapPolyMesh& morphMap)
+{
+    // Create copy since we're deleting entries. Only if both cell and added
+    // point get mapped do they get inserted.
+    Map<label> newAddedPoints(addedPoints_.size());
+
+    forAllConstIter(Map<label>, addedPoints_, iter)
+    {
+        label oldCellI = iter.key();
+
+        label newCellI = morphMap.reverseCellMap()[oldCellI];
+
+        label oldPointI = iter();
+
+        label newPointI = morphMap.reversePointMap()[oldPointI];
+
+        if (newCellI >= 0 && newPointI >= 0)
+        {
+            newAddedPoints.insert(newCellI, newPointI);
+        }
+    }
+
+    // Copy
+    addedPoints_.transfer(newAddedPoints);
+}
+
+
+// ************************************************************************* //

applications/utilities/mesh/advanced/modifyMesh/cellSplitter.H

@@ -0,0 +1,149 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011 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::cellSplitter
+
+Description
+    Does pyramidal decomposition of selected cells. So all faces will become
+    base of pyramid with as top a user-supplied point (usually the cell centre)
+
+SourceFiles
+    cellSplitter.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef cellSplitter_H
+#define cellSplitter_H
+
+#include "Map.H"
+#include "edge.H"
+#include "typeInfo.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// Forward declaration of classes
+class polyTopoChange;
+class mapPolyMesh;
+class polyMesh;
+
+
+/*---------------------------------------------------------------------------*\
+                           Class cellSplitter Declaration
+\*---------------------------------------------------------------------------*/
+
+class cellSplitter
+{
+    // Private data
+
+        //- Reference to mesh
+        const polyMesh& mesh_;
+
+        //- Per cell the mid point added.
+        Map<label> addedPoints_;
+
+
+    // Private Member Functions
+
+        //- Get patch and zone info for face
+        void getFaceInfo
+        (
+            const label faceI,
+            label& patchID,
+            label& zoneID,
+            label& zoneFlip
+        ) const;
+
+        //- Find the new owner (if any) of the face.
+        label newOwner
+        (
+            const label faceI,
+            const Map<labelList>& cellToCells
+        ) const;
+
+        //- Find the new neighbour (if any) of the face.
+        label newNeighbour
+        (
+            const label faceI,
+            const Map<labelList>& cellToCells
+        ) const;
+
+        //- Disallow default bitwise copy construct
+        cellSplitter(const cellSplitter&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const cellSplitter&);
+
+public:
+
+    //- Runtime type information
+    ClassName("cellSplitter");
+
+    // Constructors
+
+        //- Construct from mesh
+        cellSplitter(const polyMesh& mesh);
+
+
+    //- Destructor
+    ~cellSplitter();
+
+
+    // Member Functions
+
+        // Edit
+
+            //- Insert mesh changes into meshMod.
+            //  cellToMidPoint : cell to cut and position of its new midpoint
+            void setRefinement
+            (
+                const Map<point>& cellToMidPoint,
+                polyTopoChange& meshMod
+            );
+
+            //- Force recalculation of locally stored data on topological change
+            void updateMesh(const mapPolyMesh&);
+
+
+        // Access
+
+            //- Per cell the mid point added.
+            const Map<label>& addedPoints() const
+            {
+                return addedPoints_;
+            }
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

applications/utilities/mesh/advanced/modifyMesh/modifyMesh.C

@@ -0,0 +1,692 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2013 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
+    modifyMesh
+
+Description
+    Manipulates mesh elements.
+
+    Actions are:
+        (boundary)points:
+            - move
+
+        (boundary)edges:
+            - split and move introduced point
+
+        (boundary)faces:
+            - split(triangulate) and move introduced point
+
+        edges:
+            - collapse
+
+        cells:
+            - split into polygonal base pyramids around newly introduced mid
+              point
+
+    Is a bit of a loose collection of mesh change drivers.
+
+\*---------------------------------------------------------------------------*/
+
+#include "argList.H"
+#include "Time.H"
+#include "polyMesh.H"
+#include "polyTopoChange.H"
+#include "mapPolyMesh.H"
+#include "boundaryCutter.H"
+#include "cellSplitter.H"
+#include "edgeCollapser.H"
+#include "meshTools.H"
+#include "Pair.H"
+#include "globalIndex.H"
+
+using namespace Foam;
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+// Locate point on patch. Returns (mesh) point label.
+label findPoint(const primitivePatch& pp, const point& nearPoint)
+{
+    const pointField& points = pp.points();
+    const labelList& meshPoints = pp.meshPoints();
+
+    // Find nearest and next nearest
+    scalar minDistSqr = GREAT;
+    label minI = -1;
+
+    scalar almostMinDistSqr = GREAT;
+    label almostMinI = -1;
+
+    forAll(meshPoints, i)
+    {
+        label pointI = meshPoints[i];
+
+        scalar distSqr = magSqr(nearPoint - points[pointI]);
+
+        if (distSqr < minDistSqr)
+        {
+            almostMinDistSqr = minDistSqr;
+            almostMinI = minI;
+
+            minDistSqr = distSqr;
+            minI = pointI;
+        }
+        else if (distSqr < almostMinDistSqr)
+        {
+            almostMinDistSqr = distSqr;
+            almostMinI = pointI;
+        }
+    }
+
+
+    // Decide if nearPoint unique enough.
+    Info<< "Found to point " << nearPoint << nl
+        << "    nearest point      : " << minI
+        << " distance " <<  Foam::sqrt(minDistSqr)
+        << " at " << points[minI] << nl
+        << "    next nearest point : " << almostMinI
+        << " distance " <<  Foam::sqrt(almostMinDistSqr)
+        << " at " << points[almostMinI] << endl;
+
+    if (almostMinDistSqr < 4*minDistSqr)
+    {
+        Info<< "Next nearest too close to nearest. Aborting" << endl;
+
+        return -1;
+    }
+    else
+    {
+        return minI;
+    }
+}
+
+
+// Locate edge on patch. Return mesh edge label.
+label findEdge
+(
+    const primitiveMesh& mesh,
+    const primitivePatch& pp,
+    const point& nearPoint
+)
+{
+    const pointField& localPoints = pp.localPoints();
+    const pointField& points = pp.points();
+    const labelList& meshPoints = pp.meshPoints();
+    const edgeList& edges = pp.edges();
+
+    // Find nearest and next nearest
+    scalar minDist = GREAT;
+    label minI = -1;
+
+    scalar almostMinDist = GREAT;
+    label almostMinI = -1;
+
+    forAll(edges, edgeI)
+    {
+        const edge& e = edges[edgeI];
+
+        pointHit pHit(e.line(localPoints).nearestDist(nearPoint));
+
+        if (pHit.hit())
+        {
+            if (pHit.distance() < minDist)
+            {
+                almostMinDist = minDist;
+                almostMinI = minI;
+
+                minDist = pHit.distance();
+                minI = meshTools::findEdge
+                (
+                    mesh,
+                    meshPoints[e[0]],
+                    meshPoints[e[1]]
+                );
+            }
+            else if (pHit.distance() < almostMinDist)
+            {
+                almostMinDist = pHit.distance();
+                almostMinI = meshTools::findEdge
+                (
+                    mesh,
+                    meshPoints[e[0]],
+                    meshPoints[e[1]]
+                );
+            }
+        }
+    }
+
+    if (minI == -1)
+    {
+        Info<< "Did not find edge close to point " << nearPoint << endl;
+
+        return -1;
+    }
+
+
+    // Decide if nearPoint unique enough.
+    Info<< "Found to point " << nearPoint << nl
+        << "    nearest edge      : " << minI
+        << " distance " << minDist << " endpoints "
+        << mesh.edges()[minI].line(points) << nl
+        << "    next nearest edge : " << almostMinI
+        << " distance " << almostMinDist << " endpoints "
+        << mesh.edges()[almostMinI].line(points) << nl
+        << endl;
+
+    if (almostMinDist < 2*minDist)
+    {
+        Info<< "Next nearest too close to nearest. Aborting" << endl;
+
+        return -1;
+    }
+    else
+    {
+        return minI;
+    }
+}
+
+
+// Find face on patch. Return mesh face label.
+label findFace
+(
+    const primitiveMesh& mesh,
+    const primitivePatch& pp,
+    const point& nearPoint
+)
+{
+    const pointField& points = pp.points();
+
+    // Find nearest and next nearest
+    scalar minDist = GREAT;
+    label minI = -1;
+
+    scalar almostMinDist = GREAT;
+    label almostMinI = -1;
+
+    forAll(pp, patchFaceI)
+    {
+        pointHit pHit(pp[patchFaceI].nearestPoint(nearPoint, points));
+
+        if (pHit.hit())
+        {
+            if (pHit.distance() < minDist)
+            {
+                almostMinDist = minDist;
+                almostMinI = minI;
+
+                minDist = pHit.distance();
+                minI = patchFaceI + mesh.nInternalFaces();
+            }
+            else if (pHit.distance() < almostMinDist)
+            {
+                almostMinDist = pHit.distance();
+                almostMinI = patchFaceI + mesh.nInternalFaces();
+            }
+        }
+    }
+
+    if (minI == -1)
+    {
+        Info<< "Did not find face close to point " << nearPoint << endl;
+
+        return -1;
+    }
+
+
+    // Decide if nearPoint unique enough.
+    Info<< "Found to point " << nearPoint << nl
+        << "    nearest face      : " << minI
+        << " distance " << minDist
+        << " to face centre " << mesh.faceCentres()[minI] << nl
+        << "    next nearest face : " << almostMinI
+        << " distance " << almostMinDist
+        << " to face centre " << mesh.faceCentres()[almostMinI] << nl
+        << endl;
+
+    if (almostMinDist < 2*minDist)
+    {
+        Info<< "Next nearest too close to nearest. Aborting" << endl;
+
+        return -1;
+    }
+    else
+    {
+        return minI;
+    }
+}
+
+
+// Find cell with cell centre close to given point.
+label findCell(const primitiveMesh& mesh, const point& nearPoint)
+{
+    label cellI = mesh.findCell(nearPoint);
+
+    if (cellI != -1)
+    {
+        scalar distToCcSqr = magSqr(nearPoint - mesh.cellCentres()[cellI]);
+
+        const labelList& cPoints = mesh.cellPoints()[cellI];
+
+        label minI = -1;
+        scalar minDistSqr = GREAT;
+
+        forAll(cPoints, i)
+        {
+            label pointI = cPoints[i];
+
+            scalar distSqr = magSqr(nearPoint - mesh.points()[pointI]);
+
+            if (distSqr < minDistSqr)
+            {
+                minDistSqr = distSqr;
+                minI = pointI;
+            }
+        }
+
+        // Decide if nearPoint unique enough.
+        Info<< "Found to point " << nearPoint << nl
+            << "    nearest cell       : " << cellI
+            << " distance " << Foam::sqrt(distToCcSqr)
+            << " to cell centre " << mesh.cellCentres()[cellI] << nl
+            << "    nearest mesh point : " << minI
+            << " distance " << Foam::sqrt(minDistSqr)
+            << " to " << mesh.points()[minI] << nl
+            << endl;
+
+        if (minDistSqr < 4*distToCcSqr)
+        {
+            Info<< "Mesh point too close to nearest cell centre. Aborting"
+                << endl;
+
+            cellI = -1;
+        }
+    }
+
+    return cellI;
+}
+
+
+
+
+int main(int argc, char *argv[])
+{
+#   include "addOverwriteOption.H"
+
+#   include "setRootCase.H"
+#   include "createTime.H"
+    runTime.functionObjects().off();
+#   include "createPolyMesh.H"
+    const word oldInstance = mesh.pointsInstance();
+
+    const bool overwrite = args.optionFound("overwrite");
+
+    Info<< "Reading modifyMeshDict\n" << endl;
+
+    IOdictionary dict
+    (
+        IOobject
+        (
+            "modifyMeshDict",
+            runTime.system(),
+            mesh,
+            IOobject::MUST_READ_IF_MODIFIED,
+            IOobject::NO_WRITE
+        )
+    );
+
+    // Read all from the dictionary.
+    List<Pair<point> > pointsToMove(dict.lookup("pointsToMove"));
+    List<Pair<point> > edgesToSplit(dict.lookup("edgesToSplit"));
+    List<Pair<point> > facesToTriangulate
+    (
+        dict.lookup("facesToTriangulate")
+    );
+
+    bool cutBoundary =
+    (
+        pointsToMove.size()
+     || edgesToSplit.size()
+     || facesToTriangulate.size()
+    );
+
+    List<Pair<point> > edgesToCollapse(dict.lookup("edgesToCollapse"));
+
+    bool collapseEdge = edgesToCollapse.size();
+
+    List<Pair<point> > cellsToPyramidise(dict.lookup("cellsToSplit"));
+
+    bool cellsToSplit = cellsToPyramidise.size();
+
+    // List<Tuple2<pointField,point> >
+    //     cellsToCreate(dict.lookup("cellsToCreate"));
+
+    Info<< "Read from " << dict.name() << nl
+        << "  Boundary cutting module:" << nl
+        << "    points to move      :" << pointsToMove.size() << nl
+        << "    edges to split      :" << edgesToSplit.size() << nl
+        << "    faces to triangulate:" << facesToTriangulate.size() << nl
+        << "  Cell splitting module:" << nl
+        << "    cells to split      :" << cellsToPyramidise.size() << nl
+        << "  Edge collapsing module:" << nl
+        << "    edges to collapse   :" << edgesToCollapse.size() << nl
+        //<< "    cells to create     :" << cellsToCreate.size() << nl
+        << endl;
+
+    if
+    (
+        (cutBoundary && collapseEdge)
+     || (cutBoundary && cellsToSplit)
+     || (collapseEdge && cellsToSplit)
+    )
+    {
+        FatalErrorIn(args.executable())
+            << "Used more than one mesh modifying module "
+            << "(boundary cutting, cell splitting, edge collapsing)" << nl
+            << "Please do them in separate passes." << exit(FatalError);
+    }
+
+
+
+    // Get calculating engine for all of outside
+    const SubList<face> outsideFaces
+    (
+        mesh.faces(),
+        mesh.nFaces() - mesh.nInternalFaces(),
+        mesh.nInternalFaces()
+    );
+
+    primitivePatch allBoundary(outsideFaces, mesh.points());
+
+
+    // Look up mesh labels and convert to input for boundaryCutter.
+
+    bool validInputs = true;
+
+
+    Info<< nl << "Looking up points to move ..." << nl << endl;
+    Map<point> pointToPos(pointsToMove.size());
+    forAll(pointsToMove, i)
+    {
+        const Pair<point>& pts = pointsToMove[i];
+
+        label pointI = findPoint(allBoundary, pts.first());
+
+        if (pointI == -1 || !pointToPos.insert(pointI, pts.second()))
+        {
+            Info<< "Could not insert mesh point " << pointI
+                << " for input point " << pts.first() << nl
+                << "Perhaps the point is already marked for moving?" << endl;
+            validInputs = false;
+        }
+    }
+
+
+    Info<< nl << "Looking up edges to split ..." << nl << endl;
+    Map<List<point> > edgeToCuts(edgesToSplit.size());
+    forAll(edgesToSplit, i)
+    {
+        const Pair<point>& pts = edgesToSplit[i];
+
+        label edgeI = findEdge(mesh, allBoundary, pts.first());
+
+        if
+        (
+            edgeI == -1
+        || !edgeToCuts.insert(edgeI, List<point>(1, pts.second()))
+        )
+        {
+            Info<< "Could not insert mesh edge " << edgeI
+                << " for input point " << pts.first() << nl
+                << "Perhaps the edge is already marked for cutting?" << endl;
+
+            validInputs = false;
+        }
+    }
+
+
+    Info<< nl << "Looking up faces to triangulate ..." << nl << endl;
+    Map<point> faceToDecompose(facesToTriangulate.size());
+    forAll(facesToTriangulate, i)
+    {
+        const Pair<point>& pts = facesToTriangulate[i];
+
+        label faceI = findFace(mesh, allBoundary, pts.first());
+
+        if (faceI == -1 || !faceToDecompose.insert(faceI, pts.second()))
+        {
+            Info<< "Could not insert mesh face " << faceI
+                << " for input point " << pts.first() << nl
+                << "Perhaps the face is already marked for splitting?" << endl;
+
+            validInputs = false;
+        }
+    }
+
+
+
+    Info<< nl << "Looking up cells to convert to pyramids around"
+        << " cell centre ..." << nl << endl;
+    Map<point> cellToPyrCentre(cellsToPyramidise.size());
+    forAll(cellsToPyramidise, i)
+    {
+        const Pair<point>& pts = cellsToPyramidise[i];
+
+        label cellI = findCell(mesh, pts.first());
+
+        if (cellI == -1 || !cellToPyrCentre.insert(cellI, pts.second()))
+        {
+            Info<< "Could not insert mesh cell " << cellI
+                << " for input point " << pts.first() << nl
+                << "Perhaps the cell is already marked for splitting?" << endl;
+
+            validInputs = false;
+        }
+    }
+
+
+    Info<< nl << "Looking up edges to collapse ..." << nl << endl;
+    Map<point> edgeToPos(edgesToCollapse.size());
+    forAll(edgesToCollapse, i)
+    {
+        const Pair<point>& pts = edgesToCollapse[i];
+
+        label edgeI = findEdge(mesh, allBoundary, pts.first());
+
+        if (edgeI == -1 || !edgeToPos.insert(edgeI, pts.second()))
+        {
+            Info<< "Could not insert mesh edge " << edgeI
+                << " for input point " << pts.first() << nl
+                << "Perhaps the edge is already marked for collaping?" << endl;
+
+            validInputs = false;
+        }
+    }
+
+
+
+    if (!validInputs)
+    {
+        Info<< nl << "There was a problem in one of the inputs in the"
+            << " dictionary. Not modifying mesh." << endl;
+    }
+    else if (cellToPyrCentre.size())
+    {
+        Info<< nl << "All input cells located. Modifying mesh." << endl;
+
+        // Mesh change engine
+        cellSplitter cutter(mesh);
+
+        // Topo change container
+        polyTopoChange meshMod(mesh);
+
+        // Insert commands into meshMod
+        cutter.setRefinement(cellToPyrCentre, meshMod);
+
+        // Do changes
+        autoPtr<mapPolyMesh> morphMap = meshMod.changeMesh(mesh, false);
+
+        if (morphMap().hasMotionPoints())
+        {
+            mesh.movePoints(morphMap().preMotionPoints());
+        }
+
+        cutter.updateMesh(morphMap());
+
+        if (!overwrite)
+        {
+            runTime++;
+        }
+        else
+        {
+            mesh.setInstance(oldInstance);
+        }
+
+        // Write resulting mesh
+        Info<< "Writing modified mesh to time " << runTime.timeName() << endl;
+        mesh.write();
+    }
+    else if (edgeToPos.size())
+    {
+        Info<< nl << "All input edges located. Modifying mesh." << endl;
+
+        // Mesh change engine
+        edgeCollapser cutter(mesh);
+
+        const edgeList& edges = mesh.edges();
+        const pointField& points = mesh.points();
+
+        pointField newPoints(points);
+
+        PackedBoolList collapseEdge(mesh.nEdges());
+        Map<point> collapsePointToLocation(mesh.nPoints());
+
+        // Get new positions and construct collapse network
+        forAllConstIter(Map<point>, edgeToPos, iter)
+        {
+            label edgeI = iter.key();
+            const edge& e = edges[edgeI];
+
+            collapseEdge[edgeI] = true;
+            collapsePointToLocation.set(e[1], points[e[0]]);
+
+            newPoints[e[0]] = iter();
+        }
+
+        // Move master point to destination.
+        mesh.movePoints(newPoints);
+
+        List<pointEdgeCollapse> allPointInfo;
+        const globalIndex globalPoints(mesh.nPoints());
+        labelList pointPriority(mesh.nPoints(), 0);
+
+        cutter.consistentCollapse
+        (
+            globalPoints,
+            pointPriority,
+            collapsePointToLocation,
+            collapseEdge,
+            allPointInfo
+        );
+
+        // Topo change container
+        polyTopoChange meshMod(mesh);
+
+        // Insert
+        cutter.setRefinement(allPointInfo, meshMod);
+
+        // Do changes
+        autoPtr<mapPolyMesh> morphMap = meshMod.changeMesh(mesh, false);
+
+        if (morphMap().hasMotionPoints())
+        {
+            mesh.movePoints(morphMap().preMotionPoints());
+        }
+
+        // Not implemented yet:
+        //cutter.updateMesh(morphMap());
+
+
+        if (!overwrite)
+        {
+            runTime++;
+        }
+        else
+        {
+            mesh.setInstance(oldInstance);
+        }
+
+        // Write resulting mesh
+        Info<< "Writing modified mesh to time " << runTime.timeName() << endl;
+        mesh.write();
+    }
+    else
+    {
+        Info<< nl << "All input points located. Modifying mesh." << endl;
+
+        // Mesh change engine
+        boundaryCutter cutter(mesh);
+
+        // Topo change container
+        polyTopoChange meshMod(mesh);
+
+        // Insert commands into meshMod
+        cutter.setRefinement
+        (
+            pointToPos,
+            edgeToCuts,
+            Map<labelPair>(0),  // Faces to split diagonally
+            faceToDecompose,    // Faces to triangulate
+            meshMod
+        );
+
+        // Do changes
+        autoPtr<mapPolyMesh> morphMap = meshMod.changeMesh(mesh, false);
+
+        if (morphMap().hasMotionPoints())
+        {
+            mesh.movePoints(morphMap().preMotionPoints());
+        }
+
+        cutter.updateMesh(morphMap());
+
+        if (!overwrite)
+        {
+            runTime++;
+        }
+        else
+        {
+            mesh.setInstance(oldInstance);
+        }
+
+        // Write resulting mesh
+        Info<< "Writing modified mesh to time " << runTime.timeName() << endl;
+        mesh.write();
+    }
+
+
+    Info<< "\nEnd\n" << endl;
+    return 0;
+}
+
+
+// ************************************************************************* //

applications/utilities/mesh/advanced/modifyMesh/modifyMeshDict

@@ -0,0 +1,79 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  dev                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    object      modifyMeshDict;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+// Move boundary points:
+// Every entry is two coordinates. First one is location of the point to move,
+// the second is the position to move to.
+pointsToMove
+(
+    (( -0.17861 -0.45073 0.75276)( -0.18 -0.45073 0.75276))
+);
+
+// Split boundary edge in two:
+// First coord is a point on the (boundary) edge to cut, second is the
+// position of the newly introduced point
+edgesToSplit
+(
+    (( -0.17692 -0.45312 0.74516)( -0.18 -0.45 0.742))
+);
+
+// Triangulate a boundary face:
+// First coord is a point on the face to triangulate. It will introduce a
+// point on the face, triangulate and move the point to the second coordinate.
+facesToTriangulate
+(
+    (( -0.039123 -0.45045 0.74083) (-0.03844 -0.45049 0.73572))
+);
+
+// Boundary edges to collapse. First coord is point on the edge, second
+// is coordinate to collapse to.
+edgesToCollapse
+(
+    ((0.054975 0.099987 0.0044074)(0.054975 0.099987 0.0044074))
+);
+
+// Split cells:
+// First coord is a point inside the cell to split. A point inside the cell will
+// be introduced and the cell will get decomposed into polygonal base pyramids
+// with this new point as top. (so the original faces will not get split)
+cellsToSplit
+(
+    (( -0.039123 -0.45045 0.74083) (-0.03844 -0.45049 0.73572))
+);
+
+// Change patch:
+// Changes patchID of boundary faces. Coord selects the face, label is the
+// patch index.
+facesToRepatch
+(
+    (( -0.039123 -0.45045 0.74083) 1)
+);
+
+//// Create cell:
+//// Creates a cell on the boundary given a face covering a cavity. Gets
+//// the vertices of the face (outwards pointing normal) and a point internal
+//// to the new cell. (used to check the orientation of the face). Walks all
+//// boundary faces reachable from any edge on the face and constructs cell
+//// from it.
+//cellsToCreate
+//(
+//    (
+//        ((0 0 0) (1 0 0) (1 1 0) (0 1 0))   // vertices of face
+//        (0.5 0.5 0.1)                       // cell centre
+//    )
+//);
+
+// ************************************************************************* //