Add the OpenFOAM source tree

applications/utilities/mesh/generation/Allwmake

@@ -0,0 +1,18 @@
+#!/bin/sh
+cd ${0%/*} || exit 1    # run from this directory
+set -x
+
+wmake all blockMesh
+wmake all extrude
+wmake all extrude2DMesh
+wmake all snappyHexMesh
+
+if [ -n "$CGAL_ARCH_PATH" ]
+then
+    wmake libso foamyHexMesh/conformalVoronoiMesh
+    wmake all foamyHexMesh
+    wmake all foamyQuadMesh
+fi
+
+
+# ----------------------------------------------------------------- end-of-file

applications/utilities/mesh/generation/blockMesh/Make/files

@@ -0,0 +1,3 @@
+blockMeshApp.C
+
+EXE = $(FOAM_APPBIN)/blockMesh

applications/utilities/mesh/generation/blockMesh/Make/options

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

applications/utilities/mesh/generation/blockMesh/blockMeshApp.C

@@ -0,0 +1,368 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  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
+    blockMesh
+
+Description
+    A multi-block mesh generator.
+
+    Uses the block mesh description found in
+    \a constant/polyMesh/blockMeshDict
+    (or \a constant/\<region\>/polyMesh/blockMeshDict).
+
+Usage
+
+    - blockMesh [OPTION]
+
+    \param -blockTopology \n
+    Write the topology as a set of edges in OBJ format.
+
+    \param -region \<name\> \n
+    Specify an alternative mesh region.
+
+    \param -dict \<filename\> \n
+    Specify alternative dictionary for the block mesh description.
+
+\*---------------------------------------------------------------------------*/
+
+#include "Time.H"
+#include "IOdictionary.H"
+#include "IOPtrList.H"
+
+#include "blockMesh.H"
+#include "attachPolyTopoChanger.H"
+#include "emptyPolyPatch.H"
+#include "cellSet.H"
+
+#include "argList.H"
+#include "OSspecific.H"
+#include "OFstream.H"
+
+#include "Pair.H"
+#include "slidingInterface.H"
+
+using namespace Foam;
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+int main(int argc, char *argv[])
+{
+    argList::noParallel();
+    argList::addBoolOption
+    (
+        "blockTopology",
+        "write block edges and centres as .obj files"
+    );
+    argList::addOption
+    (
+        "dict",
+        "file",
+        "specify alternative dictionary for the blockMesh description"
+    );
+
+#   include "addRegionOption.H"
+#   include "setRootCase.H"
+#   include "createTime.H"
+
+    const word dictName("blockMeshDict");
+
+    word regionName;
+    fileName polyMeshDir;
+
+    if (args.optionReadIfPresent("region", regionName, polyMesh::defaultRegion))
+    {
+        // constant/<region>/polyMesh/blockMeshDict
+        polyMeshDir = regionName/polyMesh::meshSubDir;
+
+        Info<< nl << "Generating mesh for region " << regionName << endl;
+    }
+    else
+    {
+        // constant/polyMesh/blockMeshDict
+        polyMeshDir = polyMesh::meshSubDir;
+    }
+
+    IOobject meshDictIO
+    (
+        dictName,
+        runTime.constant(),
+        polyMeshDir,
+        runTime,
+        IOobject::MUST_READ,
+        IOobject::NO_WRITE,
+        false
+    );
+
+    if (args.optionFound("dict"))
+    {
+        const fileName dictPath = args["dict"];
+
+        meshDictIO = IOobject
+        (
+            (
+                isDir(dictPath)
+              ? dictPath/dictName
+              : dictPath
+            ),
+            runTime,
+            IOobject::MUST_READ,
+            IOobject::NO_WRITE,
+            false
+        );
+    }
+
+    if (!meshDictIO.headerOk())
+    {
+        FatalErrorIn(args.executable())
+            << "Cannot open mesh description file\n    "
+            << meshDictIO.objectPath()
+            << nl
+            << exit(FatalError);
+    }
+
+    Info<< "Creating block mesh from\n    "
+        << meshDictIO.objectPath() << endl;
+
+    blockMesh::verbose(true);
+
+    IOdictionary meshDict(meshDictIO);
+    blockMesh blocks(meshDict, regionName);
+
+
+    if (args.optionFound("blockTopology"))
+    {
+        // Write mesh as edges.
+        {
+            fileName objMeshFile("blockTopology.obj");
+
+            OFstream str(runTime.path()/objMeshFile);
+
+            Info<< nl << "Dumping block structure as Lightwave obj format"
+                << " to " << objMeshFile << endl;
+
+            blocks.writeTopology(str);
+        }
+
+        // Write centres of blocks
+        {
+            fileName objCcFile("blockCentres.obj");
+
+            OFstream str(runTime.path()/objCcFile);
+
+            Info<< nl << "Dumping block centres as Lightwave obj format"
+                << " to " << objCcFile << endl;
+
+            const polyMesh& topo = blocks.topology();
+
+            const pointField& cellCentres = topo.cellCentres();
+
+            forAll(cellCentres, cellI)
+            {
+                //point cc = b.blockShape().centre(b.points());
+                const point& cc = cellCentres[cellI];
+
+                str << "v " << cc.x() << ' ' << cc.y() << ' ' << cc.z() << nl;
+            }
+        }
+
+        Info<< nl << "end" << endl;
+
+        return 0;
+    }
+
+
+    Info<< nl << "Creating polyMesh from blockMesh" << endl;
+
+    word defaultFacesName = "defaultFaces";
+    word defaultFacesType = emptyPolyPatch::typeName;
+    polyMesh mesh
+    (
+        IOobject
+        (
+            regionName,
+            runTime.constant(),
+            runTime
+        ),
+        xferCopy(blocks.points()),           // could we re-use space?
+        blocks.cells(),
+        blocks.patches(),
+        blocks.patchNames(),
+        blocks.patchDicts(),
+        defaultFacesName,
+        defaultFacesType
+    );
+
+
+    // Read in a list of dictionaries for the merge patch pairs
+    if (meshDict.found("mergePatchPairs"))
+    {
+        List<Pair<word> > mergePatchPairs
+        (
+            meshDict.lookup("mergePatchPairs")
+        );
+
+#       include "mergePatchPairs.H"
+    }
+    else
+    {
+        Info<< nl << "There are no merge patch pairs edges" << endl;
+    }
+
+
+    // Set any cellZones (note: cell labelling unaffected by above
+    // mergePatchPairs)
+
+    label nZones = blocks.numZonedBlocks();
+
+    if (nZones > 0)
+    {
+        Info<< nl << "Adding cell zones" << endl;
+
+        // Map from zoneName to cellZone index
+        HashTable<label> zoneMap(nZones);
+
+        // Cells per zone.
+        List<DynamicList<label> > zoneCells(nZones);
+
+        // Running cell counter
+        label cellI = 0;
+
+        // Largest zone so far
+        label freeZoneI = 0;
+
+        forAll(blocks, blockI)
+        {
+            const block& b = blocks[blockI];
+            const labelListList& blockCells = b.cells();
+            const word& zoneName = b.blockDef().zoneName();
+
+            if (zoneName.size())
+            {
+                HashTable<label>::const_iterator iter = zoneMap.find(zoneName);
+
+                label zoneI;
+
+                if (iter == zoneMap.end())
+                {
+                    zoneI = freeZoneI++;
+
+                    Info<< "    " << zoneI << '\t' << zoneName << endl;
+
+                    zoneMap.insert(zoneName, zoneI);
+                }
+                else
+                {
+                    zoneI = iter();
+                }
+
+                forAll(blockCells, i)
+                {
+                    zoneCells[zoneI].append(cellI++);
+                }
+            }
+            else
+            {
+                cellI += b.cells().size();
+            }
+        }
+
+
+        List<cellZone*> cz(zoneMap.size());
+
+        Info<< nl << "Writing cell zones as cellSets" << endl;
+
+        forAllConstIter(HashTable<label>, zoneMap, iter)
+        {
+            label zoneI = iter();
+
+            cz[zoneI] = new cellZone
+            (
+                iter.key(),
+                zoneCells[zoneI].shrink(),
+                zoneI,
+                mesh.cellZones()
+            );
+
+            // Write as cellSet for ease of processing
+            cellSet cset(mesh, iter.key(), zoneCells[zoneI].shrink());
+            cset.write();
+        }
+
+        mesh.pointZones().setSize(0);
+        mesh.faceZones().setSize(0);
+        mesh.cellZones().setSize(0);
+        mesh.addZones(List<pointZone*>(0), List<faceZone*>(0), cz);
+    }
+
+    // Set the precision of the points data to 10
+    IOstream::defaultPrecision(max(10u, IOstream::defaultPrecision()));
+
+    Info<< nl << "Writing polyMesh" << endl;
+    mesh.removeFiles();
+    if (!mesh.write())
+    {
+        FatalErrorIn(args.executable())
+            << "Failed writing polyMesh."
+            << exit(FatalError);
+    }
+
+
+    //
+    // write some information
+    //
+    {
+        const polyPatchList& patches = mesh.boundaryMesh();
+
+        Info<< "----------------" << nl
+            << "Mesh Information" << nl
+            << "----------------" << nl
+            << "  " << "boundingBox: " << boundBox(mesh.points()) << nl
+            << "  " << "nPoints: " << mesh.nPoints() << nl
+            << "  " << "nCells: " << mesh.nCells() << nl
+            << "  " << "nFaces: " << mesh.nFaces() << nl
+            << "  " << "nInternalFaces: " << mesh.nInternalFaces() << nl;
+
+        Info<< "----------------" << nl
+            << "Patches" << nl
+            << "----------------" << nl;
+
+        forAll(patches, patchI)
+        {
+            const polyPatch& p = patches[patchI];
+
+            Info<< "  " << "patch " << patchI
+                << " (start: " << p.start()
+                << " size: " << p.size()
+                << ") name: " << p.name()
+                << nl;
+        }
+    }
+
+    Info<< "\nEnd\n" << endl;
+
+    return 0;
+}
+
+
+// ************************************************************************* //

applications/utilities/mesh/generation/blockMesh/mergePatchPairs.H

@@ -0,0 +1,119 @@
+        if (mergePatchPairs.size())
+        {
+            Info<< "Creating merge patch pairs" << nl << endl;
+
+            // Create and add point and face zones and mesh modifiers
+            List<pointZone*> pz(mergePatchPairs.size());
+            List<faceZone*> fz(3*mergePatchPairs.size());
+            List<cellZone*> cz(0);
+
+            forAll(mergePatchPairs, pairI)
+            {
+                const word mergeName
+                (
+                    mergePatchPairs[pairI].first()
+                  + mergePatchPairs[pairI].second()
+                  + name(pairI)
+                );
+
+                pz[pairI] = new pointZone
+                (
+                    mergeName + "CutPointZone",
+                    labelList(0),
+                    0,
+                    mesh.pointZones()
+                );
+
+                // Master patch
+                const word masterPatchName(mergePatchPairs[pairI].first());
+                const polyPatch& masterPatch =
+                    mesh.boundaryMesh()[masterPatchName];
+
+                labelList isf(masterPatch.size());
+
+                forAll(isf, i)
+                {
+                    isf[i] = masterPatch.start() + i;
+                }
+
+                fz[3*pairI] = new faceZone
+                (
+                    mergeName + "MasterZone",
+                    isf,
+                    boolList(masterPatch.size(), false),
+                    0,
+                    mesh.faceZones()
+                );
+
+                // Slave patch
+                const word slavePatchName(mergePatchPairs[pairI].second());
+                const polyPatch& slavePatch =
+                    mesh.boundaryMesh()[slavePatchName];
+
+                labelList osf(slavePatch.size());
+
+                forAll(osf, i)
+                {
+                    osf[i] = slavePatch.start() + i;
+                }
+
+                fz[3*pairI + 1] = new faceZone
+                (
+                    mergeName + "SlaveZone",
+                    osf,
+                    boolList(slavePatch.size(), false),
+                    1,
+                    mesh.faceZones()
+                );
+
+                // Add empty zone for cut faces
+                fz[3*pairI + 2] = new faceZone
+                (
+                    mergeName + "CutFaceZone",
+                    labelList(0),
+                    boolList(0, false),
+                    2,
+                    mesh.faceZones()
+                );
+            }  // end of all merge pairs
+
+            Info<< "Adding point and face zones" << endl;
+            mesh.addZones(pz, fz, cz);
+
+
+            Info<< "Creating attachPolyTopoChanger" << endl;
+            attachPolyTopoChanger polyMeshAttacher(mesh);
+            polyMeshAttacher.setSize(mergePatchPairs.size());
+
+            forAll(mergePatchPairs, pairI)
+            {
+                const word mergeName
+                (
+                    mergePatchPairs[pairI].first()
+                  + mergePatchPairs[pairI].second()
+                  + name(pairI)
+                );
+
+                // Add the sliding interface mesh modifier
+                polyMeshAttacher.set
+                (
+                    pairI,
+                    new slidingInterface
+                    (
+                        "couple" + name(pairI),
+                        pairI,
+                        polyMeshAttacher,
+                        mergeName + "MasterZone",
+                        mergeName + "SlaveZone",
+                        mergeName + "CutPointZone",
+                        mergeName + "CutFaceZone",
+                        mergePatchPairs[pairI].first(),
+                        mergePatchPairs[pairI].second(),
+                        slidingInterface::INTEGRAL, // always integral
+                        intersection::VISIBLE
+                    )
+                );
+            }
+
+            polyMeshAttacher.attach(true);
+        }

applications/utilities/mesh/generation/extrude/Allwclean

@@ -0,0 +1,8 @@
+#!/bin/sh
+cd ${0%/*} || exit 1    # run from this directory
+set -x
+
+wclean extrudeMesh
+wclean extrudeToRegionMesh
+
+# ----------------------------------------------------------------- end-of-file

applications/utilities/mesh/generation/extrude/Allwmake

@@ -0,0 +1,9 @@
+#!/bin/sh
+cd ${0%/*} || exit 1    # run from this directory
+set -x
+
+wmake extrudeMesh
+wmake extrudeToRegionMesh
+
+
+# ----------------------------------------------------------------- end-of-file

applications/utilities/mesh/generation/extrude/extrudeMesh/Make/files

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

applications/utilities/mesh/generation/extrude/extrudeMesh/Make/options

@@ -0,0 +1,14 @@
+EXE_INC = \
+    -IextrudedMesh \
+    -I$(LIB_SRC)/finiteVolume/lnInclude \
+    -I$(LIB_SRC)/surfMesh/lnInclude \
+    -I$(LIB_SRC)/meshTools/lnInclude \
+    -I$(LIB_SRC)/dynamicMesh/lnInclude \
+    -I$(LIB_SRC)/mesh/extrudeModel/lnInclude
+
+EXE_LIBS = \
+    -lfiniteVolume \
+    -lsurfMesh \
+    -lmeshTools \
+    -ldynamicMesh \
+    -lextrudeModel

applications/utilities/mesh/generation/extrude/extrudeMesh/createTimeExtruded.H

@@ -0,0 +1,8 @@
+    Info<< "Create time\n" << endl;
+
+    Time runTimeExtruded
+    (
+        Time::controlDictName,
+        args.rootPath(),
+        args.caseName()
+    );

applications/utilities/mesh/generation/extrude/extrudeMesh/extrudeMeshDict

@@ -0,0 +1,107 @@
+/*--------------------------------*- 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      extrudeMeshDict;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+// What to extrude:
+//      patch   : from patch of another case ('sourceCase')
+//      mesh    : as above but with original case included
+//      surface : from externally read surface
+
+//constructFrom mesh;
+constructFrom patch;
+//constructFrom surface;
+
+// If construct from patch/mesh:
+sourceCase "../cavity";
+sourcePatches (movingWall);
+// If construct from patch: patch to use for back (can be same as sourcePatch)
+exposedPatchName movingWall;
+// If construct from surface:
+surface "movingWall.stl";
+
+// Flip surface normals before usage. Valid only for extrude from surface or
+// patch.
+flipNormals false;
+
+//- Linear extrusion in point-normal direction
+//extrudeModel        linearNormal;
+
+//- Linear extrusion in specified direction
+//extrudeModel        linearDirection;
+
+//- Wedge extrusion. If nLayers is 1 assumes symmetry around plane.
+extrudeModel        wedge;
+
+//- Extrudes into sphere around (0 0 0)
+//extrudeModel        linearRadial;
+
+//- Extrudes into sphere around (0 0 0) with specified radii
+//extrudeModel        radial;
+
+//- Extrudes into sphere with grading according to pressure (atmospherics)
+//extrudeModel        sigmaRadial;
+
+nLayers             10;
+
+expansionRatio      1.0;    //0.9;
+
+wedgeCoeffs
+{
+    axisPt      (0 0.1 -0.05);
+    axis        (-1 0 0);
+    angle       360;  // For nLayers=1 assume symmetry so angle/2 on each side
+}
+
+linearNormalCoeffs
+{
+    thickness       0.05;
+}
+
+linearDirectionCoeffs
+{
+    direction       (0 1 0);
+    thickness       0.05;
+}
+
+linearRadialCoeffs
+{
+    R               0.1;
+    // Optional inner radius
+    Rsurface        0.01;
+}
+
+radialCoeffs
+{
+    // Radii specified through interpolation table
+    R               table ((0 0.01)(3 0.03)(10 0.1));
+}
+
+
+sigmaRadialCoeffs
+{
+    RTbyg           1;
+    pRef            1;
+    pStrat          1;
+}
+
+// Do front and back need to be merged? Usually only makes sense for 360
+// degree wedges.
+mergeFaces false;   //true;
+
+// Merge small edges. Fraction of bounding box.
+mergeTol 0;
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

applications/utilities/mesh/generation/extrude/extrudeMesh/extrudedMesh/extrudedMesh.C

@@ -0,0 +1,40 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  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 "extrudedMesh.H"
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+bool Foam::extrudedMesh::sameOrder(const face& f, const edge& e)
+{
+    label i = findIndex(f, e[0]);
+
+    label nextI = (i == f.size()-1 ? 0 : i+1);
+
+    return f[nextI] == e[1];
+}
+
+
+// ************************************************************************* //

applications/utilities/mesh/generation/extrude/extrudeMesh/extrudedMesh/extrudedMesh.H

@@ -0,0 +1,125 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  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/>.
+
+Class
+    Foam::extrudedMesh
+
+Description
+
+SourceFiles
+    extrudedMesh.C
+    extrudedMeshTemplates.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef extrudedMesh_H
+#define extrudedMesh_H
+
+#include "polyMesh.H"
+#include "extrudeModel.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                           Class extrudedMesh Declaration
+\*---------------------------------------------------------------------------*/
+
+class extrudedMesh
+:
+    public polyMesh
+{
+    // Private data
+
+        const extrudeModel& model_;
+
+
+    // Private Member Functions
+
+        //- Do edge and face use points in same order?
+        static bool sameOrder(const face&, const edge&);
+
+        //- Construct and return the extruded mesh points
+        template<class Face, template<class> class FaceList, class PointField>
+        Xfer<pointField> extrudedPoints
+        (
+            const PrimitivePatch<Face, FaceList, PointField>& extrudePatch,
+            const extrudeModel&
+        );
+
+        //- Construct and return the extruded mesh faces
+        template<class Face, template<class> class FaceList, class PointField>
+        Xfer<faceList> extrudedFaces
+        (
+            const PrimitivePatch<Face, FaceList, PointField>& extrudePatch,
+            const extrudeModel&
+        );
+
+        //- Construct and return the extruded mesh cells
+        template<class Face, template<class> class FaceList, class PointField>
+        Xfer<cellList> extrudedCells
+        (
+            const PrimitivePatch<Face, FaceList, PointField>& extrudePatch,
+            const extrudeModel&
+        );
+
+
+        //- Disallow default bitwise copy construct
+        extrudedMesh(const extrudedMesh&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const extrudedMesh&);
+
+
+public:
+
+    // Constructors
+
+        //- Construct from the primitivePatch to extrude
+        template<class Face, template<class> class FaceList, class PointField>
+        extrudedMesh
+        (
+            const IOobject&,
+            const PrimitivePatch<Face, FaceList, PointField>& extrudePatch,
+            const extrudeModel&
+        );
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+#   include "extrudedMeshTemplates.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

applications/utilities/mesh/generation/extrude/extrudeMesh/extrudedMesh/extrudedMeshTemplates.C

@@ -0,0 +1,373 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  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 "extrudedMesh.H"
+#include "wallPolyPatch.H"
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+template
+<
+    class Face,
+    template<class> class FaceList,
+    class PointField
+>
+Foam::Xfer<Foam::pointField> Foam::extrudedMesh::extrudedPoints
+(
+    const PrimitivePatch<Face, FaceList, PointField>& extrudePatch,
+    const extrudeModel& model
+)
+{
+    const pointField& surfacePoints = extrudePatch.localPoints();
+    const vectorField& surfaceNormals = extrudePatch.pointNormals();
+
+    const label nLayers = model.nLayers();
+
+    pointField ePoints((nLayers + 1)*surfacePoints.size());
+
+    for (label layer=0; layer<=nLayers; layer++)
+    {
+        label offset = layer*surfacePoints.size();
+
+        forAll(surfacePoints, i)
+        {
+            ePoints[offset + i] = model
+            (
+                surfacePoints[i],
+                surfaceNormals[i],
+                layer
+            );
+        }
+    }
+
+    // return points for transferring
+    return xferMove(ePoints);
+}
+
+
+template<class Face, template<class> class FaceList, class PointField>
+Foam::Xfer<Foam::faceList> Foam::extrudedMesh::extrudedFaces
+(
+    const PrimitivePatch<Face, FaceList, PointField>& extrudePatch,
+    const extrudeModel& model
+)
+{
+    const pointField& surfacePoints = extrudePatch.localPoints();
+    const List<face>& surfaceFaces = extrudePatch.localFaces();
+    const edgeList& surfaceEdges = extrudePatch.edges();
+    const label nInternalEdges = extrudePatch.nInternalEdges();
+
+    const label nLayers = model.nLayers();
+
+    label nFaces =
+        (nLayers + 1)*surfaceFaces.size() + nLayers*surfaceEdges.size();
+
+    faceList eFaces(nFaces);
+
+    labelList quad(4);
+    label facei = 0;
+
+    // Internal faces
+    for (label layer=0; layer<nLayers; layer++)
+    {
+        label currentLayerOffset = layer*surfacePoints.size();
+        label nextLayerOffset = currentLayerOffset + surfacePoints.size();
+
+        // Vertical faces from layer to layer+1
+        for (label edgeI=0; edgeI<nInternalEdges; edgeI++)
+        {
+            const edge& e = surfaceEdges[edgeI];
+            const labelList& edgeFaces = extrudePatch.edgeFaces()[edgeI];
+
+            face& f = eFaces[facei++];
+            f.setSize(4);
+
+            if
+            (
+                (edgeFaces[0] < edgeFaces[1])
+             == sameOrder(surfaceFaces[edgeFaces[0]], e)
+            )
+            {
+                f[0] = e[0] + currentLayerOffset;
+                f[1] = e[1] + currentLayerOffset;
+                f[2] = e[1] + nextLayerOffset;
+                f[3] = e[0] + nextLayerOffset;
+            }
+            else
+            {
+                f[0] = e[1] + currentLayerOffset;
+                f[1] = e[0] + currentLayerOffset;
+                f[2] = e[0] + nextLayerOffset;
+                f[3] = e[1] + nextLayerOffset;
+            }
+        }
+
+        // Faces between layer and layer+1
+        if (layer < nLayers-1)
+        {
+            forAll(surfaceFaces, i)
+            {
+                eFaces[facei++] =
+                    face
+                    (
+                        surfaceFaces[i] //.reverseFace()
+                      + nextLayerOffset
+                    );
+            }
+        }
+    }
+
+    // External side faces
+    for (label layer=0; layer<nLayers; layer++)
+    {
+        label currentLayerOffset = layer*surfacePoints.size();
+        label nextLayerOffset = currentLayerOffset + surfacePoints.size();
+
+        // Side faces across layer
+        for (label edgeI=nInternalEdges; edgeI<surfaceEdges.size(); edgeI++)
+        {
+            const edge& e = surfaceEdges[edgeI];
+            const labelList& edgeFaces = extrudePatch.edgeFaces()[edgeI];
+
+            face& f = eFaces[facei++];
+            f.setSize(4);
+
+            if (sameOrder(surfaceFaces[edgeFaces[0]], e))
+            {
+                f[0] = e[0] + currentLayerOffset;
+                f[1] = e[1] + currentLayerOffset;
+                f[2] = e[1] + nextLayerOffset;
+                f[3] = e[0] + nextLayerOffset;
+            }
+            else
+            {
+                f[0] = e[1] + currentLayerOffset;
+                f[1] = e[0] + currentLayerOffset;
+                f[2] = e[0] + nextLayerOffset;
+                f[3] = e[1] + nextLayerOffset;
+            }
+        }
+    }
+
+    // Bottom faces
+    forAll(surfaceFaces, i)
+    {
+        eFaces[facei++] = face(surfaceFaces[i]).reverseFace();
+    }
+
+    // Top faces
+    forAll(surfaceFaces, i)
+    {
+        eFaces[facei++] =
+            face
+            (
+                surfaceFaces[i]
+              + nLayers*surfacePoints.size()
+            );
+    }
+
+    // return points for transferring
+    return xferMove(eFaces);
+}
+
+
+template<class Face, template<class> class FaceList, class PointField>
+Foam::Xfer<Foam::cellList> Foam::extrudedMesh::extrudedCells
+(
+    const PrimitivePatch<Face, FaceList, PointField>& extrudePatch,
+    const extrudeModel& model
+)
+{
+    const List<face>& surfaceFaces = extrudePatch.localFaces();
+    const edgeList& surfaceEdges = extrudePatch.edges();
+    const label nInternalEdges = extrudePatch.nInternalEdges();
+
+    const label nLayers = model.nLayers();
+
+    cellList eCells(nLayers*surfaceFaces.size());
+
+    // Size the cells
+    forAll(surfaceFaces, i)
+    {
+        const face& f = surfaceFaces[i];
+
+        for (label layer=0; layer<nLayers; layer++)
+        {
+            eCells[i + layer*surfaceFaces.size()].setSize(f.size() + 2);
+        }
+    }
+
+    // Current face count per cell.
+    labelList nCellFaces(eCells.size(), 0);
+
+
+    label facei = 0;
+
+    for (label layer=0; layer<nLayers; layer++)
+    {
+        // Side faces from layer to layer+1
+        for (label i=0; i<nInternalEdges; i++)
+        {
+            // Get patch faces using edge
+            const labelList& edgeFaces = extrudePatch.edgeFaces()[i];
+
+            // Get cells on this layer
+            label cell0 = layer*surfaceFaces.size() + edgeFaces[0];
+            label cell1 = layer*surfaceFaces.size() + edgeFaces[1];
+
+            eCells[cell0][nCellFaces[cell0]++] = facei;
+            eCells[cell1][nCellFaces[cell1]++] = facei;
+
+            facei++;
+        }
+
+        // Faces between layer and layer+1
+        if (layer < nLayers-1)
+        {
+            forAll(surfaceFaces, i)
+            {
+                label cell0 = layer*surfaceFaces.size() + i;
+                label cell1 = (layer+1)*surfaceFaces.size() + i;
+
+                eCells[cell0][nCellFaces[cell0]++] = facei;
+                eCells[cell1][nCellFaces[cell1]++] = facei;
+
+                facei++;
+            }
+        }
+    }
+
+    // External side faces
+    for (label layer=0; layer<nLayers; layer++)
+    {
+        // Side faces across layer
+        for (label i=nInternalEdges; i<surfaceEdges.size(); i++)
+        {
+            // Get patch faces using edge
+            const labelList& edgeFaces = extrudePatch.edgeFaces()[i];
+
+            // Get cells on this layer
+            label cell0 = layer*surfaceFaces.size() + edgeFaces[0];
+
+            eCells[cell0][nCellFaces[cell0]++] = facei;
+
+            facei++;
+        }
+    }
+
+    // Top faces
+    forAll(surfaceFaces, i)
+    {
+        eCells[i][nCellFaces[i]++] = facei;
+
+        facei++;
+    }
+
+    // Bottom faces
+    forAll(surfaceFaces, i)
+    {
+        label cell0 = (nLayers-1)*surfaceFaces.size() + i;
+
+        eCells[cell0][nCellFaces[cell0]++] = facei;
+
+        facei++;
+    }
+
+    // return points for transferring
+    return xferMove(eCells);
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+template
+<
+    class Face,
+    template<class> class FaceList,
+    class PointField
+>
+Foam::extrudedMesh::extrudedMesh
+(
+    const IOobject& io,
+    const PrimitivePatch<Face, FaceList, PointField>& extrudePatch,
+    const extrudeModel& model
+)
+:
+    polyMesh
+    (
+        io,
+        extrudedPoints(extrudePatch, model),
+        extrudedFaces(extrudePatch, model),
+        extrudedCells(extrudePatch, model)
+    ),
+    model_(model)
+{
+    List<polyPatch*> patches(3);
+
+    label facei = nInternalFaces();
+
+    label sz =
+        model_.nLayers()
+       *(extrudePatch.nEdges() - extrudePatch.nInternalEdges());
+
+    patches[0] = new wallPolyPatch
+    (
+        "sides",
+        sz,
+        facei,
+        0,
+        boundaryMesh(),
+        wallPolyPatch::typeName
+    );
+
+    facei += sz;
+
+    patches[1] = new polyPatch
+    (
+        "originalPatch",
+        extrudePatch.size(),
+        facei,
+        1,
+        boundaryMesh(),
+        polyPatch::typeName
+    );
+
+    facei += extrudePatch.size();
+
+    patches[2] = new polyPatch
+    (
+        "otherSide",
+        extrudePatch.size(),
+        facei,
+        2,
+        boundaryMesh(),
+        polyPatch::typeName
+    );
+
+    addPatches(patches);
+}
+
+
+// ************************************************************************* //

applications/utilities/mesh/generation/extrude/extrudeToRegionMesh/Make/files

@@ -0,0 +1,3 @@
+extrudeToRegionMesh.C
+
+EXE = $(FOAM_APPBIN)/extrudeToRegionMesh

applications/utilities/mesh/generation/extrude/extrudeToRegionMesh/Make/options

@@ -0,0 +1,13 @@
+EXE_INC = \
+    -I$(LIB_SRC)/surfMesh/lnInclude \
+    -I$(LIB_SRC)/finiteVolume/lnInclude \
+    -I$(LIB_SRC)/meshTools/lnInclude \
+    -I$(LIB_SRC)/dynamicMesh/lnInclude \
+    -I$(LIB_SRC)/mesh/extrudeModel/lnInclude
+
+EXE_LIBS = \
+    -lsurfMesh \
+    -lfiniteVolume \
+    -lmeshTools \
+    -ldynamicMesh \
+    -lextrudeModel

applications/utilities/mesh/generation/extrude/extrudeToRegionMesh/extrudeToRegionMeshDict

@@ -0,0 +1,122 @@
+/*--------------------------------*- 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      extrudeToRegionMeshDict;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+// Name of region to create
+region          liquidFilm;
+
+// Specification of faces to extrude. Either faceZones (either exclusively
+// internal faces or boundary faces) or faceSets (boundary faces only).
+
+// FaceZones to extrude
+faceZones       (f0 f1);
+//faceZonesShadow (f0Shadow f1Shadow);
+
+// faceSets to extrude
+//faceSets       (f0 f1);
+//faceSetsShadow (f0Shadow f1Shadow);
+
+// Adapt the original mesh to have mapped patches at where the
+// faceZones are?
+// If true:
+// - extruding internal faces: become baffles on mapped patches
+// - extruding boundary faces: repatched to be on mapped patches
+// If false: leave original mesh intact. Extruded mesh will still have
+// mapped patch which might need to be adapted.
+adaptMesh       true;
+
+// Sample mode for inter-region communication
+sampleMode      nearestPatchFace;
+
+
+// 1 D extrusion
+// ~~~~~~~~~~~~~
+
+    // Extrude 1D-columns of cells? This by default duplicates points so can
+    // have overlapping columns (i.e. non space filling)
+    oneD            false;
+
+    //- If oneD: specify which boundary is wanted between the layers
+    //oneDPolyPatchType empty; //wedge
+
+    //- If oneD: specify whether to duplicate points (i.e. disconnect 1D
+    //  columns) or only on non-manifold extrusion areas. Default is false.
+    //  nonManifold true;
+
+
+//- Extrusion model to use. The only logical choice is linearNormal?
+
+//- Linear extrusion in normal direction
+extrudeModel    linearNormal;
+
+//- Linear extrusion in specified direction
+// extrudeModel   linearDirection;
+
+//- Wedge extrusion. If nLayers is 1 assumes symmetry around plane.
+// extrudeModel   wedge;
+
+//- Extrudes into sphere around (0 0 0)
+// extrudeModel   linearRadial;
+
+//- Extrudes into sphere around (0 0 0) with specified radii
+//extrudeModel        radial;
+
+//- Extrudes into sphere with grading according to pressure (atmospherics)
+// extrudeModel   sigmaRadial;
+
+nLayers         10;
+
+expansionRatio  0.9;
+
+linearNormalCoeffs
+{
+    thickness       0.05;
+}
+
+wedgeCoeffs
+{
+    axisPt      (0 0.1 -0.05);
+    axis        (-1 0 0);
+    angle       360;  // For nLayers=1 assume symmetry so angle/2 on each side
+}
+
+linearDirectionCoeffs
+{
+    direction       (0 1 0);
+    thickness       0.05;
+}
+
+linearRadialCoeffs
+{
+     R              0.1;
+    // Optional inner radius
+    Rsurface        0.01;
+}
+
+radialCoeffs
+{
+    // Radii specified through interpolation table
+    R               table ((0 0.01)(3 0.03)(10 0.1));
+}
+
+sigmaRadialCoeffs
+{
+    RTbyg           1;
+    pRef            1;
+    pStrat          1;
+}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

applications/utilities/mesh/generation/extrude2DMesh/Allwclean

@@ -0,0 +1,8 @@
+#!/bin/sh
+cd ${0%/*} || exit 1    # run from this directory
+set -x
+
+wclean libso extrude2DMesh
+wclean
+
+# ----------------------------------------------------------------- end-of-file

applications/utilities/mesh/generation/extrude2DMesh/Allwmake

@@ -0,0 +1,8 @@
+#!/bin/sh
+cd ${0%/*} || exit 1    # run from this directory
+set -x
+
+wmake libso extrude2DMesh
+wmake
+
+# ----------------------------------------------------------------- end-of-file

applications/utilities/mesh/generation/extrude2DMesh/Make/files

@@ -0,0 +1,3 @@
+extrude2DMeshApp.C
+
+EXE = $(FOAM_APPBIN)/extrude2DMesh

applications/utilities/mesh/generation/extrude2DMesh/Make/options

@@ -0,0 +1,12 @@
+EXE_INC = \
+    -I$(LIB_SRC)/finiteVolume/lnInclude \
+    -I$(LIB_SRC)/surfMesh/lnInclude \
+    -I$(LIB_SRC)/dynamicMesh/lnInclude \
+    -Iextrude2DMesh/lnInclude \
+    -I$(LIB_SRC)/mesh/extrudeModel/lnInclude
+
+EXE_LIBS = \
+    -lsurfMesh \
+    -ldynamicMesh \
+    -lextrude2DMesh \
+    -lextrudeModel

applications/utilities/mesh/generation/extrude2DMesh/extrude2DMesh/Make/files

@@ -0,0 +1,5 @@
+extrude2DMesh/extrude2DMesh.C
+
+patchToPoly2DMesh/patchToPoly2DMesh.C
+
+LIB = $(FOAM_LIBBIN)/libextrude2DMesh

applications/utilities/mesh/generation/extrude2DMesh/extrude2DMesh/Make/options

@@ -0,0 +1,12 @@
+EXE_INC = \
+    -I$(LIB_SRC)/meshTools/lnInclude \
+    -I$(LIB_SRC)/dynamicMesh/lnInclude \
+    -I$(LIB_SRC)/finiteVolume/lnInclude \
+    -I$(LIB_SRC)/surfMesh/lnInclude \
+    -I$(LIB_SRC)/mesh/extrudeModel/lnInclude
+
+LIB_LIBS = \
+    -lmeshTools \
+    -ldynamicMesh \
+    -lsurfMesh \
+    -lfiniteVolume

applications/utilities/mesh/generation/extrude2DMesh/extrude2DMesh/extrude2DMesh/extrude2DMesh.C

@@ -0,0 +1,586 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "extrude2DMesh.H"
+#include "polyMesh.H"
+#include "polyTopoChange.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(extrude2DMesh, 0);
+}
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+void Foam::extrude2DMesh::check2D() const
+{
+    const faceList& faces = mesh_.faces();
+    forAll(faces, faceI)
+    {
+        if (faces[faceI].size() != 2)
+        {
+            FatalErrorIn("void Foam::extrude2DMesh::check2D() const")
+                << "Face " << faceI << " size " << faces[faceI].size()
+                << " is not of size 2: mesh is not a valid two-dimensional "
+                << "mesh" << exit(FatalError);
+        }
+    }
+}
+
+
+//void Foam::extrude2DMesh::findExtrudeDirection()
+//{
+//    scalar minRange = GREAT;
+
+//    for (direction dir = 0; dir < 3; dir++)
+//    {
+//        scalarField cmpts(mesh_.points().component(dir));
+
+//        scalar range = max(cmpts)-min(cmpts);
+
+//        Info<< "Direction:" << dir << " range:" << range << endl;
+
+//        if (range < minRange)
+//        {
+//            minRange = range;
+//            extrudeDir_ = dir;
+//        }
+//    }
+
+//    Info<< "Extruding in direction " << extrudeDir_
+//        << " with thickness " << thickness_ << nl
+//        << endl;
+//}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::extrude2DMesh::extrude2DMesh
+(
+    polyMesh& mesh,
+    const dictionary& dict,
+    const extrudeModel& model
+)
+:
+    mesh_(mesh),
+    dict_(dict),
+    //patchDict_(dict.subDict("patchInfo")),
+    model_(model),
+    modelType_(dict.lookup("extrudeModel")),
+    patchType_(dict.lookup("patchType")),
+    frontPatchI_(-1),
+    backPatchI_(-1)
+{
+    check2D();
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::extrude2DMesh::~extrude2DMesh()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+void Foam::extrude2DMesh::addFrontBackPatches()
+{
+    const polyBoundaryMesh& patches = mesh_.boundaryMesh();
+
+    frontPatchI_ = patches.findPatchID("front");
+    backPatchI_ = patches.findPatchID("back");
+
+    // Add patch.
+    List<polyPatch*> newPatches(patches.size() + 2);
+
+    forAll(patches, patchI)
+    {
+        const polyPatch& pp = patches[patchI];
+
+        newPatches[patchI] =
+            pp.clone
+            (
+                patches,
+                newPatches.size(),
+                pp.size(),
+                pp.start()
+            ).ptr();
+    }
+
+    if (frontPatchI_ == -1)
+    {
+        frontPatchI_ = patches.size();
+
+        newPatches[frontPatchI_] =
+            polyPatch::New
+            (
+                patchType_,
+                "front",
+                0,
+                mesh_.nFaces(),
+                frontPatchI_,
+                patches
+            ).ptr();
+
+//        newPatches[frontPatchI_] = polyPatch::New
+//        (
+//            "front",
+//            patchDict_,
+//            frontPatchI_,
+//            patches
+//        ).ptr();
+
+        Info<< "Adding patch " << newPatches[frontPatchI_]->name()
+            << " at index " << frontPatchI_
+            << " for front faces." << nl << endl;
+    }
+
+    if (backPatchI_ == -1)
+    {
+        backPatchI_ = patches.size() + 1;
+
+        newPatches[backPatchI_] =
+            polyPatch::New
+            (
+                patchType_,
+                "back",
+                0,
+                mesh_.nFaces(),
+                backPatchI_,
+                patches
+            ).ptr();
+
+//        newPatches[frontPatchI_] = polyPatch::New
+//        (
+//            "back",
+//            patchDict_,
+//            backPatchI_,
+//            patches
+//        ).ptr();
+
+        Info<< "Adding patch " << newPatches[backPatchI_]->name()
+            << " at index " << backPatchI_
+            << " for back faces." << nl << endl;
+    }
+
+    mesh_.removeBoundary();
+    mesh_.addPatches(newPatches);
+}
+
+
+void Foam::extrude2DMesh::setRefinement
+(
+    polyTopoChange& meshMod
+)
+{
+    const label nLayers = model_.nLayers();
+    const pointField& points = mesh_.points();
+    label nFaces = 0;
+
+    for (label layer = 0; layer < nLayers; ++layer)
+    {
+        label offset = layer * mesh_.nCells();
+
+        forAll(mesh_.cells(), cellI)
+        {
+            meshMod.addCell
+            (
+                -1,     //masterPointID,
+                -1,     //masterEdgeID,
+                -1,     //masterFaceID,
+                cellI + offset,  //masterCellID,
+                mesh_.cellZones().whichZone(cellI)  //zoneID
+            );
+        }
+    }
+
+
+    // Generate points
+    // ~~~~~~~~~~~~~~~
+
+    for (label layer = 0; layer <= nLayers; ++layer)
+    {
+        label offset = layer * points.size();
+
+        forAll(points, pointI)
+        {
+            // Don't need the surface normal for either linearDirection or
+            // wedge. Will need to add to be able to use others.
+            point newPoint = model_
+            (
+                points[pointI],
+                vector(),
+                layer
+            );
+
+            meshMod.addPoint
+            (
+                newPoint,
+                pointI + offset,
+                -1,             // zoneID
+                true            // inCell
+            );
+        }
+
+        Pout<< "Added " << points.size() << " points to layer "
+            << layer << endl;
+    }
+
+
+    // Generate faces
+    // ~~~~~~~~~~~~~~
+
+    const faceList& faces = mesh_.faces();
+    const polyBoundaryMesh& patches = mesh_.boundaryMesh();
+
+    for (label layer = 0; layer < nLayers; ++layer)
+    {
+        label currentLayerOffset = layer * mesh_.nPoints();
+        label nextLayerOffset = currentLayerOffset + mesh_.nPoints();
+
+        for (label faceI = 0; faceI < mesh_.nInternalFaces(); faceI++)
+        {
+            label zoneID = mesh_.faceZones().whichZone(faceI);
+            bool zoneFlip = false;
+            if (zoneID != -1)
+            {
+                const faceZone& fZone = mesh_.faceZones()[zoneID];
+                zoneFlip = fZone.flipMap()[fZone.whichFace(faceI)];
+            }
+
+            face newFace(4);
+            const face& f = faces[faceI];
+            newFace[0] = f[0] + currentLayerOffset;
+            newFace[1] = f[1] + currentLayerOffset;
+            newFace[2] = f[1] + nextLayerOffset;
+            newFace[3] = f[0] + nextLayerOffset;
+
+//{
+//    vector n = newFace.normal(pointField(meshMod.points()));
+//    label own = mesh_.faceOwner()[faceI];
+//    const labelList& ownPoints = mesh_.cellPoints()[own];
+//    point ownCc = sum(pointField(mesh_.points(), ownPoints))/ownPoints.size();
+//    label nei = mesh_.faceNeighbour()[faceI];
+//    const labelList& neiPoints = mesh_.cellPoints()[nei];
+//    point neiCc = sum(pointField(mesh_.points(), neiPoints))/neiPoints.size();
+//    vector d = neiCc - ownCc;
+
+//    Pout<< "face:" << faceI << " at:" << f.centre(mesh_.points()) << endl
+//        << "    own:" << own << " at:" << ownCc << endl
+//        << "    nei:" << nei << " at:" << neiCc << endl
+//        << "    sign:" << (n & d) << endl
+//        << endl;
+//}
+
+            label offset = layer * mesh_.nCells();
+
+            meshMod.addFace
+            (
+                newFace,
+                mesh_.faceOwner()[faceI] + offset,       // own
+                mesh_.faceNeighbour()[faceI] + offset,   // nei
+                -1,                             // masterPointID
+                -1,                             // masterEdgeID
+                nFaces++,    // masterFaceID
+                false,                          // flipFaceFlux
+                -1,                             // patchID
+                zoneID,                         // zoneID
+                zoneFlip                        // zoneFlip
+            );
+
+            if (debug)
+            {
+                Info<< newFace << " "
+                    << mesh_.faceOwner()[faceI] + offset << " "
+                    << mesh_.faceNeighbour()[faceI] + offset << " "
+                    << nFaces - 1
+                    << endl;
+            }
+        }
+    }
+
+    forAll(patches, patchI)
+    {
+        for (label layer=0; layer < nLayers; layer++)
+        {
+            label currentLayerOffset = layer*mesh_.nPoints();
+            label nextLayerOffset = currentLayerOffset + mesh_.nPoints();
+
+            label startFaceI = patches[patchI].start();
+            label endFaceI = startFaceI + patches[patchI].size();
+
+            for (label faceI = startFaceI; faceI < endFaceI; faceI++)
+            {
+                label zoneID = mesh_.faceZones().whichZone(faceI);
+                bool zoneFlip = false;
+                if (zoneID != -1)
+                {
+                    const faceZone& fZone = mesh_.faceZones()[zoneID];
+                    zoneFlip = fZone.flipMap()[fZone.whichFace(faceI)];
+                }
+
+                face newFace(4);
+                const face& f = faces[faceI];
+                newFace[0] = f[0] + currentLayerOffset;
+                newFace[1] = f[1] + currentLayerOffset;
+                newFace[2] = f[1] + nextLayerOffset;
+                newFace[3] = f[0] + nextLayerOffset;
+
+                label offset = layer * mesh_.nCells();
+
+                meshMod.addFace
+                (
+                    newFace,
+                    mesh_.faceOwner()[faceI] + offset,       // own
+                    -1,                                      // nei
+                    -1,                                      // masterPointID
+                    -1,                                      // masterEdgeID
+                    nFaces++,                                // masterFaceID
+                    false,                                   // flipFaceFlux
+                    patchI,                                  // patchID
+                    zoneID,                                  // zoneID
+                    zoneFlip                                 // zoneFlip
+                );
+
+                if (debug)
+                {
+                    Info<< newFace << " "
+                        << mesh_.faceOwner()[faceI] + offset << " "
+                        << nFaces - 1
+                        << endl;
+                }
+            }
+        }
+    }
+
+    // Add extra internal faces that need special treatment for owners and
+    // neighbours.
+    forAll(mesh_.cells(), cellI)
+    {
+        const cell& cFaces = mesh_.cells()[cellI];
+
+        face frontFace(cFaces.size());
+
+        // Make a loop out of faces.
+        label nextFaceI = cFaces[0];
+
+        const face& f = faces[nextFaceI];
+
+        label nextPointI;
+        if (mesh_.faceOwner()[nextFaceI] == cellI)
+        {
+            frontFace[0] = f[0];
+            nextPointI = f[1];
+        }
+        else
+        {
+            frontFace[0] = f[1];
+            nextPointI = f[0];
+        }
+
+
+        for (label i = 1; i < frontFace.size(); i++)
+        {
+            frontFace[i] = nextPointI;
+
+            // Find face containing pointI
+            forAll(cFaces, cFaceI)
+            {
+                label faceI = cFaces[cFaceI];
+                if (faceI != nextFaceI)
+                {
+                    const face& f = faces[faceI];
+
+                    if (f[0] == nextPointI)
+                    {
+                        nextPointI = f[1];
+                        nextFaceI = faceI;
+                        break;
+                    }
+                    else if (f[1] == nextPointI)
+                    {
+                        nextPointI = f[0];
+                        nextFaceI = faceI;
+                        break;
+                    }
+                }
+            }
+        }
+
+        for (label layer = 0; layer < nLayers - 1; ++layer)
+        {
+            // Offset to create front face.
+            forAll(frontFace, fp)
+            {
+                frontFace[fp] += mesh_.nPoints();
+            }
+
+            label offset = layer * mesh_.nCells();
+
+            label nei = -1;
+            if (layer != nLayers - 1)
+            {
+                nei = cellI + offset + mesh_.nCells();
+            }
+
+            meshMod.addFace
+            (
+                frontFace,
+                cellI + offset,                 // own
+                nei,                            // nei
+                -1,                             // masterPointID
+                -1,                             // masterEdgeID
+                nFaces++,                       // masterFaceID
+                false,                          // flipFaceFlux
+                -1,                             // patchID
+                -1,                             // zoneID
+                false                           // zoneFlip
+            );
+
+            if (debug)
+            {
+                Info<< frontFace << " "
+                    << cellI + offset << " "
+                    << nei << " "
+                    << nFaces - 1
+                    << endl;
+            }
+        }
+    }
+
+    // Generate front and back faces
+    // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+    forAll(mesh_.cells(), cellI)
+    {
+        const cell& cFaces = mesh_.cells()[cellI];
+
+        face frontFace(cFaces.size());
+
+        // Make a loop out of faces.
+        label nextFaceI = cFaces[0];
+
+        const face& f = faces[nextFaceI];
+
+        label nextPointI;
+        if (mesh_.faceOwner()[nextFaceI] == cellI)
+        {
+            frontFace[0] = f[0];
+            nextPointI = f[1];
+        }
+        else
+        {
+            frontFace[0] = f[1];
+            nextPointI = f[0];
+        }
+
+
+        for (label i = 1; i < frontFace.size(); i++)
+        {
+            frontFace[i] = nextPointI;
+
+            // Find face containing pointI
+            forAll(cFaces, cFaceI)
+            {
+                label faceI = cFaces[cFaceI];
+                if (faceI != nextFaceI)
+                {
+                    const face& f = faces[faceI];
+
+                    if (f[0] == nextPointI)
+                    {
+                        nextPointI = f[1];
+                        nextFaceI = faceI;
+                        break;
+                    }
+                    else if (f[1] == nextPointI)
+                    {
+                        nextPointI = f[0];
+                        nextFaceI = faceI;
+                        break;
+                    }
+                }
+            }
+        }
+
+        // Add back face.
+        meshMod.addFace
+        (
+            frontFace.reverseFace(),
+            cellI,                          // own
+            -1,                             // nei
+            -1,                             // masterPointID
+            -1,                             // masterEdgeID
+            nFaces++,                       // masterFaceID
+            false,                          // flipFaceFlux
+            backPatchI_,                    // patchID
+            -1,                             // zoneID
+            false                           // zoneFlip
+        );
+
+        if (debug)
+        {
+            Info<< nl<<frontFace.reverseFace() << " "
+                << cellI << " "
+                << nFaces - 1
+                << endl;
+        }
+
+        // Offset to create front face.
+        forAll(frontFace, fp)
+        {
+            frontFace[fp] += mesh_.nPoints()* (nLayers);
+        }
+
+        label offset = (nLayers - 1) * mesh_.nCells();
+
+        meshMod.addFace
+        (
+            frontFace,
+            cellI + offset,                 // own
+            -1,                             // nei
+            -1,                             // masterPointID
+            -1,                             // masterEdgeID
+            nFaces++,                       // masterFaceID
+            false,                          // flipFaceFlux
+            frontPatchI_,                   // patchID
+            -1,                             // zoneID
+            false                           // zoneFlip
+        );
+
+        if (debug)
+        {
+            Info<< frontFace << " "
+                << cellI + offset << " "
+                << nFaces - 1
+                << endl;
+        }
+    }
+}
+
+
+// ************************************************************************* //

applications/utilities/mesh/generation/extrude2DMesh/extrude2DMesh/extrude2DMesh/extrude2DMesh.H

@@ -0,0 +1,152 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  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/>.
+
+Class
+    Foam::extrude2DMesh
+
+Description
+    Given a 2D mesh insert all the topology changes to extrude. Does not work
+    in parallel.
+
+SourceFiles
+    extrude2DMesh.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef extrude2DMesh_H
+#define extrude2DMesh_H
+
+#include "typeInfo.H"
+#include "label.H"
+#include "scalar.H"
+#include "labelList.H"
+#include "dictionary.H"
+#include "extrudeModel.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// Forward declaration of classes
+class polyMesh;
+class polyTopoChange;
+class mapPolyMesh;
+class mapDistributePolyMesh;
+class polyBoundaryMesh;
+
+/*---------------------------------------------------------------------------*\
+                           Class extrude2DMesh Declaration
+\*---------------------------------------------------------------------------*/
+
+class extrude2DMesh
+{
+    // Private data
+
+        //- Reference to 2D mesh
+        polyMesh& mesh_;
+
+        const dictionary dict_;
+
+        //const dictionary patchDict_;
+
+        const extrudeModel& model_;
+
+        const word modelType_;
+
+        const word patchType_;
+
+        label frontPatchI_;
+        label backPatchI_;
+
+    // Private Member Functions
+
+        //- Check the mesh is 2D
+        void check2D() const;
+
+        //- Find extrusion direction
+        //void findExtrudeDirection();
+
+        //- Disallow default bitwise copy construct
+        extrude2DMesh(const extrude2DMesh&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const extrude2DMesh&);
+
+public:
+
+    //- Runtime type information
+    ClassName("extrude2DMesh");
+
+
+    // Constructors
+        extrude2DMesh
+        (
+            polyMesh&,
+            const dictionary& dict,
+            const extrudeModel& model
+        );
+
+
+    //- Destructor
+    ~extrude2DMesh();
+
+
+    // Member Functions
+
+        //- Add front and back patches
+        void addFrontBackPatches();
+
+        //- Play commands into polyTopoChange to extrude mesh.
+        void setRefinement(polyTopoChange&);
+
+        //- Force recalculation of locally stored data on topological change
+        void updateMesh(const mapPolyMesh&)
+        {}
+
+        //- Force recalculation of locally stored data for mesh distribution
+        void distribute(const mapDistributePolyMesh&)
+        {}
+
+        label frontPatchI() const
+        {
+            return frontPatchI_;
+        }
+
+        label backPatchI() const
+        {
+            return backPatchI_;
+        }
+
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

applications/utilities/mesh/generation/extrude2DMesh/extrude2DMesh/patchToPoly2DMesh/patchToPoly2DMesh.C

@@ -0,0 +1,344 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "patchToPoly2DMesh.H"
+#include "PatchTools.H"
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+void Foam::patchToPoly2DMesh::flipFaceOrder()
+{
+    const edgeList& edges = patch_.edges();
+    const faceList& localFaces = patch_.localFaces();
+    const labelList& meshPoints = patch_.meshPoints();
+
+    Info<< "Flipping face order if necessary." << endl;
+    forAll(edges, edgeI)
+    {
+        const edge& e = edges[edgeI];
+
+        faces_[edgeI].setSize(2);
+
+        label edgeOwner = owner_[edgeI];
+
+        const face& f = localFaces[edgeOwner];
+
+        label fp = findIndex(f, e[0]);
+
+        if (f.nextLabel(fp) != e[1])
+        {
+            Info<< "Flipping face " << faces_[edgeI] << endl;
+            faces_[edgeI][0] = meshPoints[e[1]];
+            faces_[edgeI][1] = meshPoints[e[0]];
+        }
+        else
+        {
+            faces_[edgeI][0] = meshPoints[e[0]];
+            faces_[edgeI][1] = meshPoints[e[1]];
+        }
+    }
+}
+
+
+void Foam::patchToPoly2DMesh::createNeighbours()
+{
+    const edgeList& edges = patch_.edges();
+    const labelListList& edgeFaces = patch_.edgeFaces();
+
+    Info<< "Calculating neighbours." << endl;
+    forAll(edges, edgeI)
+    {
+        const labelList& eFaces = edgeFaces[edgeI];
+        if (eFaces.size() == 2)
+        {
+            if (owner_[edgeI] == eFaces[0])
+            {
+                neighbour_[edgeI] = eFaces[1];
+            }
+            else
+            {
+                neighbour_[edgeI] = eFaces[0];
+            }
+        }
+        else if (eFaces.size() == 1)
+        {
+            continue;
+        }
+        else
+        {
+            FatalErrorIn("polyMesh neighbour construction")
+                << abort(FatalError);
+        }
+    }
+}
+
+
+Foam::labelList Foam::patchToPoly2DMesh::internalFaceOrder()
+{
+    const labelListList& faceEdges = patch_.faceEdges();
+
+    labelList oldToNew(owner_.size(), -1);
+
+    label newFaceI = 0;
+
+    forAll(faceEdges, faceI)
+    {
+        const labelList& fEdges = faceEdges[faceI];
+        // Neighbouring faces
+        SortableList<label> nbr(fEdges.size(), -1);
+
+        forAll(fEdges, feI)
+        {
+            if (fEdges[feI] < neighbour_.size())
+            {
+                // Internal edge. Get the face on other side.
+
+                label nbrFaceI = neighbour_[fEdges[feI]];
+
+                if (nbrFaceI == faceI)
+                {
+                    nbrFaceI = owner_[fEdges[feI]];
+                }
+
+                if (faceI < nbrFaceI)
+                {
+                    // faceI is master
+                    nbr[feI] = nbrFaceI;
+                }
+            }
+        }
+
+        nbr.sort();
+
+        forAll(nbr, i)
+        {
+            if (nbr[i] != -1)
+            {
+                oldToNew[fEdges[nbr.indices()[i]]] = newFaceI++;
+            }
+        }
+    }
+
+    return oldToNew;
+}
+
+
+void Foam::patchToPoly2DMesh::addPatchFacesToFaces()
+{
+    const labelList& meshPoints = patch_.meshPoints();
+
+    label offset = patch_.nInternalEdges();
+    face f(2);
+
+    forAll(patchNames_, patchI)
+    {
+        forAllConstIter(EdgeMap<label>, mapEdgesRegion_, eIter)
+        {
+            if (eIter() == patchI)
+            {
+                f[0] = meshPoints[eIter.key().start()];
+                f[1] = meshPoints[eIter.key().end()];
+                faces_[offset++] = f;
+            }
+        }
+    }
+
+    f.clear();
+}
+
+
+void Foam::patchToPoly2DMesh::addPatchFacesToOwner()
+{
+    const label nInternalEdges = patch_.nInternalEdges();
+    const faceList& faces = patch_.faces();
+    const label nExternalEdges = patch_.edges().size() - nInternalEdges;
+    const labelList& meshPoints = patch_.meshPoints();
+
+    // Reorder patch faces on owner list.
+    labelList newOwner = owner_;
+
+    label nMatched = 0;
+
+    for
+    (
+        label bFaceI = nInternalEdges;
+        bFaceI < faces_.size();
+        ++bFaceI
+    )
+    {
+        const face& e = faces_[bFaceI];
+
+        bool matched = false;
+
+        for
+        (
+            label bEdgeI = nInternalEdges;
+            bEdgeI < faces_.size();
+            ++bEdgeI
+        )
+        {
+            if
+            (
+                e[0] == meshPoints[patch_.edges()[bEdgeI][0]]
+             && e[1] == meshPoints[patch_.edges()[bEdgeI][1]]
+            )
+            {
+                const face& f = faces[owner_[bEdgeI]];
+
+                label fp = findIndex(f, e[0]);
+
+                newOwner[bFaceI] = owner_[bEdgeI];
+
+                if (f.nextLabel(fp) != e[1])
+                {
+                    Info<< "Flipping" << endl;
+
+                    faces_[bFaceI][0] = e[1];
+                    faces_[bFaceI][1] = e[0];
+                }
+
+                nMatched++;
+
+                matched = true;
+            }
+            else if
+            (
+                e[0] == meshPoints[patch_.edges()[bEdgeI][1]]
+             && e[1] == meshPoints[patch_.edges()[bEdgeI][0]]
+            )
+            {
+                Info<< "Warning: Wrong orientation." << endl;
+                nMatched++;
+                matched = true;
+            }
+        }
+        if (!matched)
+        {
+            Info<< "No match for edge." << endl;
+        }
+    }
+
+    if (nMatched != nExternalEdges)
+    {
+        Info<< "Number of matched edges, " << nMatched
+            << ", does not match number of external edges, "
+            << nExternalEdges << endl;
+    }
+
+    owner_ = newOwner.xfer();
+}
+
+
+void Foam::patchToPoly2DMesh::createPolyMeshComponents()
+{
+    flipFaceOrder();
+
+    createNeighbours();
+
+    // New function for returning a map of old faces to new faces.
+    labelList oldToNew = internalFaceOrder();
+
+    inplaceReorder(oldToNew, faces_);
+    inplaceReorder(oldToNew, owner_);
+    inplaceReorder(oldToNew, neighbour_);
+
+    // Add patches.
+    addPatchFacesToFaces();
+
+    addPatchFacesToOwner();
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::patchToPoly2DMesh::patchToPoly2DMesh
+(
+    const MeshedSurface<face>& patch,
+    const wordList& patchNames,
+    const labelList& patchSizes,
+    const EdgeMap<label>& mapEdgesRegion
+)
+:
+    patch_(patch),
+    patchNames_(patchNames),
+    patchSizes_(patchSizes),
+    patchStarts_(patchNames.size(), 0),
+    mapEdgesRegion_(mapEdgesRegion),
+    points_(patch.points()),
+    faces_(patch.nEdges()),
+    owner_(PatchTools::edgeOwner(patch)),
+    neighbour_(patch.nInternalEdges())
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::patchToPoly2DMesh::~patchToPoly2DMesh()
+{}
+
+
+// * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
+
+void Foam::patchToPoly2DMesh::createMesh()
+{
+    for (label edgeI = 0; edgeI < patch_.nInternalEdges(); edgeI++)
+    {
+        if (patch_.edgeFaces()[edgeI].size() != 2)
+        {
+            FatalErrorIn("patchToPoly2DMesh::patchToPoly2DMesh(..)")
+                << "internal edge:" << edgeI
+                << " patch.edgeFaces()[edgeI]:" << patch_.edgeFaces()[edgeI]
+                << abort(FatalError);
+        }
+    }
+
+    for
+    (
+        label edgeI = patch_.nInternalEdges();
+        edgeI < patch_.nEdges();
+        edgeI++
+    )
+    {
+        if (patch_.edgeFaces()[edgeI].size() != 1)
+        {
+            FatalErrorIn("patchToPoly2DMesh::patchToPoly2DMesh(..)")
+                << "boundary edge:" << edgeI
+                << " patch.edgeFaces()[edgeI]:" << patch_.edgeFaces()[edgeI]
+                << abort(FatalError);
+        }
+    }
+
+    createPolyMeshComponents();
+
+    label startFace = patch_.nInternalEdges();
+    forAll(patchNames_, patchI)
+    {
+        patchStarts_[patchI] = startFace;
+        startFace += patchSizes_[patchI];
+    }
+}
+
+
+// ************************************************************************* //

applications/utilities/mesh/generation/extrude2DMesh/extrude2DMesh/patchToPoly2DMesh/patchToPoly2DMesh.H

@@ -0,0 +1,168 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+  =========                 |
+  \\      /  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/>.
+
+Class
+    Foam::patchToPoly2DMesh
+
+Description
+    Convert a primitivePatch into a 2D polyMesh.
+
+SourceFiles
+    patchToPoly2DMesh.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef patchToPoly2DMesh_H
+#define patchToPoly2DMesh_H
+
+#include "EdgeMap.H"
+#include "MeshedSurface.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                     Class patchToPoly2DMesh Declaration
+\*---------------------------------------------------------------------------*/
+
+class patchToPoly2DMesh
+{
+    // Private data
+
+        // Reference to the meshed surface
+        const MeshedSurface<face>& patch_;
+
+        const wordList& patchNames_;
+
+        const labelList& patchSizes_;
+
+        labelList patchStarts_;
+
+        const EdgeMap<label>& mapEdgesRegion_;
+
+        pointField points_;
+
+        faceList faces_;
+
+        labelList owner_;
+
+        labelList neighbour_;
+
+
+    // Private Member Functions
+
+        void flipFaceOrder();
+
+        void createNeighbours();
+
+        labelList internalFaceOrder();
+
+        void addPatchFacesToFaces();
+
+        void addPatchFacesToOwner();
+
+        void createPolyMeshComponents();
+
+        //- Disallow default bitwise copy construct
+        patchToPoly2DMesh(const patchToPoly2DMesh&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const patchToPoly2DMesh&);
+
+
+public:
+
+    // Constructors
+
+        //- Construct from a primitivePatch
+        patchToPoly2DMesh
+        (
+            const MeshedSurface<face>& patch,
+            const wordList& patchNames,
+            const labelList& patchSizes,
+            const EdgeMap<label>& mapEdgesRegion
+        );
+
+
+    //- Destructor
+    ~patchToPoly2DMesh();
+
+
+    // Member Functions
+
+        // Access
+
+            pointField& points()
+            {
+                return points_;
+            }
+
+            faceList& faces()
+            {
+                return faces_;
+            }
+
+            labelList& owner()
+            {
+                return owner_;
+            }
+
+            labelList& neighbour()
+            {
+                return neighbour_;
+            }
+
+            const wordList& patchNames() const
+            {
+                return patchNames_;
+            }
+
+            const labelList& patchSizes() const
+            {
+                return patchSizes_;
+            }
+
+            const labelList& patchStarts() const
+            {
+                return patchStarts_;
+            }
+
+
+        // Edit
+
+            //- Create the mesh
+            void createMesh();
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

applications/utilities/mesh/generation/extrude2DMesh/extrude2DMeshApp.C

@@ -0,0 +1,330 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  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
+    extrude2DMesh
+
+Description
+    Takes 2D mesh (all faces 2 points only, no front and back faces) and
+    creates a 3D mesh by extruding with specified thickness.
+
+Note
+    Not sure about the walking of the faces to create the front and back faces.
+
+\*---------------------------------------------------------------------------*/
+
+#include "argList.H"
+#include "Time.H"
+#include "polyMesh.H"
+#include "extrude2DMesh.H"
+#include "extrudeModel.H"
+#include "polyTopoChange.H"
+#include "MeshedSurface.H"
+#include "edgeCollapser.H"
+#include "addPatchCellLayer.H"
+#include "patchToPoly2DMesh.H"
+#include "globalIndex.H"
+
+using namespace Foam;
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+enum ExtrudeMode
+{
+    POLYMESH2D,
+    MESHEDSURFACE
+};
+
+namespace Foam
+{
+    template<>
+    const char* NamedEnum<ExtrudeMode, 2>::names[] =
+    {
+        "polyMesh2D",
+        "MeshedSurface"
+    };
+}
+
+static const NamedEnum<ExtrudeMode, 2> ExtrudeModeNames;
+
+
+//pointField moveInitialPoints
+//(
+//    primitiveFacePatch& fMesh,
+//    const extrudeModel& model
+//)
+//{
+//    pointField layer0Points(fMesh.nPoints());
+//    pointField layer1Points(fMesh.nPoints());
+//    pointField displacement(fMesh.nPoints());
+
+//    forAll(layer0Points, pointI)
+//    {
+//        const labelList& meshPoints = fMesh.meshPoints();
+//        label meshPointI = meshPoints[pointI];
+
+//        layer0Points[meshPointI] = model
+//        (
+//            fMesh.points()[meshPointI],
+//            fMesh.pointNormals()[pointI],
+//            0
+//        );
+
+//        layer1Points[meshPointI] = model
+//        (
+//            fMesh.points()[meshPointI],
+//            fMesh.pointNormals()[pointI],
+//            1
+//        );
+
+//        displacement[pointI] =
+//            layer1Points[meshPointI]
+//          - layer0Points[meshPointI];
+//    }
+
+//    fMesh.movePoints(layer0Points);
+
+//    return displacement;
+//}
+
+
+
+int main(int argc, char *argv[])
+{
+    argList::validArgs.append("surfaceFormat");
+
+    #include "addOverwriteOption.H"
+
+    #include "setRootCase.H"
+
+    Info<< "Create time\n" << endl;
+
+    Time runTimeExtruded
+    (
+        Time::controlDictName,
+        args.rootPath(),
+        args.caseName()
+    );
+
+    runTimeExtruded.functionObjects().off();
+
+    const ExtrudeMode surfaceFormat = ExtrudeModeNames[args[1]];
+    const bool overwrite = args.optionFound("overwrite");
+
+    Info<< "Extruding from " << ExtrudeModeNames[surfaceFormat]
+        << " at time " << runTimeExtruded.timeName() << endl;
+
+    IOdictionary extrude2DMeshDict
+    (
+        IOobject
+        (
+            "extrude2DMeshDict",
+            runTimeExtruded.system(),
+            runTimeExtruded,
+            IOobject::MUST_READ,
+            IOobject::NO_WRITE,
+            false
+        )
+    );
+
+    // Point generator
+    autoPtr<extrudeModel> model(extrudeModel::New(extrude2DMeshDict));
+
+    autoPtr<MeshedSurface<face> > fMesh;
+
+    autoPtr<polyMesh> mesh;
+
+    autoPtr<polyTopoChange> meshMod;
+
+    labelListList extrudeEdgePatches;
+
+    if (surfaceFormat == MESHEDSURFACE)
+    {
+        fMesh.set(new MeshedSurface<face>("MeshedSurface.obj"));
+
+        EdgeMap<label> edgeRegionMap;
+        wordList patchNames(1, "default");
+        labelList patchSizes(1, fMesh().nEdges() - fMesh().nInternalEdges());
+
+        const edgeList& edges = fMesh().edges();
+        forAll(edges, edgeI)
+        {
+            if (!fMesh().isInternalEdge(edgeI))
+            {
+                edgeRegionMap.insert(edges[edgeI], 0);
+            }
+        }
+
+        patchToPoly2DMesh poly2DMesh
+        (
+            fMesh(),
+            patchNames,
+            patchSizes,
+            edgeRegionMap
+        );
+
+        poly2DMesh.createMesh();
+
+        mesh.set
+        (
+            new polyMesh
+            (
+                IOobject
+                (
+                    polyMesh::defaultRegion,
+                    runTimeExtruded.constant(),
+                    runTimeExtruded,
+                    IOobject::NO_READ,
+                    IOobject::NO_WRITE,
+                    false
+                ),
+                xferMove(poly2DMesh.points()),
+                xferMove(poly2DMesh.faces()),
+                xferMove(poly2DMesh.owner()),
+                xferMove(poly2DMesh.neighbour())
+            )
+        );
+
+        Info<< "Constructing patches." << endl;
+        List<polyPatch*> patches(poly2DMesh.patchNames().size());
+
+        forAll(patches, patchI)
+        {
+            patches[patchI] = new polyPatch
+            (
+                poly2DMesh.patchNames()[patchI],
+                poly2DMesh.patchSizes()[patchI],
+                poly2DMesh.patchStarts()[patchI],
+                patchI,
+                mesh().boundaryMesh(),
+                polyPatch::typeName
+            );
+        }
+
+        mesh().addPatches(patches);
+    }
+    else if (surfaceFormat == POLYMESH2D)
+    {
+        mesh.set
+        (
+            new polyMesh
+            (
+                Foam::IOobject
+                (
+                    Foam::polyMesh::defaultRegion,
+                    runTimeExtruded.timeName(),
+                    runTimeExtruded,
+                    Foam::IOobject::MUST_READ
+                )
+            )
+        );
+    }
+
+    // Engine to extrude mesh
+    extrude2DMesh extruder(mesh(), extrude2DMeshDict, model());
+
+    extruder.addFrontBackPatches();
+
+    meshMod.set(new polyTopoChange(mesh().boundaryMesh().size()));
+
+    extruder.setRefinement(meshMod());
+
+    // Create a mesh from topo changes.
+    autoPtr<mapPolyMesh> morphMap = meshMod().changeMesh(mesh(), false);
+
+    mesh().updateMesh(morphMap);
+
+    {
+        edgeCollapser collapser(mesh());
+
+        const edgeList& edges = mesh().edges();
+        const pointField& points = mesh().points();
+
+        const boundBox& bb = mesh().bounds();
+        const scalar mergeDim = 1e-4 * bb.minDim();
+
+        PackedBoolList collapseEdge(mesh().nEdges());
+        Map<point> collapsePointToLocation(mesh().nPoints());
+
+        forAll(edges, edgeI)
+        {
+            const edge& e = edges[edgeI];
+
+            scalar d = e.mag(points);
+
+            if (d < mergeDim)
+            {
+                Info<< "Merging edge " << e << " since length " << d
+                    << " << " << mergeDim << nl;
+
+                collapseEdge[edgeI] = true;
+                collapsePointToLocation.set(e[1], points[e[0]]);
+            }
+        }
+
+        List<pointEdgeCollapse> allPointInfo;
+        const globalIndex globalPoints(mesh().nPoints());
+        labelList pointPriority(mesh().nPoints(), 0);
+
+        collapser.consistentCollapse
+        (
+            globalPoints,
+            pointPriority,
+            collapsePointToLocation,
+            collapseEdge,
+            allPointInfo
+        );
+
+        polyTopoChange meshModCollapse(mesh());
+
+        collapser.setRefinement(allPointInfo, meshModCollapse);
+
+        // Create a mesh from topo changes.
+        autoPtr<mapPolyMesh> morphMap
+            = meshModCollapse.changeMesh(mesh(), false);
+
+        mesh().updateMesh(morphMap);
+    }
+
+    if (!overwrite)
+    {
+        runTimeExtruded++;
+    }
+    else
+    {
+        mesh().setInstance("constant");
+    }
+
+    // Take over refinement levels and write to new time directory.
+    Info<< "\nWriting extruded mesh to time = " << runTimeExtruded.timeName()
+        << nl << endl;
+
+    mesh().write();
+
+    Info<< "End\n" << endl;
+
+    return 0;
+}
+
+
+// ************************************************************************* //

applications/utilities/mesh/generation/extrude2DMesh/extrude2DMeshDict

@@ -0,0 +1,46 @@
+/*--------------------------------*- 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;
+
+    root            "";
+    case            "";
+    instance        "";
+    local           "";
+
+    class           dictionary;
+    object          extrude2DMeshDict;
+}
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+extrudeModel        linearDirection;
+//extrudeModel        wedge;
+
+patchType           empty;
+//patchType           wedge;
+
+nLayers             1;
+
+expansionRatio      1.0;
+
+linearDirectionCoeffs
+{
+    direction       (0 0 1);
+    thickness       0.1;
+}
+
+wedgeCoeffs
+{
+    axisPt      (0 0 0);
+    axis        (1 0 0);
+    angle       10;
+}

applications/utilities/mesh/generation/foamyHexMesh/Allwclean

@@ -0,0 +1,10 @@
+#!/bin/sh
+cd ${0%/*} || exit 1    # run from this directory
+set -x
+
+wclean libso conformalVoronoiMesh
+wclean
+wclean foamyHexMeshSurfaceSimplify
+wclean foamyHexMeshBackgroundMesh
+
+# ----------------------------------------------------------------- end-of-file

applications/utilities/mesh/generation/foamyHexMesh/Allwmake

@@ -0,0 +1,14 @@
+#!/bin/sh
+cd ${0%/*} || exit 1    # run from this directory
+set -x
+
+if [ -n "$CGAL_ARCH_PATH" ]
+then
+    wmake libso conformalVoronoiMesh
+    wmake
+    #wmake foamyHexMeshBackgroundMesh
+    #(cd foamyHexMeshSurfaceSimplify && ./Allwmake)
+    #wmake cellSizeAndAlignmentGrid
+fi
+
+# ----------------------------------------------------------------- end-of-file

applications/utilities/mesh/generation/foamyHexMesh/Make/files

@@ -0,0 +1,3 @@
+foamyHexMesh.C
+
+EXE = $(FOAM_APPBIN)/foamyHexMesh

applications/utilities/mesh/generation/foamyHexMesh/Make/options

@@ -0,0 +1,38 @@
+EXE_DEBUG = -DFULLDEBUG -g -O0
+EXE_FROUNDING_MATH = -frounding-math
+EXE_NDEBUG = -DNDEBUG
+
+CGAL_EXACT = /*-DCGAL_DONT_USE_LAZY_KERNEL*/
+CGAL_INEXACT = -DCGAL_INEXACT
+
+include $(GENERAL_RULES)/CGAL
+
+EXE_INC = \
+    ${EXE_FROUNDING_MATH} \
+    ${EXE_NDEBUG} \
+    ${CGAL_EXACT} \
+    ${CGAL_INEXACT} \
+    ${CGAL_INC} \
+    ${c++CGALWARN} \
+    -IconformalVoronoiMesh/lnInclude \
+    -I$(LIB_SRC)/finiteVolume/lnInclude \
+    -I$(LIB_SRC)/meshTools/lnInclude \
+    -I$(LIB_SRC)/parallel/decompose/decompositionMethods/lnInclude \
+    -I$(LIB_SRC)/edgeMesh/lnInclude \
+    -I$(LIB_SRC)/fileFormats/lnInclude \
+    -I$(LIB_SRC)/dynamicMesh/lnInclude \
+    -I$(LIB_SRC)/triSurface/lnInclude \
+    -I$(LIB_SRC)/sampling/lnInclude \
+    -I$(LIB_SRC)/mesh/autoMesh/lnInclude \
+    -IvectorTools
+
+EXE_LIBS = \
+    -lconformalVoronoiMesh \
+    -lmeshTools \
+    -ldecompositionMethods \
+    -L$(FOAM_LIBBIN)/dummy -lptscotchDecomp \
+    -ledgeMesh \
+    -lfileFormats \
+    -ltriSurface \
+    -ldynamicMesh \
+    -lsampling

applications/utilities/mesh/generation/foamyHexMesh/cellSizeAndAlignmentGrid/Make/files

@@ -0,0 +1,2 @@
+cellSizeAndAlignmentGrid.C
+EXE = $(FOAM_USER_APPBIN)/cellSizeAndAlignmentGrid

applications/utilities/mesh/generation/foamyHexMesh/cellSizeAndAlignmentGrid/Make/options

@@ -0,0 +1,41 @@
+EXE_DEBUG = -DFULLDEBUG -g -O0
+EXE_FROUNDING_MATH = -frounding-math
+EXE_NDEBUG = -DNDEBUG
+
+CGAL_EXACT = /*-DCGAL_DONT_USE_LAZY_KERNEL*/
+CGAL_INEXACT = -DCGAL_INEXACT
+
+include $(GENERAL_RULES)/CGAL
+
+
+EXE_INC =  \
+    ${EXE_FROUNDING_MATH} \
+    ${EXE_NDEBUG} \
+    ${CGAL_INEXACT} \
+    ${CGAL_INC} \
+    -I$(LIB_SRC)/finiteVolume/lnInclude \
+    -I$(LIB_SRC)/dynamicMesh/lnInclude \
+    -I$(LIB_SRC)/triSurface/lnInclude \
+    -I$(LIB_SRC)/fileFormats/lnInclude \
+    -I$(LIB_SRC)/sampling/lnInclude \
+    -I$(LIB_SRC)/meshTools/lnInclude \
+    -I$(LIB_SRC)/parallel/decompose/decompositionMethods/lnInclude \
+    -I$(LIB_SRC)/edgeMesh/lnInclude \
+    -I$(LIB_SRC)/mesh/autoMesh/lnInclude \
+    -I$(FOAM_UTILITIES)/mesh/generation/foamyHexMesh/conformalVoronoiMesh/lnInclude \
+    -I$(FOAM_UTILITIES)/mesh/generation/foamyHexMesh/vectorTools
+
+EXE_LIBS =  \
+    $(CGAL_LIBS) \
+    -lmpfr \
+    -lboost_thread \
+    -lconformalVoronoiMesh \
+    -lfiniteVolume    \
+    -lmeshTools \
+    -ldecompositionMethods \
+    -L$(FOAM_LIBBIN)/dummy -lptscotchDecomp \
+    -ledgeMesh \
+    -ltriSurface \
+    -ldynamicMesh \
+    -lsampling \
+    -lfileFormats

applications/utilities/mesh/generation/foamyHexMesh/cellSizeAndAlignmentGrid/cellSizeAndAlignmentGrid.C

@@ -0,0 +1,717 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012-2014 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
+    Test-distributedDelaunayMesh
+
+Description
+
+\*---------------------------------------------------------------------------*/
+
+#include "CGALTriangulation3DKernel.H"
+
+#include "indexedVertex.H"
+#include "indexedCell.H"
+
+#include "argList.H"
+#include "Time.H"
+#include "DistributedDelaunayMesh.H"
+#include "backgroundMeshDecomposition.H"
+#include "searchableSurfaces.H"
+#include "conformationSurfaces.H"
+#include "PrintTable.H"
+#include "Random.H"
+#include "boundBox.H"
+#include "point.H"
+#include "cellShapeControlMesh.H"
+#include "triadField.H"
+#include "scalarIOField.H"
+#include "pointIOField.H"
+#include "triadIOField.H"
+
+using namespace Foam;
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+// Main program:
+
+template<class Triangulation, class Type>
+Foam::tmp<Foam::Field<Type> > filterFarPoints
+(
+    const Triangulation& mesh,
+    const Field<Type>& field
+)
+{
+    tmp<Field<Type> > tNewField(new Field<Type>(field.size()));
+    Field<Type>& newField = tNewField();
+
+    label added = 0;
+    label count = 0;
+
+    for
+    (
+        typename Triangulation::Finite_vertices_iterator vit =
+            mesh.finite_vertices_begin();
+        vit != mesh.finite_vertices_end();
+        ++vit
+    )
+    {
+        if (vit->real())
+        {
+            newField[added++] = field[count];
+        }
+
+        count++;
+    }
+
+    newField.resize(added);
+
+    return tNewField;
+}
+
+
+template<class T>
+autoPtr<mapDistribute> buildMap
+(
+    const T& mesh,
+    labelListList& pointPoints
+)
+{
+    pointPoints.setSize(mesh.vertexCount());
+
+    globalIndex globalIndexing(mesh.vertexCount());
+
+    for
+    (
+        typename T::Finite_vertices_iterator vit = mesh.finite_vertices_begin();
+        vit != mesh.finite_vertices_end();
+        ++vit
+    )
+    {
+        if (!vit->real())
+        {
+            continue;
+        }
+
+        std::list<typename T::Vertex_handle> adjVerts;
+        mesh.finite_adjacent_vertices(vit, std::back_inserter(adjVerts));
+
+        DynamicList<label> indices(adjVerts.size());
+
+        for
+        (
+            typename std::list<typename T::Vertex_handle>::const_iterator
+                adjVertI = adjVerts.begin();
+            adjVertI != adjVerts.end();
+            ++adjVertI
+        )
+        {
+            typename T::Vertex_handle vh = *adjVertI;
+
+            if (!vh->farPoint())
+            {
+                indices.append
+                (
+                    globalIndexing.toGlobal(vh->procIndex(), vh->index())
+                );
+            }
+        }
+
+        pointPoints[vit->index()].transfer(indices);
+    }
+
+    List<Map<label> > compactMap;
+
+    return autoPtr<mapDistribute>
+    (
+        new mapDistribute
+        (
+            globalIndexing,
+            pointPoints,
+            compactMap
+        )
+    );
+}
+
+
+template<class T>
+Foam::tmp<Foam::triadField> buildAlignmentField(const T& mesh)
+{
+    tmp<triadField> tAlignments
+    (
+        new triadField(mesh.vertexCount(), triad::unset)
+    );
+    triadField& alignments = tAlignments();
+
+    for
+    (
+        typename T::Finite_vertices_iterator vit = mesh.finite_vertices_begin();
+        vit != mesh.finite_vertices_end();
+        ++vit
+    )
+    {
+        if (!vit->real())
+        {
+            continue;
+        }
+
+        alignments[vit->index()] = vit->alignment();
+    }
+
+    return tAlignments;
+}
+
+
+template<class T>
+Foam::tmp<Foam::pointField> buildPointField(const T& mesh)
+{
+    tmp<pointField> tPoints
+    (
+        new pointField(mesh.vertexCount(), point(GREAT, GREAT, GREAT))
+    );
+    pointField& points = tPoints();
+
+    for
+    (
+        typename T::Finite_vertices_iterator vit = mesh.finite_vertices_begin();
+        vit != mesh.finite_vertices_end();
+        ++vit
+    )
+    {
+        if (!vit->real())
+        {
+            continue;
+        }
+
+        points[vit->index()] = topoint(vit->point());
+    }
+
+    return tPoints;
+}
+
+
+void refine
+(
+    cellShapeControlMesh& mesh,
+    const conformationSurfaces& geometryToConformTo,
+    const label maxRefinementIterations,
+    const scalar defaultCellSize
+)
+{
+    for (label iter = 0; iter < maxRefinementIterations; ++iter)
+    {
+        DynamicList<point> ptsToInsert;
+
+        for
+        (
+            CellSizeDelaunay::Finite_cells_iterator cit =
+                mesh.finite_cells_begin();
+            cit != mesh.finite_cells_end();
+            ++cit
+        )
+        {
+            const point newPoint =
+                topoint
+                (
+                    CGAL::centroid
+                    (
+                        cit->vertex(0)->point(),
+                        cit->vertex(1)->point(),
+                        cit->vertex(2)->point(),
+                        cit->vertex(3)->point()
+                    )
+                );
+
+            if (geometryToConformTo.inside(newPoint))
+            {
+                ptsToInsert.append(newPoint);
+            }
+        }
+
+        Info<< "    Adding " << returnReduce(ptsToInsert.size(), sumOp<label>())
+            << endl;
+
+        forAll(ptsToInsert, ptI)
+        {
+            mesh.insert
+            (
+                ptsToInsert[ptI],
+                defaultCellSize,
+                triad::unset,
+                Vb::vtInternal
+            );
+        }
+    }
+}
+
+
+int main(int argc, char *argv[])
+{
+    #include "setRootCase.H"
+    #include "createTime.H"
+
+    // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+    label maxRefinementIterations = 2;
+    label maxSmoothingIterations = 200;
+    scalar minResidual = 0;
+    scalar defaultCellSize = 0.001;
+    scalar nearFeatDistSqrCoeff = 1e-8;
+
+
+    // Need to decouple vertex and cell type from this class?
+    // Vertex must have:
+    // + index
+    // + procIndex
+    // - type should be optional
+    cellShapeControlMesh mesh(runTime);
+
+    IOdictionary foamyHexMeshDict
+    (
+        IOobject
+        (
+            "foamyHexMeshDict",
+            runTime.system(),
+            runTime,
+            IOobject::MUST_READ,
+            IOobject::NO_WRITE
+        )
+    );
+
+    Random rndGen(64293*Pstream::myProcNo());
+
+    searchableSurfaces allGeometry
+    (
+        IOobject
+        (
+            "cvSearchableSurfaces",
+            runTime.constant(),
+            "triSurface",
+            runTime,
+            IOobject::MUST_READ,
+            IOobject::NO_WRITE
+        ),
+        foamyHexMeshDict.subDict("geometry"),
+        foamyHexMeshDict.lookupOrDefault("singleRegionName", true)
+    );
+
+    conformationSurfaces geometryToConformTo
+    (
+        runTime,
+        rndGen,
+        allGeometry,
+        foamyHexMeshDict.subDict("surfaceConformation")
+    );
+
+    autoPtr<backgroundMeshDecomposition> bMesh;
+    if (Pstream::parRun())
+    {
+        bMesh.set
+        (
+            new backgroundMeshDecomposition
+            (
+                runTime,
+                rndGen,
+                geometryToConformTo,
+                foamyHexMeshDict.subDict("backgroundMeshDecomposition")
+            )
+        );
+    }
+
+    // Nice to have IO for the delaunay mesh
+    // IO depend on vertex type.
+    //
+    // Define a delaunay mesh as:
+    // + list of points of the triangulation
+    // + optionally a list of cells
+
+    Info<< nl << "Loop over surfaces" << endl;
+
+    forAll(geometryToConformTo.surfaces(), sI)
+    {
+        const label surfI = geometryToConformTo.surfaces()[sI];
+
+        const searchableSurface& surface =
+            geometryToConformTo.geometry()[surfI];
+
+        Info<< nl << "Inserting points from surface " << surface.name()
+            << " (" << surface.type() << ")" << endl;
+
+        const tmp<pointField> tpoints(surface.points());
+        const pointField& points = tpoints();
+
+        Info<< "    Number of points = " << points.size() << endl;
+
+        forAll(points, pI)
+        {
+            // Is the point in the extendedFeatureEdgeMesh? If so get the
+            // point normal, otherwise get the surface normal from
+            // searchableSurface
+
+            pointIndexHit info;
+            label infoFeature;
+            geometryToConformTo.findFeaturePointNearest
+            (
+                points[pI],
+                nearFeatDistSqrCoeff,
+                info,
+                infoFeature
+            );
+
+
+            autoPtr<triad> pointAlignment;
+
+            if (info.hit())
+            {
+                const extendedFeatureEdgeMesh& features =
+                    geometryToConformTo.features()[infoFeature];
+
+                vectorField norms = features.featurePointNormals(info.index());
+
+                // Create a triad from these norms.
+                pointAlignment.set(new triad());
+                forAll(norms, nI)
+                {
+                    pointAlignment() += norms[nI];
+                }
+
+                pointAlignment().normalize();
+                pointAlignment().orthogonalize();
+            }
+            else
+            {
+                geometryToConformTo.findEdgeNearest
+                (
+                    points[pI],
+                    nearFeatDistSqrCoeff,
+                    info,
+                    infoFeature
+                );
+
+                if (info.hit())
+                {
+                    const extendedFeatureEdgeMesh& features =
+                        geometryToConformTo.features()[infoFeature];
+
+                    vectorField norms = features.edgeNormals(info.index());
+
+                    // Create a triad from these norms.
+                    pointAlignment.set(new triad());
+                    forAll(norms, nI)
+                    {
+                        pointAlignment() += norms[nI];
+                    }
+
+                    pointAlignment().normalize();
+                    pointAlignment().orthogonalize();
+                }
+                else
+                {
+                    pointField ptField(1, points[pI]);
+                    scalarField distField(1, nearFeatDistSqrCoeff);
+                    List<pointIndexHit> infoList(1, pointIndexHit());
+
+                    surface.findNearest(ptField, distField, infoList);
+
+                    vectorField normals(1);
+                    surface.getNormal(infoList, normals);
+
+                    pointAlignment.set(new triad(normals[0]));
+                }
+            }
+
+            if (Pstream::parRun())
+            {
+                if (bMesh().positionOnThisProcessor(points[pI]))
+                {
+                    CellSizeDelaunay::Vertex_handle vh = mesh.insert
+                    (
+                        points[pI],
+                        defaultCellSize,
+                        pointAlignment(),
+                        Vb::vtInternalNearBoundary
+                    );
+                }
+            }
+            else
+            {
+                CellSizeDelaunay::Vertex_handle vh = mesh.insert
+                (
+                    points[pI],
+                    defaultCellSize,
+                    pointAlignment(),
+                    Vb::vtInternalNearBoundary
+                );
+            }
+        }
+    }
+
+
+    // Refine the mesh
+    refine
+    (
+        mesh,
+        geometryToConformTo,
+        maxRefinementIterations,
+        defaultCellSize
+    );
+
+
+    if (Pstream::parRun())
+    {
+        mesh.distribute(bMesh);
+    }
+
+
+    labelListList pointPoints;
+    autoPtr<mapDistribute> meshDistributor = buildMap(mesh, pointPoints);
+
+
+    triadField alignments(buildAlignmentField(mesh));
+    pointField points(buildPointField(mesh));
+
+    mesh.printInfo(Info);
+
+
+    // Setup the sizes and alignments on each point
+    triadField fixedAlignments(mesh.vertexCount(), triad::unset);
+
+    for
+    (
+        CellSizeDelaunay::Finite_vertices_iterator vit =
+            mesh.finite_vertices_begin();
+        vit != mesh.finite_vertices_end();
+        ++vit
+    )
+    {
+        if (vit->nearBoundary())
+        {
+            fixedAlignments[vit->index()] = vit->alignment();
+        }
+    }
+
+    Info<< nl << "Smoothing alignments" << endl;
+
+    for (label iter = 0; iter < maxSmoothingIterations; iter++)
+    {
+        Info<< "Iteration " << iter;
+
+        meshDistributor().distribute(points);
+        meshDistributor().distribute(alignments);
+
+        scalar residual = 0;
+
+        triadField triadAv(alignments.size(), triad::unset);
+
+        forAll(pointPoints, pI)
+        {
+            const labelList& pPoints = pointPoints[pI];
+
+            if (pPoints.empty())
+            {
+                continue;
+            }
+
+            const triad& oldTriad = alignments[pI];
+            triad& newTriad = triadAv[pI];
+
+            // Enforce the boundary conditions
+            const triad& fixedAlignment = fixedAlignments[pI];
+
+            forAll(pPoints, adjPointI)
+            {
+                const label adjPointIndex = pPoints[adjPointI];
+
+                scalar dist = mag(points[pI] - points[adjPointIndex]);
+
+//                dist = max(dist, SMALL);
+
+                triad tmpTriad = alignments[adjPointIndex];
+
+                for (direction dir = 0; dir < 3; dir++)
+                {
+                    if (tmpTriad.set(dir))
+                    {
+                        tmpTriad[dir] *= (1.0/dist);
+                    }
+                }
+
+                newTriad += tmpTriad;
+            }
+
+            newTriad.normalize();
+            newTriad.orthogonalize();
+//            newTriad = newTriad.sortxyz();
+
+            label nFixed = 0;
+
+            forAll(fixedAlignment, dirI)
+            {
+                if (fixedAlignment.set(dirI))
+                {
+                    nFixed++;
+                }
+            }
+
+            if (nFixed == 1)
+            {
+                forAll(fixedAlignment, dirI)
+                {
+                    if (fixedAlignment.set(dirI))
+                    {
+                        newTriad.align(fixedAlignment[dirI]);
+                    }
+                }
+            }
+            else if (nFixed == 2)
+            {
+                forAll(fixedAlignment, dirI)
+                {
+                    if (fixedAlignment.set(dirI))
+                    {
+                        newTriad[dirI] = fixedAlignment[dirI];
+                    }
+                    else
+                    {
+                        newTriad[dirI] = triad::unset[dirI];
+                    }
+                }
+
+                newTriad.orthogonalize();
+            }
+            else if (nFixed == 3)
+            {
+                forAll(fixedAlignment, dirI)
+                {
+                    if (fixedAlignment.set(dirI))
+                    {
+                        newTriad[dirI] = fixedAlignment[dirI];
+                    }
+                }
+            }
+
+            for (direction dir = 0; dir < 3; ++dir)
+            {
+                if
+                (
+                    newTriad.set(dir)
+                 && oldTriad.set(dir)
+                 //&& !fixedAlignment.set(dir)
+                )
+                {
+                    scalar dotProd = (oldTriad[dir] & newTriad[dir]);
+                    scalar diff = mag(dotProd) - 1.0;
+
+                    residual += mag(diff);
+                }
+            }
+        }
+
+        forAll(alignments, pI)
+        {
+            alignments[pI] = triadAv[pI].sortxyz();
+        }
+
+        reduce(residual, sumOp<scalar>());
+
+        Info<< ", Residual = " << residual << endl;
+
+        if (residual <= minResidual)
+        {
+            break;
+        }
+    }
+
+
+    // Write alignments to a .obj file
+    OFstream str(runTime.path()/"alignments.obj");
+
+    forAll(alignments, pI)
+    {
+        const triad& tri = alignments[pI];
+
+        if (tri.set())
+        {
+            forAll(tri, dirI)
+            {
+                meshTools::writeOBJ(str, points[pI], tri[dirI] + points[pI]);
+            }
+        }
+    }
+
+
+    // Remove the far points
+    pointIOField pointsIO
+    (
+        IOobject
+        (
+            "points",
+            runTime.constant(),
+            runTime,
+            IOobject::NO_READ,
+            IOobject::AUTO_WRITE
+        ),
+        filterFarPoints(mesh, points)
+    );
+
+    scalarField sizes(points.size(), defaultCellSize);
+    scalarIOField sizesIO
+    (
+        IOobject
+        (
+            "sizes",
+            runTime.constant(),
+            runTime,
+            IOobject::NO_READ,
+            IOobject::AUTO_WRITE
+        ),
+        filterFarPoints(mesh, sizes)
+    );
+
+    triadIOField alignmentsIO
+    (
+        IOobject
+        (
+            "alignments",
+            runTime.constant(),
+            runTime,
+            IOobject::NO_READ,
+            IOobject::AUTO_WRITE
+        ),
+        filterFarPoints(mesh, alignments)
+    );
+
+    pointsIO.write();
+    sizesIO.write();
+    alignmentsIO.write();
+
+    Info<< nl << "ExecutionTime = " << runTime.elapsedCpuTime() << " s"
+        << "  ClockTime = " << runTime.elapsedClockTime() << " s"
+        << nl << endl;
+
+    Info<< "\nEnd\n" << endl;
+
+    return 0;
+}
+
+
+// ************************************************************************* //

applications/utilities/mesh/generation/foamyHexMesh/conformalVoronoiMesh/DelaunayMesh/DelaunayMesh.C

@@ -0,0 +1,366 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012-2014 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 "DelaunayMesh.H"
+#include "labelPair.H"
+#include "PrintTable.H"
+#include "pointIOField.H"
+#include "scalarIOField.H"
+#include "labelIOField.H"
+#include "pointConversion.H"
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+template<class Triangulation>
+Foam::DelaunayMesh<Triangulation>::DelaunayMesh(const Time& runTime)
+:
+    Triangulation(),
+    vertexCount_(0),
+    cellCount_(0),
+    runTime_(runTime)
+{}
+
+
+template<class Triangulation>
+Foam::DelaunayMesh<Triangulation>::DelaunayMesh
+(
+    const Time& runTime,
+    const word& meshName
+)
+:
+    Triangulation(),
+    vertexCount_(0),
+    cellCount_(0),
+    runTime_(runTime)
+{
+    Info<< "Reading " << meshName << " from " << runTime.timeName() << endl;
+
+    pointIOField pts
+    (
+        IOobject
+        (
+            "points",
+            runTime.timeName(),
+            meshName/polyMesh::meshSubDir,
+            runTime,
+            IOobject::READ_IF_PRESENT,
+            IOobject::NO_WRITE
+        )
+    );
+
+    if (pts.headerOk())
+    {
+        labelIOField types
+        (
+            IOobject
+            (
+                "types",
+                runTime.timeName(),
+                meshName,
+                runTime,
+                IOobject::MUST_READ,
+                IOobject::NO_WRITE
+            )
+        );
+
+// Do not read in indices
+//        labelIOField indices
+//        (
+//            IOobject
+//            (
+//                "indices",
+//                runTime.timeName(),
+//                meshName,
+//                runTime,
+//                IOobject::MUST_READ,
+//                IOobject::NO_WRITE
+//            )
+//        );
+
+        labelIOField processorIndices
+        (
+            IOobject
+            (
+                "processorIndices",
+                runTime.timeName(),
+                meshName,
+                runTime,
+                IOobject::MUST_READ,
+                IOobject::NO_WRITE
+            )
+        );
+
+        List<Vb> pointsToInsert(pts.size());
+
+        forAll(pointsToInsert, pI)
+        {
+            pointsToInsert[pI] =
+                Vb
+                (
+                    toPoint(pts[pI]),
+                    pI,
+                    static_cast<indexedVertexEnum::vertexType>(types[pI]),
+                    processorIndices[pI]
+                );
+        }
+
+        rangeInsertWithInfo
+        (
+            pointsToInsert.begin(),
+            pointsToInsert.end(),
+            false,
+            false
+        );
+
+        vertexCount_ = Triangulation::number_of_vertices();
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+template<class Triangulation>
+Foam::DelaunayMesh<Triangulation>::~DelaunayMesh()
+{}
+
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
+
+template<class Triangulation>
+void Foam::DelaunayMesh<Triangulation>::reset()
+{
+    Info<< "Clearing triangulation" << endl;
+
+    DynamicList<Vb> vertices;
+
+    for
+    (
+        Finite_vertices_iterator vit = Triangulation::finite_vertices_begin();
+        vit != Triangulation::finite_vertices_end();
+        ++vit
+    )
+    {
+        if (vit->fixed())
+        {
+            vertices.append
+            (
+                Vb
+                (
+                    vit->point(),
+                    vit->index(),
+                    vit->type(),
+                    vit->procIndex()
+                )
+            );
+
+            vertices.last().fixed() = vit->fixed();
+        }
+    }
+
+    this->clear();
+
+    resetVertexCount();
+    resetCellCount();
+
+    insertPoints(vertices, false);
+
+    Info<< "Inserted " << vertexCount() << " fixed points" << endl;
+}
+
+
+template<class Triangulation>
+Foam::Map<Foam::label> Foam::DelaunayMesh<Triangulation>::insertPoints
+(
+    const List<Vb>& vertices,
+    const bool reIndex
+)
+{
+    return rangeInsertWithInfo
+    (
+        vertices.begin(),
+        vertices.end(),
+        false,
+        reIndex
+    );
+}
+
+
+template<class Triangulation>
+bool Foam::DelaunayMesh<Triangulation>::Traits_for_spatial_sort::Less_x_3::
+operator()
+(
+    const Point_3& p,
+    const Point_3& q
+) const
+{
+    return typename Gt::Less_x_3()(*(p.first), *(q.first));
+}
+
+template<class Triangulation>
+bool Foam::DelaunayMesh<Triangulation>::Traits_for_spatial_sort::Less_y_3::
+operator()
+(
+    const Point_3& p,
+    const Point_3& q
+) const
+{
+    return typename Gt::Less_y_3()(*(p.first), *(q.first));
+}
+
+template<class Triangulation>
+bool Foam::DelaunayMesh<Triangulation>::Traits_for_spatial_sort::Less_z_3::
+operator()
+(
+    const Point_3& p,
+    const Point_3& q
+) const
+{
+    return typename Gt::Less_z_3()(*(p.first), *(q.first));
+}
+
+template<class Triangulation>
+typename Foam::DelaunayMesh<Triangulation>::Traits_for_spatial_sort::Less_x_3
+Foam::DelaunayMesh<Triangulation>::Traits_for_spatial_sort::less_x_3_object()
+const
+{
+    return Less_x_3();
+}
+
+template<class Triangulation>
+typename Foam::DelaunayMesh<Triangulation>::Traits_for_spatial_sort::Less_y_3
+Foam::DelaunayMesh<Triangulation>::Traits_for_spatial_sort::less_y_3_object()
+const
+{
+    return Less_y_3();
+}
+
+template<class Triangulation>
+typename Foam::DelaunayMesh<Triangulation>::Traits_for_spatial_sort::Less_z_3
+Foam::DelaunayMesh<Triangulation>::Traits_for_spatial_sort::less_z_3_object()
+const
+{
+    return Less_z_3();
+}
+
+
+template<class Triangulation>
+template<class PointIterator>
+Foam::Map<Foam::label> Foam::DelaunayMesh<Triangulation>::rangeInsertWithInfo
+(
+    PointIterator begin,
+    PointIterator end,
+    bool printErrors,
+    bool reIndex
+)
+{
+    typedef DynamicList
+    <
+        std::pair
+        <
+            const typename Triangulation::Point*,
+            label
+        >
+    > vectorPairPointIndex;
+
+    vectorPairPointIndex points;
+
+    label count = 0;
+    for (PointIterator it = begin; it != end; ++it)
+    {
+        points.append
+        (
+            std::make_pair(&(it->point()), count++)
+        );
+    }
+
+    std::random_shuffle(points.begin(), points.end());
+
+    spatial_sort
+    (
+        points.begin(),
+        points.end(),
+        Traits_for_spatial_sort()
+    );
+
+    Vertex_handle hint;
+
+    Map<label> oldToNewIndex(points.size());
+
+    for
+    (
+        typename vectorPairPointIndex::const_iterator p = points.begin();
+        p != points.end();
+        ++p
+    )
+    {
+        const size_t checkInsertion = Triangulation::number_of_vertices();
+
+        hint = this->insert(*(p->first), hint);
+
+        const Vb& vert = *(begin + p->second);
+
+        if (checkInsertion != Triangulation::number_of_vertices() - 1)
+        {
+            if (printErrors)
+            {
+                Vertex_handle nearV =
+                    Triangulation::nearest_vertex(*(p->first));
+
+                Pout<< "Failed insertion : " << vert.info()
+                    << "         nearest : " << nearV->info();
+            }
+        }
+        else
+        {
+            const label oldIndex = vert.index();
+            hint->index() = getNewVertexIndex();
+
+            if (reIndex)
+            {
+                oldToNewIndex.insert(oldIndex, hint->index());
+            }
+
+            hint->type() = vert.type();
+            hint->procIndex() = vert.procIndex();
+            hint->targetCellSize() = vert.targetCellSize();
+            hint->alignment() = vert.alignment();
+        }
+    }
+
+    return oldToNewIndex;
+}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#include "DelaunayMeshIO.C"
+
+// ************************************************************************* //

applications/utilities/mesh/generation/foamyHexMesh/conformalVoronoiMesh/DelaunayMesh/DelaunayMesh.H

@@ -0,0 +1,291 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012-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/>.
+
+Class
+    Foam::DelaunayMesh
+
+Description
+    The vertex and cell classes must have an index defined
+
+SourceFiles
+    DelaunayMeshI.H
+    DelaunayMesh.C
+    DelaunayMeshIO.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef DelaunayMesh_H
+#define DelaunayMesh_H
+
+#include "Pair.H"
+#include "HashSet.H"
+#include "FixedList.H"
+#include "boundBox.H"
+#include "indexedVertex.H"
+#include "CGALTriangulation3Ddefs.H"
+#include "Time.H"
+#include "autoPtr.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+class fvMesh;
+
+/*---------------------------------------------------------------------------*\
+                        Class DelaunayMesh Declaration
+\*---------------------------------------------------------------------------*/
+
+template<class Triangulation>
+class DelaunayMesh
+:
+    public Triangulation
+{
+public:
+
+        typedef typename Triangulation::Cell_handle Cell_handle;
+        typedef typename Triangulation::Vertex_handle Vertex_handle;
+        typedef typename Triangulation::Edge Edge;
+        typedef typename Triangulation::Point Point;
+        typedef typename Triangulation::Facet Facet;
+
+        typedef typename Triangulation::Finite_vertices_iterator
+            Finite_vertices_iterator;
+        typedef typename Triangulation::Finite_cells_iterator
+            Finite_cells_iterator;
+        typedef typename Triangulation::Finite_facets_iterator
+            Finite_facets_iterator;
+
+        typedef HashSet
+        <
+           Pair<label>,
+           FixedList<label, 2>::Hash<>
+        > labelPairHashSet;
+
+        typedef HashTable
+        <
+            label,
+            labelPair,
+            FixedList<label, 2>::Hash<>
+        > labelTolabelPairHashTable;
+
+
+private:
+
+    // Private data
+
+        //- Keep track of the number of vertices that have been added.
+        //  This allows a unique index to be assigned to each vertex.
+        mutable label vertexCount_;
+
+        //- Keep track of the number of cells that have been added.
+        //  This allows a unique index to be assigned to each cell.
+        mutable label cellCount_;
+
+        //- Reference to Time
+        const Time& runTime_;
+
+        //- Spatial sort traits to use with a pair of point pointers and an int.
+        //  Taken from a post on the CGAL lists: 2010-01/msg00004.html by
+        //  Sebastien Loriot (Geometry Factory).
+        struct Traits_for_spatial_sort
+        :
+            public Triangulation::Geom_traits
+        {
+            typedef typename Triangulation::Geom_traits Gt;
+
+            typedef std::pair<const typename Triangulation::Point*, int>
+                Point_3;
+
+            struct Less_x_3
+            {
+                bool operator()(const Point_3& p, const Point_3& q) const;
+            };
+
+            struct Less_y_3
+            {
+                bool operator()(const Point_3& p, const Point_3& q) const;
+            };
+
+            struct Less_z_3
+            {
+                bool operator()(const Point_3& p, const Point_3& q) const;
+            };
+
+            Less_x_3 less_x_3_object() const;
+            Less_y_3 less_y_3_object() const;
+            Less_z_3 less_z_3_object() const;
+        };
+
+
+    // Private Member Functions
+
+        void sortFaces
+        (
+            faceList& faces,
+            labelList& owner,
+            labelList& neighbour
+        ) const;
+
+        void addPatches
+        (
+            const label nInternalFaces,
+            faceList& faces,
+            labelList& owner,
+            PtrList<dictionary>& patchDicts,
+            const List<DynamicList<face> >& patchFaces,
+            const List<DynamicList<label> >& patchOwners
+        ) const;
+
+        //- Disallow default bitwise copy construct
+        DelaunayMesh(const DelaunayMesh<Triangulation>&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const DelaunayMesh<Triangulation>&);
+
+
+public:
+
+    // Constructors
+
+        //- Construct from components
+        explicit DelaunayMesh(const Time& runTime);
+
+        DelaunayMesh
+        (
+            const Time& runTime,
+            const word& meshName
+        );
+
+
+    //- Destructor
+    ~DelaunayMesh();
+
+
+    // Member Functions
+
+        // Access
+
+            //- Return a reference to the Time object
+            inline const Time& time() const;
+
+
+        // Check
+
+            //- Write the cpuTime to screen
+            inline void timeCheck
+            (
+                const string& description,
+                const bool check = true
+            ) const;
+
+
+        // Indexing functions
+
+            //- Create a new unique cell index and return
+            inline label getNewCellIndex() const;
+
+            //- Create a new unique vertex index and return
+            inline label getNewVertexIndex() const;
+
+            //- Return the cell count (the next unique cell index)
+            inline label cellCount() const;
+
+            //- Return the vertex count (the next unique vertex index)
+            inline label vertexCount() const;
+
+            //- Set the cell count to zero
+            inline void resetCellCount();
+
+            //- Set the vertex count to zero
+            inline void resetVertexCount();
+
+
+        // Triangulation manipulation functions
+
+            //- Clear the entire triangulation
+            void reset();
+
+            //- Insert the list of vertices (calls rangeInsertWithInfo)
+            Map<label> insertPoints
+            (
+                const List<Vb>& vertices,
+                const bool reIndex
+            );
+
+            //- Function inserting points into a triangulation and setting the
+            //  index and type data of the point in the correct order. This is
+            //  faster than inserting points individually.
+            //
+            //  Adapted from a post on the CGAL lists: 2010-01/msg00004.html by
+            //  Sebastien Loriot (Geometry Factory).
+            template<class PointIterator>
+            Map<label> rangeInsertWithInfo
+            (
+                PointIterator begin,
+                PointIterator end,
+                bool printErrors = false,
+                bool reIndex = true
+            );
+
+
+        // Write
+
+            //- Write mesh statistics to stream
+            void printInfo(Ostream& os) const;
+
+            //- Write vertex statistics in the form of a table to stream
+            void printVertexInfo(Ostream& os) const;
+
+            //- Create an fvMesh from the triangulation.
+            //  The mesh is not parallel consistent - only used for viewing
+            autoPtr<polyMesh> createMesh
+            (
+                const fileName& name,
+                labelTolabelPairHashTable& vertexMap,
+                labelList& cellMap,
+                const bool writeDelaunayData = true
+            ) const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#include "DelaunayMeshI.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+#   include "DelaunayMesh.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

applications/utilities/mesh/generation/foamyHexMesh/conformalVoronoiMesh/DelaunayMesh/DelaunayMeshI.H

@@ -0,0 +1,124 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012-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/>.
+
+\*---------------------------------------------------------------------------*/
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+template<class Triangulation>
+inline const Foam::Time& Foam::DelaunayMesh<Triangulation>::time() const
+{
+    return runTime_;
+}
+
+
+template<class Triangulation>
+void Foam::DelaunayMesh<Triangulation>::timeCheck
+(
+    const string& description,
+    const bool check
+) const
+{
+    if (check)
+    {
+        Info<< nl << "--- [ cpuTime "
+            << time().elapsedCpuTime() << " s, "
+            << "delta " << time().cpuTimeIncrement()<< " s";
+
+        if (description != word::null)
+        {
+            Info<< ", " << description << " ";
+        }
+        else
+        {
+            Info<< " ";
+        }
+
+        Info<< "] --- " << endl;
+    }
+}
+
+
+template<class Triangulation>
+inline Foam::label Foam::DelaunayMesh<Triangulation>::getNewCellIndex() const
+{
+    label id = cellCount_++;
+
+    if (id == labelMax)
+    {
+        WarningIn
+        (
+            "Foam::DelaunayMesh<Triangulation>::getNewCellIndex() const"
+        )   << "Cell counter has overflowed." << endl;
+    }
+
+    return id;
+}
+
+
+template<class Triangulation>
+inline Foam::label Foam::DelaunayMesh<Triangulation>::getNewVertexIndex() const
+{
+    label id = vertexCount_++;
+
+    if (id == labelMax)
+    {
+        WarningIn
+        (
+            "Foam::DelaunayMesh<Triangulation>::getNewVertexIndex() const"
+        )   << "Vertex counter has overflowed." << endl;
+    }
+
+    return id;
+}
+
+
+template<class Triangulation>
+Foam::label Foam::DelaunayMesh<Triangulation>::cellCount() const
+{
+    return cellCount_;
+}
+
+
+template<class Triangulation>
+Foam::label Foam::DelaunayMesh<Triangulation>::vertexCount() const
+{
+    return vertexCount_;
+}
+
+
+template<class Triangulation>
+void Foam::DelaunayMesh<Triangulation>::resetCellCount()
+{
+    cellCount_ = 0;
+}
+
+
+template<class Triangulation>
+void Foam::DelaunayMesh<Triangulation>::resetVertexCount()
+{
+    vertexCount_ = 0;
+}
+
+
+// ************************************************************************* //

applications/utilities/mesh/generation/foamyHexMesh/conformalVoronoiMesh/DelaunayMesh/DelaunayMeshIO.C

@@ -0,0 +1,652 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012-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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "DelaunayMesh.H"
+#include "fvMesh.H"
+#include "pointConversion.H"
+#include "wallPolyPatch.H"
+#include "processorPolyPatch.H"
+#include "labelIOField.H"
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+template<class Triangulation>
+void Foam::DelaunayMesh<Triangulation>::sortFaces
+(
+    faceList& faces,
+    labelList& owner,
+    labelList& neighbour
+) const
+{
+    // Upper triangular order:
+    // + owner is sorted in ascending cell order
+    // + within each block of equal value for owner, neighbour is sorted in
+    //   ascending cell order.
+    // + faces sorted to correspond
+    // e.g.
+    // owner | neighbour
+    // 0     | 2
+    // 0     | 23
+    // 0     | 71
+    // 1     | 23
+    // 1     | 24
+    // 1     | 91
+
+    List<labelPair> ownerNeighbourPair(owner.size());
+
+    forAll(ownerNeighbourPair, oNI)
+    {
+        ownerNeighbourPair[oNI] = labelPair(owner[oNI], neighbour[oNI]);
+    }
+
+    Info<< nl
+        << "Sorting faces, owner and neighbour into upper triangular order"
+        << endl;
+
+    labelList oldToNew;
+
+    sortedOrder(ownerNeighbourPair, oldToNew);
+
+    oldToNew = invert(oldToNew.size(), oldToNew);
+
+    inplaceReorder(oldToNew, faces);
+    inplaceReorder(oldToNew, owner);
+    inplaceReorder(oldToNew, neighbour);
+}
+
+
+template<class Triangulation>
+void Foam::DelaunayMesh<Triangulation>::addPatches
+(
+    const label nInternalFaces,
+    faceList& faces,
+    labelList& owner,
+    PtrList<dictionary>& patchDicts,
+    const List<DynamicList<face> >& patchFaces,
+    const List<DynamicList<label> >& patchOwners
+) const
+{
+    label nPatches = patchFaces.size();
+
+    patchDicts.setSize(nPatches);
+    forAll(patchDicts, patchI)
+    {
+        patchDicts.set(patchI, new dictionary());
+    }
+
+    label nBoundaryFaces = 0;
+
+    forAll(patchFaces, p)
+    {
+        patchDicts[p].set("nFaces", patchFaces[p].size());
+        patchDicts[p].set("startFace", nInternalFaces + nBoundaryFaces);
+
+        nBoundaryFaces += patchFaces[p].size();
+    }
+
+    faces.setSize(nInternalFaces + nBoundaryFaces);
+    owner.setSize(nInternalFaces + nBoundaryFaces);
+
+    label faceI = nInternalFaces;
+
+    forAll(patchFaces, p)
+    {
+        forAll(patchFaces[p], f)
+        {
+            faces[faceI] = patchFaces[p][f];
+            owner[faceI] = patchOwners[p][f];
+
+            faceI++;
+        }
+    }
+}
+
+
+// * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * * //
+
+template<class Triangulation>
+void Foam::DelaunayMesh<Triangulation>::printInfo(Ostream& os) const
+{
+    PrintTable<word, label> triInfoTable("Mesh Statistics");
+
+    triInfoTable.add("Points", Triangulation::number_of_vertices());
+    triInfoTable.add("Edges", Triangulation::number_of_finite_edges());
+    triInfoTable.add("Faces", Triangulation::number_of_finite_facets());
+    triInfoTable.add("Cells", Triangulation::number_of_finite_cells());
+
+    scalar minSize = GREAT;
+    scalar maxSize = 0;
+
+    for
+    (
+        Finite_vertices_iterator vit = Triangulation::finite_vertices_begin();
+        vit != Triangulation::finite_vertices_end();
+        ++vit
+    )
+    {
+        // Only internal or boundary vertices have a size
+        if (vit->internalOrBoundaryPoint())
+        {
+            minSize = min(vit->targetCellSize(), minSize);
+            maxSize = max(vit->targetCellSize(), maxSize);
+        }
+    }
+
+    Info<< incrIndent;
+    triInfoTable.print(Info, true, true);
+
+    Info<< "Size (Min/Max) = "
+        << returnReduce(minSize, minOp<scalar>()) << " "
+        << returnReduce(maxSize, maxOp<scalar>()) << endl;
+
+    Info<< decrIndent;
+}
+
+
+template<class Triangulation>
+void Foam::DelaunayMesh<Triangulation>::printVertexInfo(Ostream& os) const
+{
+    label nInternal = 0;
+    label nInternalRef = 0;
+    label nUnassigned = 0;
+    label nUnassignedRef = 0;
+    label nInternalNearBoundary = 0;
+    label nInternalNearBoundaryRef = 0;
+    label nInternalSurface = 0;
+    label nInternalSurfaceRef = 0;
+    label nInternalFeatureEdge = 0;
+    label nInternalFeatureEdgeRef = 0;
+    label nInternalFeaturePoint = 0;
+    label nInternalFeaturePointRef = 0;
+    label nExternalSurface = 0;
+    label nExternalSurfaceRef = 0;
+    label nExternalFeatureEdge = 0;
+    label nExternalFeatureEdgeRef = 0;
+    label nExternalFeaturePoint = 0;
+    label nExternalFeaturePointRef = 0;
+    label nFar = 0;
+    label nReferred = 0;
+
+    for
+    (
+        Finite_vertices_iterator vit = Triangulation::finite_vertices_begin();
+        vit != Triangulation::finite_vertices_end();
+        ++vit
+    )
+    {
+        if (vit->type() == Vb::vtInternal)
+        {
+            if (vit->referred())
+            {
+                nReferred++;
+                nInternalRef++;
+            }
+
+            nInternal++;
+        }
+        else if (vit->type() == Vb::vtUnassigned)
+        {
+            if (vit->referred())
+            {
+                nReferred++;
+                nUnassignedRef++;
+            }
+
+            nUnassigned++;
+        }
+        else if (vit->type() == Vb::vtInternalNearBoundary)
+        {
+            if (vit->referred())
+            {
+                nReferred++;
+                nInternalNearBoundaryRef++;
+            }
+
+            nInternalNearBoundary++;
+        }
+        else if (vit->type() == Vb::vtInternalSurface)
+        {
+            if (vit->referred())
+            {
+                nReferred++;
+                nInternalSurfaceRef++;
+            }
+
+            nInternalSurface++;
+        }
+        else if (vit->type() == Vb::vtInternalFeatureEdge)
+        {
+            if (vit->referred())
+            {
+                nReferred++;
+                nInternalFeatureEdgeRef++;
+            }
+
+            nInternalFeatureEdge++;
+        }
+        else if (vit->type() == Vb::vtInternalFeaturePoint)
+        {
+            if (vit->referred())
+            {
+                nReferred++;
+                nInternalFeaturePointRef++;
+            }
+
+            nInternalFeaturePoint++;
+        }
+        else if (vit->type() == Vb::vtExternalSurface)
+        {
+            if (vit->referred())
+            {
+                nReferred++;
+                nExternalSurfaceRef++;
+            }
+
+            nExternalSurface++;
+        }
+        else if (vit->type() == Vb::vtExternalFeatureEdge)
+        {
+            if (vit->referred())
+            {
+                nReferred++;
+                nExternalFeatureEdgeRef++;
+            }
+
+            nExternalFeatureEdge++;
+        }
+        else if (vit->type() == Vb::vtExternalFeaturePoint)
+        {
+            if (vit->referred())
+            {
+                nReferred++;
+                nExternalFeaturePointRef++;
+            }
+
+            nExternalFeaturePoint++;
+        }
+        else if (vit->type() == Vb::vtFar)
+        {
+            nFar++;
+        }
+    }
+
+    label nTotalVertices =
+          nUnassigned
+        + nInternal
+        + nInternalNearBoundary
+        + nInternalSurface
+        + nInternalFeatureEdge
+        + nInternalFeaturePoint
+        + nExternalSurface
+        + nExternalFeatureEdge
+        + nExternalFeaturePoint
+        + nFar;
+
+    if (nTotalVertices != label(Triangulation::number_of_vertices()))
+    {
+        WarningIn("Foam::conformalVoronoiMesh::printVertexInfo()")
+            << nTotalVertices << " does not equal "
+            << Triangulation::number_of_vertices()
+            << endl;
+    }
+
+    PrintTable<word, label> vertexTable("Vertex Type Information");
+
+    vertexTable.add("Total", nTotalVertices);
+    vertexTable.add("Unassigned", nUnassigned);
+    vertexTable.add("nInternal", nInternal);
+    vertexTable.add("nInternalNearBoundary", nInternalNearBoundary);
+    vertexTable.add("nInternalSurface", nInternalSurface);
+    vertexTable.add("nInternalFeatureEdge", nInternalFeatureEdge);
+    vertexTable.add("nInternalFeaturePoint", nInternalFeaturePoint);
+    vertexTable.add("nExternalSurface", nExternalSurface);
+    vertexTable.add("nExternalFeatureEdge", nExternalFeatureEdge);
+    vertexTable.add("nExternalFeaturePoint", nExternalFeaturePoint);
+    vertexTable.add("nFar", nFar);
+    vertexTable.add("nReferred", nReferred);
+
+    os  << endl;
+    vertexTable.print(os);
+}
+
+
+template<class Triangulation>
+Foam::autoPtr<Foam::polyMesh>
+Foam::DelaunayMesh<Triangulation>::createMesh
+(
+    const fileName& name,
+    labelTolabelPairHashTable& vertexMap,
+    labelList& cellMap,
+    const bool writeDelaunayData
+) const
+{
+    pointField points(Triangulation::number_of_vertices());
+    faceList faces(Triangulation::number_of_finite_facets());
+    labelList owner(Triangulation::number_of_finite_facets());
+    labelList neighbour(Triangulation::number_of_finite_facets());
+
+    wordList patchNames(1, "foamyHexMesh_defaultPatch");
+    wordList patchTypes(1, wallPolyPatch::typeName);
+
+    PtrList<dictionary> patchDicts(1);
+    patchDicts.set(0, new dictionary());
+
+    List<DynamicList<face> > patchFaces(1, DynamicList<face>());
+    List<DynamicList<label> > patchOwners(1, DynamicList<label>());
+
+    vertexMap.resize(vertexCount());
+    cellMap.setSize(Triangulation::number_of_finite_cells(), -1);
+
+    // Calculate pts and a map of point index to location in pts.
+    label vertI = 0;
+
+//    labelIOField indices
+//    (
+//        IOobject
+//        (
+//            "indices",
+//            time().timeName(),
+//            name,
+//            time(),
+//            IOobject::NO_READ,
+//            IOobject::AUTO_WRITE
+//        ),
+//        Triangulation::number_of_vertices()
+//    );
+
+    labelIOField types
+    (
+        IOobject
+        (
+            "types",
+            time().timeName(),
+            name,
+            time(),
+            IOobject::NO_READ,
+            IOobject::AUTO_WRITE
+        ),
+        Triangulation::number_of_vertices()
+    );
+
+    labelIOField processorIndices
+    (
+        IOobject
+        (
+            "processorIndices",
+            time().timeName(),
+            name,
+            time(),
+            IOobject::NO_READ,
+            IOobject::AUTO_WRITE
+        ),
+        Triangulation::number_of_vertices()
+    );
+
+    for
+    (
+        Finite_vertices_iterator vit = Triangulation::finite_vertices_begin();
+        vit != Triangulation::finite_vertices_end();
+        ++vit
+    )
+    {
+        if (!vit->farPoint())
+        {
+            vertexMap(labelPair(vit->index(), vit->procIndex())) = vertI;
+            points[vertI] = topoint(vit->point());
+//            indices[vertI] = vit->index();
+            types[vertI] = static_cast<label>(vit->type());
+            processorIndices[vertI] = vit->procIndex();
+            vertI++;
+        }
+    }
+
+    points.setSize(vertI);
+//    indices.setSize(vertI);
+    types.setSize(vertI);
+    processorIndices.setSize(vertI);
+
+
+    // Index the cells
+    label cellI = 0;
+
+    for
+    (
+        Finite_cells_iterator cit = Triangulation::finite_cells_begin();
+        cit != Triangulation::finite_cells_end();
+        ++cit
+    )
+    {
+        if
+        (
+            !cit->hasFarPoint()
+         && !Triangulation::is_infinite(cit)
+         && cit->real()
+        )
+        {
+            cellMap[cit->cellIndex()] = cellI++;
+        }
+    }
+
+    label faceI = 0;
+    labelList verticesOnTriFace(3, -1);
+    face newFace(verticesOnTriFace);
+
+    for
+    (
+        Finite_facets_iterator fit = Triangulation::finite_facets_begin();
+        fit != Triangulation::finite_facets_end();
+        ++fit
+    )
+    {
+        const Cell_handle c1(fit->first);
+        const int oppositeVertex = fit->second;
+        const Cell_handle c2(c1->neighbor(oppositeVertex));
+
+        // Do not output if face has neither opposite vertex as an internal
+//        if
+//        (
+//            !c1->vertex(oppositeVertex)->internalPoint()
+//         || !Triangulation::mirror_vertex(c1, oppositeVertex)->internalPoint()
+//        )
+//        {
+//            continue;
+//        }
+
+        label c1I = Cb::ctFar;
+        bool c1Real = false;
+        if
+        (
+            !Triangulation::is_infinite(c1)
+         && !c1->hasFarPoint()
+         && c1->real()
+        )
+        {
+            c1I = cellMap[c1->cellIndex()];
+            c1Real = true;
+        }
+
+        label c2I = Cb::ctFar;
+        bool c2Real = false;
+        if
+        (
+            !Triangulation::is_infinite(c2)
+         && !c2->hasFarPoint()
+         && c2->real()
+        )
+        {
+            c2I = cellMap[c2->cellIndex()];
+            c2Real = true;
+        }
+
+        if (!c1Real && !c2Real)
+        {
+            // Both tets are outside, skip
+            continue;
+        }
+
+        label ownerCell = -1;
+        label neighbourCell = -1;
+
+        for (label i = 0; i < 3; i++)
+        {
+            verticesOnTriFace[i] = vertexMap
+            [
+                labelPair
+                (
+                    c1->vertex
+                    (
+                        Triangulation::vertex_triple_index(oppositeVertex, i)
+                    )->index(),
+                    c1->vertex
+                    (
+                        Triangulation::vertex_triple_index(oppositeVertex, i)
+                    )->procIndex()
+                )
+            ];
+        }
+
+        newFace = face(verticesOnTriFace);
+
+        if (!c1Real || !c2Real)
+        {
+            // Boundary face...
+            if (!c1Real)
+            {
+                //... with c1 outside
+                ownerCell = c2I;
+            }
+            else
+            {
+                // ... with c2 outside
+                ownerCell = c1I;
+
+                reverse(newFace);
+            }
+
+            patchFaces[0].append(newFace);
+            patchOwners[0].append(ownerCell);
+        }
+        else
+        {
+            // Internal face...
+            if (c1I < c2I)
+            {
+                // ...with c1 as the ownerCell
+                ownerCell = c1I;
+                neighbourCell = c2I;
+
+                reverse(newFace);
+            }
+            else
+            {
+                // ...with c2 as the ownerCell
+                ownerCell = c2I;
+                neighbourCell = c1I;
+            }
+
+            faces[faceI] = newFace;
+            owner[faceI] = ownerCell;
+            neighbour[faceI] = neighbourCell;
+            faceI++;
+        }
+    }
+
+    faces.setSize(faceI);
+    owner.setSize(faceI);
+    neighbour.setSize(faceI);
+
+    sortFaces(faces, owner, neighbour);
+
+    Info<< "Creating patches" << endl;
+
+    addPatches
+    (
+        faceI,
+        faces,
+        owner,
+        patchDicts,
+        patchFaces,
+        patchOwners
+    );
+
+    Info<< "Creating mesh" << endl;
+
+    autoPtr<polyMesh> meshPtr
+    (
+        new polyMesh
+        (
+            IOobject
+            (
+                name,
+                time().timeName(),
+                time(),
+                IOobject::NO_READ,
+                IOobject::NO_WRITE
+            ),
+            xferMove(points),
+            xferMove(faces),
+            xferMove(owner),
+            xferMove(neighbour)
+        )
+    );
+
+    Info<< "Adding patches" << endl;
+
+    List<polyPatch*> patches(patchNames.size());
+
+    label nValidPatches = 0;
+
+    forAll(patches, p)
+    {
+        patches[nValidPatches] = polyPatch::New
+        (
+            patchTypes[p],
+            patchNames[p],
+            patchDicts[p],
+            nValidPatches,
+            meshPtr().boundaryMesh()
+        ).ptr();
+
+        nValidPatches++;
+    }
+
+    patches.setSize(nValidPatches);
+
+    meshPtr().addPatches(patches);
+
+    if (writeDelaunayData)
+    {
+//        indices.write();
+        types.write();
+        processorIndices.write();
+    }
+
+    Info<< "Mesh created" << endl;
+
+    return meshPtr;
+}
+
+
+// ************************************************************************* //

applications/utilities/mesh/generation/foamyHexMesh/conformalVoronoiMesh/DelaunayMesh/DistributedDelaunayMesh.H

@@ -0,0 +1,223 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012-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/>.
+
+Class
+    Foam::DistributedDelaunayMesh
+
+Description
+
+SourceFiles
+    DistributedDelaunayMeshI.H
+    DistributedDelaunayMesh.C
+    DistributedDelaunayMeshIO.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef DistributedDelaunayMesh_H
+#define DistributedDelaunayMesh_H
+
+#include "DelaunayMesh.H"
+#include "backgroundMeshDecomposition.H"
+#include "autoPtr.H"
+#include "boundBox.H"
+#include "indexedVertex.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+class mapDistribute;
+
+/*---------------------------------------------------------------------------*\
+                  Class DistributedDelaunayMesh Declaration
+\*---------------------------------------------------------------------------*/
+
+template<class Triangulation>
+class DistributedDelaunayMesh
+:
+    public DelaunayMesh<Triangulation>
+{
+public:
+
+        typedef typename Triangulation::Vertex_handle Vertex_handle;
+        typedef typename Triangulation::Cell_handle   Cell_handle;
+        typedef typename Triangulation::Point         Point;
+
+        typedef typename Triangulation::Finite_vertices_iterator
+            Finite_vertices_iterator;
+        typedef typename Triangulation::Finite_cells_iterator
+            Finite_cells_iterator;
+        typedef typename Triangulation::All_cells_iterator
+            All_cells_iterator;
+
+        typedef typename DelaunayMesh<Triangulation>::labelPairHashSet
+            labelPairHashSet;
+
+
+private:
+
+        autoPtr<List<boundBox> > allBackgroundMeshBounds_;
+
+
+    // Private Member Functions
+
+        //-
+        bool distributeBoundBoxes(const boundBox& bb);
+
+        //-
+        bool isLocal(const Vertex_handle& v) const;
+
+        bool isLocal(const label localProcIndex) const;
+
+        labelList overlapProcessors
+        (
+            const point& centre,
+            const scalar radiusSqr
+        ) const;
+
+        bool checkProcBoundaryCell
+        (
+            const Cell_handle& cit,
+            Map<labelList>& circumsphereOverlaps
+        ) const;
+
+        void findProcessorBoundaryCells
+        (
+            Map<labelList>& circumsphereOverlaps
+        ) const;
+
+        void markVerticesToRefer
+        (
+            const Map<labelList>& circumsphereOverlaps,
+            PtrList<labelPairHashSet>& referralVertices,
+            DynamicList<label>& targetProcessor,
+            DynamicList<Vb>& parallelInfluenceVertices
+        );
+
+        label referVertices
+        (
+            const DynamicList<label>& targetProcessor,
+            DynamicList<Vb>& parallelVertices,
+            PtrList<labelPairHashSet>& referralVertices,
+            labelPairHashSet& receivedVertices
+        );
+
+        //- Disallow default bitwise copy construct
+        DistributedDelaunayMesh(const DistributedDelaunayMesh<Triangulation>&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const DistributedDelaunayMesh<Triangulation>&);
+
+
+public:
+
+    // Constructors
+
+        //- Construct from components
+        explicit DistributedDelaunayMesh(const Time& runTime);
+
+        DistributedDelaunayMesh
+        (
+            const Time& runTime,
+            const word& meshName
+        );
+
+
+    //- Destructor
+    ~DistributedDelaunayMesh();
+
+
+    // Queries
+
+        //- Use DelaunayMesh timeCheck function
+        using DelaunayMesh<Triangulation>::timeCheck;
+
+        scalar calculateLoadUnbalance() const;
+
+
+    // Member Functions
+
+        //- Build a mapDistribute for the supplied destination processor data
+        static autoPtr<mapDistribute> buildMap(const List<label>& toProc);
+
+        //-
+        bool distribute(const boundBox& bb);
+
+        autoPtr<mapDistribute> distribute
+        (
+            const backgroundMeshDecomposition& decomposition,
+            List<Foam::point>& points
+        );
+
+        //- Refer vertices so that the processor interfaces are consistent
+        void sync(const boundBox& bb);
+
+        //- Refer vertices so that the processor interfaces are consistent
+        void sync
+        (
+            const boundBox& bb,
+            PtrList<labelPairHashSet>& referralVertices,
+            labelPairHashSet& receivedVertices,
+            bool iterateReferral = true
+        );
+
+        //- Inserts points into the triangulation if the point is within
+        //  the circumsphere of another cell. Returns HashSet of failed
+        //  point insertions
+        template<class PointIterator>
+        labelPairHashSet rangeInsertReferredWithInfo
+        (
+            PointIterator begin,
+            PointIterator end,
+            bool printErrors = true
+        );
+
+//        distributeField();
+
+
+    // Queries
+
+
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+//#include "DistributedDelaunayMeshI.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+#   include "DistributedDelaunayMesh.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

applications/utilities/mesh/generation/foamyHexMesh/conformalVoronoiMesh/DelaunayMeshTools/DelaunayMeshTools.C

@@ -0,0 +1,110 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "DelaunayMeshTools.H"
+#include "meshTools.H"
+#include "OFstream.H"
+#include "pointConversion.H"
+
+// * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
+
+void Foam::DelaunayMeshTools::writeOBJ
+(
+    const fileName& fName,
+    const List<Foam::point>& points
+)
+{
+    if (points.size())
+    {
+        OFstream str(fName);
+
+        Pout<< nl
+            << "Writing " << points.size() << " points from pointList to "
+            << str.name() << endl;
+
+        forAll(points, p)
+        {
+            meshTools::writeOBJ(str, points[p]);
+        }
+    }
+}
+
+
+void Foam::DelaunayMeshTools::writeOBJ
+(
+    const fileName& fName,
+    const List<Vb>& points
+)
+{
+    if (points.size())
+    {
+        OFstream str(fName);
+
+        Pout<< nl
+            << "Writing " << points.size() << " points from pointList to "
+            << str.name() << endl;
+
+        forAll(points, p)
+        {
+            meshTools::writeOBJ(str, topoint(points[p].point()));
+        }
+    }
+}
+
+
+void Foam::DelaunayMeshTools::writeObjMesh
+(
+    const fileName& fName,
+    const pointField& points,
+    const faceList& faces
+)
+{
+    OFstream str(fName);
+
+    Pout<< nl
+        << "Writing points and faces to " << str.name() << endl;
+
+    forAll(points, p)
+    {
+        meshTools::writeOBJ(str, points[p]);
+    }
+
+    forAll(faces, f)
+    {
+        str<< 'f';
+
+        const face& fP = faces[f];
+
+        forAll(fP, p)
+        {
+            str<< ' ' << fP[p] + 1;
+        }
+
+        str<< nl;
+    }
+}
+
+
+// ************************************************************************* //

applications/utilities/mesh/generation/foamyHexMesh/conformalVoronoiMesh/DelaunayMeshTools/DelaunayMeshTools.H

@@ -0,0 +1,152 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 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/>.
+
+Class
+    Foam::DelaunayMeshTools
+
+Description
+    Collection of functions for operating on a Delaunay mesh. Includes:
+
+      - Functions for writing to an OBJ file
+      - Functions for extracting fields from the Delaunay triangulation
+
+SourceFiles
+    DelaunayMeshToolsI.H
+    DelaunayMeshTools.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef DelaunayMeshTools_H
+#define DelaunayMeshTools_H
+
+#include "fileName.H"
+#include "List.H"
+#include "point.H"
+#include "CGALTriangulation3Ddefs.H"
+#include "indexedVertexEnum.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                   Namespace DelaunayMeshTools Declaration
+\*---------------------------------------------------------------------------*/
+
+namespace DelaunayMeshTools
+{
+
+// OBJ writing
+
+    //- Write list of points to file
+    void writeOBJ(const fileName& fName, const List<Foam::point>& points);
+
+    //- Write list of points to file
+    void writeOBJ(const fileName& fName, const List<Vb>& points);
+
+    //- Write an OBJ mesh consisting of points and faces
+    void writeObjMesh
+    (
+        const fileName& fName,
+        const pointField& points,
+        const faceList& faces
+    );
+
+    //- Write Delaunay points in the range between (and including)
+    //  type startPointType and endPointType to an OBJ file
+    template<typename Triangulation>
+    void writeOBJ
+    (
+        const fileName& fName,
+        const Triangulation& t,
+        const indexedVertexEnum::vertexType startPointType,
+        const indexedVertexEnum::vertexType endPointType
+    );
+
+    //- Write Delaunay points of type pointType to .obj file
+    template<typename Triangulation>
+    void writeOBJ
+    (
+        const fileName& fName,
+        const Triangulation& t,
+        const indexedVertexEnum::vertexType pointType
+    );
+
+    //- Write the fixed Delaunay points to an OBJ file
+    template<typename Triangulation>
+    void writeFixedPoints(const fileName& fName, const Triangulation& t);
+
+    //- Write the boundary Delaunay points to an OBJ file
+    template<typename Triangulation>
+    void writeBoundaryPoints(const fileName& fName, const Triangulation& t);
+
+    //- Write the processor interface to an OBJ file
+    template<typename Triangulation>
+    void writeProcessorInterface
+    (
+        const fileName& fName,
+        const Triangulation& t,
+        const faceList& faces
+    );
+
+    //- Write the internal Delaunay vertices of the tessellation as a
+    //  pointField that may be used to restart the meshing process
+    template<typename Triangulation>
+    void writeInternalDelaunayVertices
+    (
+        const fileName& instance,
+        const Triangulation& t
+    );
+
+    //- Draws a tet cell to an output stream. The offset is supplied as the tet
+    //  number to be drawn.
+    template<typename CellHandle>
+    void drawDelaunayCell(Ostream& os, const CellHandle& c, label offset = 0);
+
+
+// Field extraction
+
+    //- Extract all points in vertex-index order
+    template<typename Triangulation>
+    tmp<pointField> allPoints(const Triangulation& t);
+
+
+} // End namespace DelaunayMeshTools
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+#   include "DelaunayMeshToolsTemplates.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

applications/utilities/mesh/generation/foamyHexMesh/conformalVoronoiMesh/DelaunayMeshTools/DelaunayMeshToolsTemplates.C

@@ -0,0 +1,303 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "DelaunayMeshTools.H"
+#include "meshTools.H"
+#include "OFstream.H"
+#include "pointConversion.H"
+#include "pointIOField.H"
+#include "indexedVertexOps.H"
+
+// * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
+
+template<typename Triangulation>
+void Foam::DelaunayMeshTools::writeOBJ
+(
+    const fileName& fName,
+    const Triangulation& t,
+    const indexedVertexEnum::vertexType startPointType,
+    const indexedVertexEnum::vertexType endPointType
+)
+{
+    OFstream str(fName);
+
+    Pout<< nl
+        << "Writing points of types:" << nl;
+
+    forAllConstIter
+    (
+        HashTable<int>,
+        indexedVertexEnum::vertexTypeNames_,
+        iter
+    )
+    {
+        if (iter() >= startPointType && iter() <= endPointType)
+        {
+            Pout<< "    " << iter.key() << nl;
+        }
+    }
+
+    Pout<< "to " << str.name() << endl;
+
+    for
+    (
+        typename Triangulation::Finite_vertices_iterator vit =
+            t.finite_vertices_begin();
+        vit != t.finite_vertices_end();
+        ++vit
+    )
+    {
+        if (vit->type() >= startPointType && vit->type() <= endPointType)
+        {
+            meshTools::writeOBJ(str, topoint(vit->point()));
+        }
+    }
+}
+
+
+template<typename Triangulation>
+void Foam::DelaunayMeshTools::writeOBJ
+(
+    const fileName& fName,
+    const Triangulation& t,
+    const indexedVertexEnum::vertexType pointType
+)
+{
+    writeOBJ(fName, t, pointType, pointType);
+}
+
+
+template<typename Triangulation>
+void Foam::DelaunayMeshTools::writeFixedPoints
+(
+    const fileName& fName,
+    const Triangulation& t
+)
+{
+    OFstream str(fName);
+
+    Pout<< nl
+        << "Writing fixed points to " << str.name() << endl;
+
+    for
+    (
+        typename Triangulation::Finite_vertices_iterator vit =
+            t.finite_vertices_begin();
+        vit != t.finite_vertices_end();
+        ++vit
+    )
+    {
+        if (vit->fixed())
+        {
+            meshTools::writeOBJ(str, topoint(vit->point()));
+        }
+    }
+}
+
+
+template<typename Triangulation>
+void Foam::DelaunayMeshTools::writeBoundaryPoints
+(
+    const fileName& fName,
+    const Triangulation& t
+)
+{
+    OFstream str(fName);
+
+    Pout<< nl
+        << "Writing boundary points to " << str.name() << endl;
+
+    for
+    (
+        typename Triangulation::Finite_vertices_iterator vit =
+            t.finite_vertices_begin();
+        vit != t.finite_vertices_end();
+        ++vit
+    )
+    {
+        if (!vit->internalPoint())
+        {
+            meshTools::writeOBJ(str, topoint(vit->point()));
+        }
+    }
+}
+
+
+template<typename Triangulation>
+void Foam::DelaunayMeshTools::writeProcessorInterface
+(
+    const fileName& fName,
+    const Triangulation& t,
+    const faceList& faces
+)
+{
+    OFstream str(fName);
+
+    pointField points(t.number_of_finite_cells(), point::max);
+
+    for
+    (
+        typename Triangulation::Finite_cells_iterator cit =
+            t.finite_cells_begin();
+        cit != t.finite_cells_end();
+        ++cit
+    )
+    {
+        if (!cit->hasFarPoint() && !t.is_infinite(cit))
+        {
+            points[cit->cellIndex()] = cit->dual();
+        }
+    }
+
+    meshTools::writeOBJ(str, faces, points);
+}
+
+
+template<typename Triangulation>
+void Foam::DelaunayMeshTools::writeInternalDelaunayVertices
+(
+    const fileName& instance,
+    const Triangulation& t
+)
+{
+    pointField internalDelaunayVertices(t.number_of_vertices());
+
+    label vertI = 0;
+
+    for
+    (
+        typename Triangulation::Finite_vertices_iterator vit =
+            t.finite_vertices_begin();
+        vit != t.finite_vertices_end();
+        ++vit
+    )
+    {
+        if (vit->internalPoint())
+        {
+            internalDelaunayVertices[vertI++] = topoint(vit->point());
+        }
+    }
+
+    internalDelaunayVertices.setSize(vertI);
+
+    pointIOField internalDVs
+    (
+        IOobject
+        (
+            "internalDelaunayVertices",
+            instance,
+            t.time(),
+            IOobject::NO_READ,
+            IOobject::AUTO_WRITE
+        ),
+        internalDelaunayVertices
+    );
+
+    Info<< nl
+        << "Writing " << internalDVs.name()
+        << " to " << internalDVs.instance()
+        << endl;
+
+    internalDVs.write();
+}
+
+
+template<typename CellHandle>
+void Foam::DelaunayMeshTools::drawDelaunayCell
+(
+    Ostream& os,
+    const CellHandle& c,
+    label offset
+)
+{
+    // Supply offset as tet number
+    offset *= 4;
+
+    os  << "# cell index: " << label(c->cellIndex())
+        << " INT_MIN = " << INT_MIN
+        << endl;
+
+    os  << "# circumradius "
+        << mag(c->dual() - topoint(c->vertex(0)->point()))
+        << endl;
+
+    for (int i = 0; i < 4; i++)
+    {
+        os  << "# index / type / procIndex: "
+            << label(c->vertex(i)->index()) << " "
+            << label(c->vertex(i)->type()) << " "
+            << label(c->vertex(i)->procIndex())
+            <<
+                (
+                    CGAL::indexedVertexOps::uninitialised(c->vertex(i))
+                  ? " # This vertex is uninitialised!"
+                  : ""
+                )
+            << endl;
+
+        meshTools::writeOBJ(os, topoint(c->vertex(i)->point()));
+    }
+
+    os  << "f " << 1 + offset << " " << 3 + offset << " " << 2 + offset << nl
+        << "f " << 2 + offset << " " << 3 + offset << " " << 4 + offset << nl
+        << "f " << 1 + offset << " " << 4 + offset << " " << 3 + offset << nl
+        << "f " << 1 + offset << " " << 2 + offset << " " << 4 + offset << endl;
+
+//    os  << "# cicumcentre " << endl;
+
+//    meshTools::writeOBJ(os, c->dual());
+
+//    os  << "l " << 1 + offset << " " << 5 + offset << endl;
+}
+
+
+template<typename Triangulation>
+Foam::tmp<Foam::pointField> Foam::DelaunayMeshTools::allPoints
+(
+    const Triangulation& t
+)
+{
+    tmp<pointField> tpts(new pointField(t.vertexCount(), point::max));
+    pointField& pts = tpts();
+
+    for
+    (
+        typename Triangulation::Finite_vertices_iterator vit =
+            t.finite_vertices_begin();
+        vit != t.finite_vertices_end();
+        ++vit
+    )
+    {
+        if (vit->internalOrBoundaryPoint() && !vit->referred())
+        {
+            pts[vit->index()] = topoint(vit->point());
+        }
+    }
+
+    return tpts;
+}
+
+
+// ************************************************************************* //

applications/utilities/mesh/generation/foamyHexMesh/conformalVoronoiMesh/Make/files

@@ -0,0 +1,80 @@
+DelaunayMeshTools/DelaunayMeshTools.C
+
+conformalVoronoiMesh/indexedVertex/indexedVertexEnum.C
+conformalVoronoiMesh/indexedCell/indexedCellEnum.C
+
+conformalVoronoiMesh/conformalVoronoiMesh.C
+conformalVoronoiMesh/conformalVoronoiMeshCalcDualMesh.C
+conformalVoronoiMesh/conformalVoronoiMeshConformToSurface.C
+conformalVoronoiMesh/conformalVoronoiMeshZones.C
+conformalVoronoiMesh/conformalVoronoiMeshIO.C
+conformalVoronoiMesh/conformalVoronoiMeshFeaturePoints.C
+
+conformalVoronoiMesh/featurePointConformer/pointFeatureEdgesTypes.C
+conformalVoronoiMesh/featurePointConformer/featurePointConformer.C
+conformalVoronoiMesh/featurePointConformer/featurePointConformerSpecialisations.C
+
+cvControls/cvControls.C
+
+conformationSurfaces/conformationSurfaces.C
+
+backgroundMeshDecomposition/backgroundMeshDecomposition.C
+
+cellShapeControl/cellShapeControl/cellShapeControl.C
+
+cellShapeControl/cellShapeControlMesh/cellShapeControlMesh.C
+
+cellSizeAndAlignmentControl = cellShapeControl/cellSizeAndAlignmentControl
+$(cellSizeAndAlignmentControl)/cellSizeAndAlignmentControls.C
+$(cellSizeAndAlignmentControl)/cellSizeAndAlignmentControl/cellSizeAndAlignmentControl.C
+$(cellSizeAndAlignmentControl)/fileControl/fileControl.C
+$(cellSizeAndAlignmentControl)/searchableSurfaceControl/searchableSurfaceControl.C
+/*cellShapeControl/pQuadCoorControl/pQuadCoorControl.C*/
+
+cellShapeControl/cellAspectRatioControl/cellAspectRatioControl.C
+
+cellShapeControl/smoothAlignmentSolver/smoothAlignmentSolver.C
+
+cellShapeControl/controlMeshRefinement/controlMeshRefinement.C
+
+/*cellSizeControlSurfaces/cellSizeControlSurfaces.C*/
+
+cellSizeFunctions = cellSizeControlSurfaces/cellSizeFunction
+$(cellSizeFunctions)/cellSizeFunction/cellSizeFunction.C
+$(cellSizeFunctions)/uniform/uniform.C
+$(cellSizeFunctions)/uniformDistance/uniformDistance.C
+$(cellSizeFunctions)/linearDistance/linearDistance.C
+$(cellSizeFunctions)/surfaceOffsetLinearDistance/surfaceOffsetLinearDistance.C
+$(cellSizeFunctions)/linearSpatial/linearSpatial.C
+
+surfaceCellSizeFunctions = cellSizeControlSurfaces/surfaceCellSizeFunction
+$(surfaceCellSizeFunctions)/surfaceCellSizeFunction/surfaceCellSizeFunction.C
+$(surfaceCellSizeFunctions)/uniformValue/uniformValue.C
+$(surfaceCellSizeFunctions)/nonUniformField/nonUniformField.C
+
+cellSizeCalculationType = $(surfaceCellSizeFunctions)/cellSizeCalculationType
+$(cellSizeCalculationType)/cellSizeCalculationType/cellSizeCalculationType.C
+$(cellSizeCalculationType)/fieldFromFile/fieldFromFile.C
+$(cellSizeCalculationType)/automatic/automatic.C
+
+initialPointsMethod/initialPointsMethod/initialPointsMethod.C
+initialPointsMethod/uniformGrid/uniformGrid.C
+initialPointsMethod/bodyCentredCubic/bodyCentredCubic.C
+initialPointsMethod/faceCentredCubic/faceCentredCubic.C
+initialPointsMethod/pointFile/pointFile.C
+initialPointsMethod/autoDensity/autoDensity.C
+initialPointsMethod/rayShooting/rayShooting.C
+
+relaxationModel/relaxationModel/relaxationModel.C
+relaxationModel/adaptiveLinear/adaptiveLinear.C
+relaxationModel/rampHoldFall/rampHoldFall.C
+
+faceAreaWeightModel/faceAreaWeightModel/faceAreaWeightModel.C
+faceAreaWeightModel/piecewiseLinearRamp/piecewiseLinearRamp.C
+
+searchableSurfaceFeatures/searchableSurfaceFeatures.C
+searchableSurfaceFeatures/searchableBoxFeatures.C
+searchableSurfaceFeatures/searchablePlateFeatures.C
+searchableSurfaceFeatures/triSurfaceMeshFeatures.C
+
+LIB = $(FOAM_LIBBIN)/libconformalVoronoiMesh

applications/utilities/mesh/generation/foamyHexMesh/conformalVoronoiMesh/Make/options

@@ -0,0 +1,40 @@
+EXE_DEBUG = -DFULLDEBUG -g -O0
+EXE_FROUNDING_MATH = -frounding-math
+EXE_NDEBUG = -DNDEBUG
+
+CGAL_EXACT = /*-DCGAL_DONT_USE_LAZY_KERNEL*/
+CGAL_INEXACT = -DCGAL_INEXACT
+
+include $(GENERAL_RULES)/CGAL
+
+EXE_INC = \
+    ${EXE_FROUNDING_MATH} \
+    ${EXE_NDEBUG} \
+    ${CGAL_EXACT} \
+    ${CGAL_INEXACT} \
+    ${CGAL_INC} \
+    ${c++CGALWARN} \
+    -I$(LIB_SRC)/finiteVolume/lnInclude \
+    -I$(LIB_SRC)/meshTools/lnInclude \
+    -I$(LIB_SRC)/parallel/decompose/decompositionMethods/lnInclude \
+    -I$(LIB_SRC)/edgeMesh/lnInclude \
+    -I$(LIB_SRC)/fileFormats/lnInclude \
+    -I$(LIB_SRC)/dynamicMesh/lnInclude \
+    -I$(LIB_SRC)/surfMesh/lnInclude \
+    -I$(LIB_SRC)/triSurface/lnInclude \
+    -I$(LIB_SRC)/sampling/lnInclude \
+    -I$(LIB_SRC)/mesh/autoMesh/lnInclude \
+    -IPrintTable \
+    -I../vectorTools \
+    -I/usr/include
+
+LIB_LIBS = \
+    ${CGAL_LIBS} \
+    -lmeshTools \
+    -ledgeMesh \
+    -lfileFormats \
+    -ltriSurface \
+    -ldynamicMesh \
+    -lsurfMesh \
+    -lsampling \
+    -lautoMesh

applications/utilities/mesh/generation/foamyHexMesh/conformalVoronoiMesh/PrintTable/PrintTable.C

@@ -0,0 +1,235 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012-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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "PrintTable.H"
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+template<class KeyType, class DataType>
+Foam::PrintTable<KeyType, DataType>::PrintTable()
+:
+    table_(),
+    title_(string::null)
+{}
+
+
+template<class KeyType, class DataType>
+Foam::PrintTable<KeyType, DataType>::PrintTable(const string& title)
+:
+    table_(),
+    title_(title)
+{}
+
+
+template<class KeyType, class DataType>
+Foam::PrintTable<KeyType, DataType>::PrintTable
+(
+    const PrintTable<KeyType, DataType>& table
+)
+:
+    table_(table.table_),
+    title_(table.title_)
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+template<class KeyType, class DataType>
+Foam::PrintTable<KeyType, DataType>::~PrintTable()
+{}
+
+
+// * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
+
+template<class KeyType, class DataType>
+void Foam::PrintTable<KeyType, DataType>::print
+(
+    Ostream& os,
+    const bool printSum,
+    const bool printAverage
+) const
+{
+    HashTable<HashTable<DataType, label>, KeyType> combinedTable;
+
+    List<HashTableData> procData(Pstream::nProcs(), HashTableData());
+
+    procData[Pstream::myProcNo()] = table_;
+
+    Pstream::gatherList(procData);
+
+    if (Pstream::master())
+    {
+        label largestKeyLength = 6;
+        label largestDataLength = 0;
+
+        List<label> largestProcSize(Pstream::nProcs(), 0);
+
+        forAll(procData, procI)
+        {
+            const HashTableData& procIData = procData[procI];
+
+            for
+            (
+                typename HashTableData::const_iterator iter = procIData.begin();
+                iter != procIData.end();
+                ++iter
+            )
+            {
+                if (!combinedTable.found(iter.key()))
+                {
+                    combinedTable.insert
+                    (
+                        iter.key(),
+                        HashTable<DataType, label>()
+                    );
+                }
+
+                HashTable<DataType, label>& key = combinedTable[iter.key()];
+
+                key.insert(procI, iter());
+
+                for
+                (
+                    typename HashTable<DataType, label>
+                        ::const_iterator dataIter = key.begin();
+                    dataIter != key.end();
+                    ++dataIter
+                )
+                {
+                    std::ostringstream buf;
+                    buf << dataIter();
+
+                    largestDataLength = max
+                    (
+                        largestDataLength,
+                        label(buf.str().length())
+                    );
+                }
+
+                std::ostringstream buf;
+                buf << iter.key();
+
+                largestKeyLength = max
+                (
+                    largestKeyLength,
+                    label(buf.str().length())
+                );
+            }
+        }
+
+        os.width(largestKeyLength);
+        os  << nl << indent << tab << "# " << title_.c_str() << endl;
+
+        os.width(largestKeyLength);
+        os  << indent << "# Proc";
+
+        forAll(procData, procI)
+        {
+            os  << tab;
+            os.width(largestDataLength);
+            os  << procI;
+        }
+
+        if (printSum)
+        {
+            os  << tab;
+            os.width(largestDataLength);
+            os  << "Sum";
+        }
+
+        if (printAverage)
+        {
+            os  << tab;
+            os.width(largestDataLength);
+            os  << "Average";
+        }
+
+        os  << endl;
+
+        const List<KeyType>& sortedTable = combinedTable.sortedToc();
+
+        forAll(sortedTable, keyI)
+        {
+            const HashTable<DataType, label>& procDataList
+                = combinedTable[sortedTable[keyI]];
+
+            os.width(largestKeyLength);
+            os  << indent << sortedTable[keyI];
+
+            forAll(procDataList, elemI)
+            {
+                os  << tab;
+                os.width(largestDataLength);
+                os  << procDataList[elemI];
+            }
+
+            if (printSum)
+            {
+                DataType sum = 0;
+                forAll(procDataList, elemI)
+                {
+                    sum += procDataList[elemI];
+                }
+
+                os  << tab;
+                os.width(largestDataLength);
+                os  << sum;
+
+                if (printAverage)
+                {
+                    os  << tab;
+                    os.width(largestDataLength);
+                    os  << sum/Pstream::nProcs();
+                }
+            }
+
+            os  << endl;
+        }
+    }
+}
+
+
+// * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * * //
+
+template<class KeyType, class DataType>
+void Foam::PrintTable<KeyType, DataType>::operator=
+(
+    const PrintTable<KeyType, DataType>& rhs
+)
+{
+    // Check for assignment to self
+    if (this == &rhs)
+    {
+        FatalErrorIn
+        (
+            "Foam::PrintTable<KeyType, DataType>::operator="
+            "(const Foam::PrintTable<KeyType, DataType>&)"
+        )   << "Attempted assignment to self"
+            << abort(FatalError);
+    }
+}
+
+
+// ************************************************************************* //

applications/utilities/mesh/generation/foamyHexMesh/conformalVoronoiMesh/PrintTable/PrintTable.H

@@ -0,0 +1,140 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012-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/>.
+
+Class
+    Foam::PrintTable
+
+Description
+    Print a table in parallel, e.g.;
+
+    \verbatim
+                            Vertex Type Information
+                   Proc #        0       1       2       3
+                    Total   145680  145278  145751  145359
+               Unassigned        0       0       0       0
+     nExternalFeatureEdge      883     829     828     960
+    nExternalFeaturePoint        8      10      10      12
+         nExternalSurface     9533    9488    9502    9482
+                     nFar        0       0       0       0
+                nInternal   125494  125198  125642  125174
+     nInternalFeatureEdge      238     241     241     240
+    nInternalFeaturePoint        2       2       2       2
+    nInternalNearBoundary        0       0       0       0
+         nInternalSurface     9522    9510    9526    9489
+                nReferred     7545    7497    7500    7587
+    \endverbatim
+
+SourceFiles
+    PrintTableI.H
+    PrintTable.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef PrintTable_H
+#define PrintTable_H
+
+#include "HashTable.H"
+#include "Ostream.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                         Class PrintTable Declaration
+\*---------------------------------------------------------------------------*/
+
+template<class KeyType, class DataType>
+class PrintTable
+{
+    typedef HashTable<DataType, KeyType> HashTableData;
+
+
+    // Private data
+
+        //- Hash table holding the data
+        HashTableData table_;
+
+        //- Title of the table
+        string title_;
+
+
+    // Private Member Functions
+
+        //- Disallow default bitwise assignment
+        void operator=(const PrintTable<KeyType, DataType>&);
+
+
+public:
+
+    // Constructors
+
+        //- Null constructor
+        PrintTable();
+
+        //- Construct with a title
+        explicit PrintTable(const string& title);
+
+        //- Copy constructor
+        PrintTable(const PrintTable<KeyType, DataType>& table);
+
+
+    //- Destructor
+    ~PrintTable();
+
+
+    // Member Functions
+
+        //- Add an entry (D) to the given key(K)
+        void add(const KeyType& K, const DataType& D);
+
+        //- Print the table
+        void print
+        (
+            Ostream& os,
+            const bool printSum = false,
+            const bool printAverage = false
+        ) const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#include "PrintTableI.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+#   include "PrintTable.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

applications/utilities/mesh/generation/foamyHexMesh/conformalVoronoiMesh/PrintTable/PrintTableI.H

@@ -0,0 +1,42 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012-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/>.
+
+\*---------------------------------------------------------------------------*/
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+template<class KeyType, class DataType>
+void Foam::PrintTable<KeyType, DataType>::add
+(
+    const KeyType& K,
+    const DataType& D
+)
+{
+    table_.set(K, D);
+}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+
+// ************************************************************************* //

applications/utilities/mesh/generation/foamyHexMesh/conformalVoronoiMesh/backgroundMeshDecomposition/backgroundMeshDecomposition.H

@@ -0,0 +1,348 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  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/>.
+
+Class
+    Foam::backgroundMeshDecomposition
+
+Description
+    Store a background polyMesh to use for the decomposition of space and
+    queries for parallel conformalVoronoiMesh.
+
+    The requirements are:
+
+    + To have a decomposition of space which can quickly interrogate an
+      arbitrary location from any processor to reliably and unambiguously
+      determine which processor owns the space that the point is in, i.e. as
+      the vertices move, or need inserted as part of the surface conformation,
+      send them to the correct proc.
+
+    + To be able to be dynamically built, refined and redistributed to other
+      procs the partitioning as the meshing progresses to balance the load.
+
+    + To be able to query whether a sphere (the circumsphere of a Delaunay tet)
+      overlaps any part of the space defined by the structure, and whether a
+      ray (Voronoi edge) penetrates any part of the space defined by the
+      structure, this is what determines if points get referred to a processor.
+
+SourceFiles
+    backgroundMeshDecompositionI.H
+    backgroundMeshDecomposition.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef backgroundMeshDecomposition_H
+#define backgroundMeshDecomposition_H
+
+#include "fvMesh.H"
+#include "hexRef8.H"
+#include "cellSet.H"
+#include "meshTools.H"
+#include "polyTopoChange.H"
+#include "mapPolyMesh.H"
+#include "decompositionMethod.H"
+#include "fvMeshDistribute.H"
+#include "removeCells.H"
+#include "mapDistributePolyMesh.H"
+#include "globalIndex.H"
+#include "treeBoundBox.H"
+#include "primitivePatch.H"
+#include "face.H"
+#include "labelList.H"
+#include "pointField.H"
+#include "indexedOctree.H"
+#include "treeDataPrimitivePatch.H"
+#include "volumeType.H"
+#include "CGALTriangulation3Ddefs.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+typedef PrimitivePatch<face, List, const pointField, point> bPatch;
+typedef treeDataPrimitivePatch<bPatch> treeDataBPatch;
+
+class Time;
+class Random;
+class conformationSurfaces;
+
+/*---------------------------------------------------------------------------*\
+                  Class backgroundMeshDecomposition Declaration
+\*---------------------------------------------------------------------------*/
+
+class backgroundMeshDecomposition
+{
+    // Private data
+
+        //- Method details dictionary
+        //dictionary coeffsDict_;
+
+        //- Reference to runtime
+        const Time& runTime_;
+
+        //- Reference to surface
+        const conformationSurfaces& geometryToConformTo_;
+
+        //- Random number generator
+        Random& rndGen_;
+
+        //- Mesh stored on for this processor, specifiying the domain that it
+        //  is responsible for.
+        fvMesh mesh_;
+
+        //- Refinement object
+        hexRef8 meshCutter_;
+
+        //- Patch containing an independent representation of the surface of the
+        //  mesh of this processor
+        autoPtr<bPatch> boundaryFacesPtr_;
+
+        //- Search tree for the boundaryFaces_ patch
+        autoPtr<indexedOctree<treeDataBPatch> > bFTreePtr_;
+
+        //- The bounds of all background meshes on all processors
+        treeBoundBoxList allBackgroundMeshBounds_;
+
+        //- The overall bounds of all of the background meshes, used to test if
+        //  a point that is not found on any processor is in the domain at all
+        treeBoundBox globalBackgroundBounds_;
+
+        //- Decomposition dictionary
+        IOdictionary decomposeDict_;
+
+        //- Decomposition method
+        autoPtr<decompositionMethod> decomposerPtr_;
+
+        //- merge distance required by fvMeshDistribute
+        scalar mergeDist_;
+
+        //- Scale of a cell span vs cell size used to decide to refine a cell
+        scalar spanScale_;
+
+        //- Smallest minimum cell size allowed, i.e. to avoid high initial
+        //  refinement of areas of small size
+        scalar minCellSizeLimit_;
+
+        //- Minimum normal level of refinement
+        label minLevels_;
+
+        //- How fine should the initial sample of the volume a box be to
+        //  investigate the local cell size
+        label volRes_;
+
+        //- Allowed factor above the average cell weight before a background
+        //  cell needs to be split
+        scalar maxCellWeightCoeff_;
+
+
+    // Private Member Functions
+
+        void initialRefinement();
+
+        //- Print details of the decomposed mesh
+        void printMeshData(const polyMesh& mesh) const;
+
+        //- Estimate the number of vertices that will be in this cell, returns
+        //  true if the cell is to be split because of the density ratio inside
+        //  it
+        bool refineCell
+        (
+            label cellI,
+            volumeType volType,
+            scalar& weightEstimate
+        ) const;
+
+        //- Select cells for refinement at the surface of the geometry to be
+        //  meshed
+        labelList selectRefinementCells
+        (
+            List<volumeType>& volumeStatus,
+            volScalarField& cellWeights
+        ) const;
+
+        //- Build the surface patch and search tree
+        void buildPatchAndTree();
+
+        //- Disallow default bitwise copy construct
+        backgroundMeshDecomposition(const backgroundMeshDecomposition&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const backgroundMeshDecomposition&);
+
+
+public:
+
+    //- Runtime type information
+    ClassName("backgroundMeshDecomposition");
+
+
+    // Constructors
+
+        //- Construct from components in foamyHexMesh operation
+        backgroundMeshDecomposition
+        (
+            const Time& runTime,
+            Random& rndGen,
+            const conformationSurfaces& geometryToConformTo,
+            const dictionary& coeffsDict
+        );
+
+
+    //- Destructor
+    ~backgroundMeshDecomposition();
+
+
+    // Member Functions
+
+        //- Build a mapDistribute for the supplied destination processor data
+        static autoPtr<mapDistribute> buildMap(const List<label>& toProc);
+
+        //- Redistribute the background mesh based on a supplied weight field,
+        //  returning a map to use to redistribute vertices.
+        autoPtr<mapDistributePolyMesh> distribute
+        (
+            volScalarField& cellWeights
+        );
+
+        //- Distribute supplied the points to the appropriate processor
+        template<typename PointType>
+        autoPtr<mapDistribute> distributePoints(List<PointType>& points) const;
+
+        //- Is the given position inside the domain of this decomposition
+        bool positionOnThisProcessor(const point& pt) const;
+
+        //- Are the given positions inside the domain of this decomposition
+        boolList positionOnThisProcessor(const List<point>& pts) const;
+
+        //- Does the given box overlap the faces of the boundary of this
+        //  processor
+        bool overlapsThisProcessor(const treeBoundBox& box) const;
+
+        //- Does the given sphere overlap the faces of the boundary of this
+        //  processor
+        bool overlapsThisProcessor
+        (
+            const point& centre,
+            const scalar radiusSqr
+        ) const;
+
+        //- Find nearest intersection of line between start and end, (exposing
+        //  underlying indexedOctree)
+        pointIndexHit findLine
+        (
+            const point& start,
+            const point& end
+        ) const;
+
+        //- Find any intersection of line between start and end, (exposing
+        //  underlying indexedOctree)
+        pointIndexHit findLineAny
+        (
+            const point& start,
+            const point& end
+        ) const;
+
+        //- What processor is the given position on?
+        template<typename PointType>
+        labelList processorPosition(const List<PointType>& pts) const;
+
+        //- What is the nearest processor to the given position?
+        labelList processorNearestPosition(const List<point>& pts) const;
+
+        //- Which processors are intersected by the line segment, returns all
+        //  processors whose boundary patch is intersected by the sphere.  By
+        //  default this does not return the processor that the query is
+        //  launched from, it is assumed that the point is on that processor.
+        //  The index data member of the pointIndexHit is replaced with the
+        //  processor index.
+        List<List<pointIndexHit> > intersectsProcessors
+        (
+            const List<point>& starts,
+            const List<point>& ends,
+            bool includeOwnProcessor = false
+        ) const;
+
+        bool overlapsOtherProcessors
+        (
+            const point& centre,
+            const scalar& radiusSqr
+        ) const;
+
+        labelList overlapProcessors
+        (
+            const point& centre,
+            const scalar radiusSqr
+        ) const;
+
+//        //- Which processors overlap the given sphere, returns all processors
+//        //  whose boundary patch is touched by the sphere or whom the sphere
+//        //  is inside.  By default this does not return the processor that the
+//        //  query is launched from, it is assumed that the point is on that
+//        //  processor.
+//        labelListList overlapsProcessors
+//        (
+//            const List<point>& centres,
+//            const List<scalar>& radiusSqrs,
+//            const Delaunay& T,
+//            bool includeOwnProcessor
+//        ) const;
+
+        // Access
+
+            //- Return access to the underlying mesh
+            inline const fvMesh& mesh() const;
+
+            //- Return access to the underlying tree
+            inline const indexedOctree<treeDataBPatch>& tree() const;
+
+            //- Return the boundBox of this processor
+            inline const treeBoundBox& procBounds() const;
+
+            //- Return the cell level of the underlying mesh
+            inline const labelList& cellLevel() const;
+
+            //- Return the point level of the underlying mesh
+            inline const labelList& pointLevel() const;
+
+            //- Return the current decomposition method
+            inline const decompositionMethod& decomposer() const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#include "backgroundMeshDecompositionI.H"
+
+#ifdef NoRepository
+#   include "backgroundMeshDecompositionTemplates.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

applications/utilities/mesh/generation/foamyHexMesh/conformalVoronoiMesh/backgroundMeshDecomposition/backgroundMeshDecompositionI.H

@@ -0,0 +1,67 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  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/>.
+
+\*---------------------------------------------------------------------------*/
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+const Foam::fvMesh& Foam::backgroundMeshDecomposition::mesh() const
+{
+    return mesh_;
+}
+
+
+const Foam::indexedOctree<Foam::treeDataBPatch>&
+Foam::backgroundMeshDecomposition::tree() const
+{
+    return bFTreePtr_();
+}
+
+
+const Foam::treeBoundBox&
+Foam::backgroundMeshDecomposition::procBounds() const
+{
+    return allBackgroundMeshBounds_[Pstream::myProcNo()];
+}
+
+
+const Foam::labelList& Foam::backgroundMeshDecomposition::cellLevel() const
+{
+    return meshCutter_.cellLevel();
+}
+
+
+const Foam::labelList& Foam::backgroundMeshDecomposition::pointLevel() const
+{
+    return meshCutter_.pointLevel();
+}
+
+
+const Foam::decompositionMethod&
+Foam::backgroundMeshDecomposition::decomposer() const
+{
+    return decomposerPtr_();
+}
+
+
+// ************************************************************************* //

applications/utilities/mesh/generation/foamyHexMesh/conformalVoronoiMesh/backgroundMeshDecomposition/backgroundMeshDecompositionTemplates.C

@@ -0,0 +1,186 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "backgroundMeshDecomposition.H"
+#include "pointConversion.H"
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+template<typename PointType>
+Foam::autoPtr<Foam::mapDistribute>
+Foam::backgroundMeshDecomposition::distributePoints
+(
+    List<PointType>& points
+) const
+{
+    labelList toProc(processorPosition(points));
+
+    autoPtr<mapDistribute> map(buildMap(toProc));
+
+    map().distribute(points);
+
+    return map;
+}
+
+
+template<typename PointType>
+Foam::labelList Foam::backgroundMeshDecomposition::processorPosition
+(
+    const List<PointType>& pts
+) const
+{
+    DynamicList<label> toCandidateProc;
+    DynamicList<point> testPoints;
+    labelList ptBlockStart(pts.size(), -1);
+    labelList ptBlockSize(pts.size(), -1);
+
+    label nTotalCandidates = 0;
+
+    forAll(pts, pI)
+    {
+        const pointFromPoint pt = topoint(pts[pI]);
+
+        label nCandidates = 0;
+
+        forAll(allBackgroundMeshBounds_, procI)
+        {
+            if (allBackgroundMeshBounds_[procI].contains(pt))
+            {
+                toCandidateProc.append(procI);
+                testPoints.append(pt);
+
+                nCandidates++;
+            }
+        }
+
+        ptBlockStart[pI] = nTotalCandidates;
+        ptBlockSize[pI] = nCandidates;
+
+        nTotalCandidates += nCandidates;
+    }
+
+    // Needed for reverseDistribute
+    label preDistributionToCandidateProcSize = toCandidateProc.size();
+
+    autoPtr<mapDistribute> map(buildMap(toCandidateProc));
+
+    map().distribute(testPoints);
+
+    List<bool> pointOnCandidate(testPoints.size(), false);
+
+    // Test candidate points on candidate processors
+    forAll(testPoints, tPI)
+    {
+        pointOnCandidate[tPI] = positionOnThisProcessor(testPoints[tPI]);
+    }
+
+    map().reverseDistribute
+    (
+        preDistributionToCandidateProcSize,
+        pointOnCandidate
+    );
+
+    labelList ptProc(pts.size(), -1);
+
+    DynamicList<label> failedPointIndices;
+    DynamicList<point> failedPoints;
+
+    forAll(pts, pI)
+    {
+        // Extract the sub list of results for this point
+
+        SubList<bool> ptProcResults
+        (
+            pointOnCandidate,
+            ptBlockSize[pI],
+            ptBlockStart[pI]
+        );
+
+        forAll(ptProcResults, pPRI)
+        {
+            if (ptProcResults[pPRI])
+            {
+                ptProc[pI] = toCandidateProc[ptBlockStart[pI] + pPRI];
+
+                break;
+            }
+        }
+
+        if (ptProc[pI] < 0)
+        {
+            const pointFromPoint pt = topoint(pts[pI]);
+
+            if (!globalBackgroundBounds_.contains(pt))
+            {
+                FatalErrorIn
+                (
+                    "Foam::labelList"
+                    "Foam::backgroundMeshDecomposition::processorPosition"
+                    "("
+                        "const List<point>&"
+                    ") const"
+                )
+                    << "The position " << pt
+                    << " is not in any part of the background mesh "
+                    << globalBackgroundBounds_ << endl
+                    << "A background mesh with a wider margin around "
+                    << "the geometry may help."
+                    << exit(FatalError);
+            }
+
+            if (debug)
+            {
+                WarningIn
+                (
+                    "Foam::labelList"
+                    "Foam::backgroundMeshDecomposition::processorPosition"
+                    "("
+                        "const List<point>&"
+                    ") const"
+                )   << "The position " << pt
+                    << " was not found in the background mesh "
+                    << globalBackgroundBounds_ << ", finding nearest."
+                    << endl;
+            }
+
+            failedPointIndices.append(pI);
+            failedPoints.append(pt);
+        }
+    }
+
+    labelList ptNearestProc(processorNearestPosition(failedPoints));
+
+    forAll(failedPoints, fPI)
+    {
+        label pI = failedPointIndices[fPI];
+
+        ptProc[pI] = ptNearestProc[fPI];
+    }
+
+    return ptProc;
+}
+
+
+// ************************************************************************* //

applications/utilities/mesh/generation/foamyHexMesh/conformalVoronoiMesh/cellShapeControl/cellAspectRatioControl/cellAspectRatioControl.C

@@ -0,0 +1,112 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012-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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "cellAspectRatioControl.H"
+#include "vectorTools.H"
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::cellAspectRatioControl::cellAspectRatioControl
+(
+    const dictionary& motionDict
+)
+:
+    aspectRatioDict_(motionDict.subOrEmptyDict("cellAspectRatioControl")),
+    aspectRatio_(aspectRatioDict_.lookupOrDefault<scalar>("aspectRatio", 1.0)),
+    aspectRatioDirection_
+    (
+        aspectRatioDict_.lookupOrDefault<vector>
+        (
+            "aspectRatioDirection",
+            vector::zero
+        )
+    )
+{
+    // Normalise the direction
+    aspectRatioDirection_ /= mag(aspectRatioDirection_) + SMALL;
+
+    Info<< nl
+        << "Cell Aspect Ratio Control" << nl
+        << "    Ratio     : " << aspectRatio_ << nl
+        << "    Direction : " << aspectRatioDirection_
+        << endl;
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::cellAspectRatioControl::~cellAspectRatioControl()
+{}
+
+
+// * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
+
+void Foam::cellAspectRatioControl::updateCellSizeAndFaceArea
+(
+    vector& alignmentDir,
+    scalar& targetFaceArea,
+    scalar& targetCellSize
+) const
+{
+    const scalar cosAngle =
+        mag(vectorTools::cosPhi(alignmentDir, aspectRatioDirection_));
+
+    // Change target face area based on aspect ratio
+    targetFaceArea +=
+        targetFaceArea
+       *(aspectRatio_ - 1.0)
+       *(1.0 - cosAngle);
+
+    // Change target cell size based on aspect ratio
+    targetCellSize +=
+        targetCellSize
+       *(aspectRatio_ - 1.0)
+       *cosAngle;
+
+    alignmentDir *= 0.5*targetCellSize;
+}
+
+
+void Foam::cellAspectRatioControl::updateDeltaVector
+(
+    const vector& alignmentDir,
+    const scalar targetCellSize,
+    const scalar rABMag,
+    vector& delta
+) const
+{
+    const scalar cosAngle =
+        mag(vectorTools::cosPhi(alignmentDir, aspectRatioDirection_));
+
+    delta +=
+        0.5
+       *delta
+       *cosAngle
+       *(targetCellSize/rABMag)
+       *(aspectRatio_ - 1.0);
+}
+
+
+// ************************************************************************* //

applications/utilities/mesh/generation/foamyHexMesh/conformalVoronoiMesh/cellShapeControl/cellAspectRatioControl/cellAspectRatioControl.H

@@ -0,0 +1,112 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012-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/>.
+
+Class
+    Foam::cellAspectRatioControl
+
+Description
+
+SourceFiles
+    cellAspectRatioControl.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef cellAspectRatioControl_H
+#define cellAspectRatioControl_H
+
+#include "dictionary.H"
+#include "vector.H"
+#include "scalar.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+
+/*---------------------------------------------------------------------------*\
+                     Class cellAspectRatioControl Declaration
+\*---------------------------------------------------------------------------*/
+
+class cellAspectRatioControl
+{
+    // Private data
+
+        const dictionary aspectRatioDict_;
+
+        const scalar aspectRatio_;
+
+        vector aspectRatioDirection_;
+
+
+    // Private Member Functions
+
+        //- Disallow default bitwise copy construct
+        cellAspectRatioControl(const cellAspectRatioControl&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const cellAspectRatioControl&);
+
+
+public:
+
+    // Constructors
+
+        //- Construct from dictionary
+        cellAspectRatioControl(const dictionary& motionDict);
+
+
+    //- Destructor
+    virtual ~cellAspectRatioControl();
+
+
+    // Member Functions
+
+        // Query
+
+            void updateCellSizeAndFaceArea
+            (
+                vector& alignmentDir,
+                scalar& targetFaceArea,
+                scalar& targetCellSize
+            ) const;
+
+            void updateDeltaVector
+            (
+                const vector& alignmentDir,
+                const scalar targetCellSize,
+                const scalar rABMag,
+                vector& delta
+            ) const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

applications/utilities/mesh/generation/foamyHexMesh/conformalVoronoiMesh/cellShapeControl/cellShapeControl/cellShapeControl.C

@@ -0,0 +1,369 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012-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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "cellShapeControl.H"
+#include "pointField.H"
+#include "scalarField.H"
+#include "triadField.H"
+#include "cellSizeAndAlignmentControl.H"
+#include "searchableSurfaceControl.H"
+#include "cellSizeFunction.H"
+#include "indexedVertexOps.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+defineTypeNameAndDebug(cellShapeControl, 0);
+}
+
+
+// * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::cellShapeControl::cellShapeControl
+(
+    const Time& runTime,
+    const cvControls& foamyHexMeshControls,
+    const searchableSurfaces& allGeometry,
+    const conformationSurfaces& geometryToConformTo
+)
+:
+    dictionary
+    (
+        foamyHexMeshControls.foamyHexMeshDict().subDict("motionControl")
+    ),
+    runTime_(runTime),
+    allGeometry_(allGeometry),
+    geometryToConformTo_(geometryToConformTo),
+    defaultCellSize_(foamyHexMeshControls.defaultCellSize()),
+    minimumCellSize_(foamyHexMeshControls.minimumCellSize()),
+    shapeControlMesh_(runTime),
+    aspectRatio_(*this),
+    sizeAndAlignment_
+    (
+        runTime,
+        subDict("shapeControlFunctions"),
+        geometryToConformTo_,
+        defaultCellSize_
+    )
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::cellShapeControl::~cellShapeControl()
+{}
+
+
+// * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
+
+Foam::scalarField Foam::cellShapeControl::cellSize
+(
+    const pointField& pts
+) const
+{
+    scalarField cellSizes(pts.size());
+
+    forAll(pts, i)
+    {
+        cellSizes[i] = cellSize(pts[i]);
+    }
+
+    return cellSizes;
+}
+
+
+Foam::scalar Foam::cellShapeControl::cellSize(const point& pt) const
+{
+    scalarList bary;
+    cellShapeControlMesh::Cell_handle ch;
+
+    shapeControlMesh_.barycentricCoords(pt, bary, ch);
+
+    scalar size = 0;
+
+    if (shapeControlMesh_.dimension() < 3)
+    {
+        size = sizeAndAlignment_.cellSize(pt);
+    }
+    else if (shapeControlMesh_.is_infinite(ch))
+    {
+//        if (nFarPoints != 0)
+//        {
+//            for (label pI = 0; pI < 4; ++pI)
+//            {
+//                if (!ch->vertex(pI)->farPoint())
+//                {
+//                    size = ch->vertex(pI)->targetCellSize();
+//                    return size;
+//                }
+//            }
+//        }
+
+//        cellShapeControlMesh::Vertex_handle nearV =
+//            shapeControlMesh_.nearest_vertex_in_cell
+//            (
+//                toPoint<cellShapeControlMesh::Point>(pt),
+//                ch
+//            );
+//
+//        size = nearV->targetCellSize();
+
+        // Find nearest surface. This can be quite slow if there are a lot of
+        // surfaces
+        size = sizeAndAlignment_.cellSize(pt);
+    }
+    else
+    {
+        label nFarPoints = 0;
+        for (label pI = 0; pI < 4; ++pI)
+        {
+            if (ch->vertex(pI)->farPoint())
+            {
+                nFarPoints++;
+            }
+        }
+
+        if (nFarPoints != 0)
+        {
+            for (label pI = 0; pI < 4; ++pI)
+            {
+                if (!CGAL::indexedVertexOps::uninitialised(ch->vertex(pI)))
+                {
+                    size = ch->vertex(pI)->targetCellSize();
+                    return size;
+                }
+            }
+        }
+        else
+        {
+            forAll(bary, pI)
+            {
+                size += bary[pI]*ch->vertex(pI)->targetCellSize();
+            }
+        }
+    }
+
+    return size;
+}
+
+
+//- Return the cell alignment at the given location
+Foam::tensor Foam::cellShapeControl::cellAlignment(const point& pt) const
+{
+    scalarList bary;
+    cellShapeControlMesh::Cell_handle ch;
+
+    shapeControlMesh_.barycentricCoords(pt, bary, ch);
+
+    tensor alignment = tensor::zero;
+
+    if (shapeControlMesh_.dimension() < 3 || shapeControlMesh_.is_infinite(ch))
+    {
+        alignment = tensor::I;
+    }
+    else
+    {
+        label nFarPoints = 0;
+        for (label pI = 0; pI < 4; ++pI)
+        {
+            if (ch->vertex(pI)->farPoint())
+            {
+                nFarPoints++;
+            }
+        }
+
+//        if (nFarPoints != 0)
+//        {
+//            for (label pI = 0; pI < 4; ++pI)
+//            {
+//                if (!ch->vertex(pI)->farPoint())
+//                {
+//                    alignment = ch->vertex(pI)->alignment();
+//                }
+//            }
+//        }
+//        else
+        {
+            triad tri;
+
+            for (label pI = 0; pI < 4; ++pI)
+            {
+                if (bary[pI] > SMALL)
+                {
+                    tri += triad(bary[pI]*ch->vertex(pI)->alignment());
+                }
+            }
+
+            tri.normalize();
+            tri.orthogonalize();
+            tri = tri.sortxyz();
+
+            alignment = tri;
+        }
+
+//        cellShapeControlMesh::Vertex_handle nearV =
+//            shapeControlMesh_.nearest_vertex_in_cell
+//            (
+//                toPoint<cellShapeControlMesh::Point>(pt),
+//                ch
+//            );
+//
+//        alignment = nearV->alignment();
+    }
+
+    return alignment;
+}
+
+
+void Foam::cellShapeControl::cellSizeAndAlignment
+(
+    const point& pt,
+    scalar& size,
+    tensor& alignment
+) const
+{
+    scalarList bary;
+    cellShapeControlMesh::Cell_handle ch;
+
+    shapeControlMesh_.barycentricCoords(pt, bary, ch);
+
+    alignment = tensor::zero;
+    size = 0;
+
+    if (shapeControlMesh_.dimension() < 3 || shapeControlMesh_.is_infinite(ch))
+    {
+        // Find nearest surface
+        size = sizeAndAlignment_.cellSize(pt);
+        alignment = tensor::I;
+    }
+    else
+    {
+        label nFarPoints = 0;
+        for (label pI = 0; pI < 4; ++pI)
+        {
+            if (ch->vertex(pI)->farPoint())
+            {
+                nFarPoints++;
+            }
+        }
+
+        if (nFarPoints != 0)
+        {
+            for (label pI = 0; pI < 4; ++pI)
+            {
+                if (!CGAL::indexedVertexOps::uninitialised(ch->vertex(pI)))
+                {
+                    size = ch->vertex(pI)->targetCellSize();
+                    alignment = ch->vertex(pI)->alignment();
+                }
+            }
+        }
+        else
+        {
+            triad tri;
+
+            for (label pI = 0; pI < 4; ++pI)
+            {
+                size += bary[pI]*ch->vertex(pI)->targetCellSize();
+
+                if (bary[pI] > SMALL)
+                {
+                    tri += triad(bary[pI]*ch->vertex(pI)->alignment());
+                }
+            }
+
+            tri.normalize();
+            tri.orthogonalize();
+            tri = tri.sortxyz();
+
+            alignment = tri;
+
+//            cellShapeControlMesh::Vertex_handle nearV =
+//                shapeControlMesh_.nearest_vertex
+//                (
+//                    toPoint<cellShapeControlMesh::Point>(pt)
+//                );
+//
+//            alignment = nearV->alignment();
+        }
+    }
+
+    for (label dir = 0; dir < 3; dir++)
+    {
+        triad v = alignment;
+
+        if (!v.set(dir) || size == 0)
+        {
+            // Force orthogonalization of triad.
+
+            scalar dotProd = GREAT;
+            if (dir == 0)
+            {
+                dotProd = v[1] & v[2];
+
+                v[dir] = v[1] ^ v[2];
+            }
+            if (dir == 1)
+            {
+                dotProd = v[0] & v[2];
+
+                v[dir] = v[0] ^ v[2];
+            }
+            if (dir == 2)
+            {
+                dotProd = v[0] & v[1];
+
+                v[dir] = v[0] ^ v[1];
+            }
+
+            v.normalize();
+            v.orthogonalize();
+
+            Pout<< "Dot prod = " << dotProd << endl;
+            Pout<< "Alignment = " << v << endl;
+
+            alignment = v;
+
+//            FatalErrorIn
+//            (
+//                "Foam::conformalVoronoiMesh::setVertexSizeAndAlignment()"
+//            )   << "Point has bad alignment! "
+//                << pt << " " << size << " " << alignment << nl
+//                << "Bary Coords = " << bary <<  nl
+//                << ch->vertex(0)->info() << nl
+//                << ch->vertex(1)->info() << nl
+//                << ch->vertex(2)->info() << nl
+//                << ch->vertex(3)->info()
+//                << abort(FatalError);
+        }
+    }
+}
+
+
+// ************************************************************************* //

applications/utilities/mesh/generation/foamyHexMesh/conformalVoronoiMesh/cellShapeControl/cellShapeControl/cellShapeControl.H

@@ -0,0 +1,166 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012-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/>.
+
+Class
+    Foam::cellShapeControl
+
+Description
+
+SourceFiles
+    cellShapeControlI.H
+    cellShapeControl.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef cellShapeControl_H
+#define cellShapeControl_H
+
+#include "dictionary.H"
+#include "autoPtr.H"
+#include "tensor.H"
+#include "point.H"
+#include "primitiveFieldsFwd.H"
+#include "pointFieldFwd.H"
+#include "Time.H"
+#include "searchableSurfaces.H"
+#include "conformationSurfaces.H"
+#include "cellAspectRatioControl.H"
+#include "cellSizeAndAlignmentControls.H"
+#include "cellShapeControlMesh.H"
+#include "backgroundMeshDecomposition.H"
+#include "cvControls.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+
+/*---------------------------------------------------------------------------*\
+                     Class cellShapeControl Declaration
+\*---------------------------------------------------------------------------*/
+
+class cellShapeControl
+:
+    public dictionary
+{
+    // Private data
+
+        const Time& runTime_;
+
+        const searchableSurfaces& allGeometry_;
+
+        const conformationSurfaces& geometryToConformTo_;
+
+        const scalar defaultCellSize_;
+
+        const scalar minimumCellSize_;
+
+        cellShapeControlMesh shapeControlMesh_;
+
+        cellAspectRatioControl aspectRatio_;
+
+        cellSizeAndAlignmentControls sizeAndAlignment_;
+
+
+    // Private Member Functions
+
+        //- Disallow default bitwise copy construct
+        cellShapeControl(const cellShapeControl&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const cellShapeControl&);
+
+
+public:
+
+    //- Runtime type information
+    ClassName("cellShapeControl");
+
+
+    // Constructors
+
+        //- Construct from dictionary and references to conformalVoronoiMesh and
+        //  searchableSurfaces
+        cellShapeControl
+        (
+            const Time& runTime,
+            const cvControls& foamyHexMeshControls,
+            const searchableSurfaces& allGeometry,
+            const conformationSurfaces& geometryToConformTo
+        );
+
+
+    //- Destructor
+    ~cellShapeControl();
+
+
+    // Member Functions
+
+        // Access
+
+            inline const scalar& defaultCellSize() const;
+
+            inline cellShapeControlMesh& shapeControlMesh();
+
+            inline const cellShapeControlMesh& shapeControlMesh() const;
+
+            inline const cellAspectRatioControl& aspectRatio() const;
+
+            inline const cellSizeAndAlignmentControls& sizeAndAlignment() const;
+
+            inline const scalar& minimumCellSize() const;
+
+
+        // Query
+
+            //- Return the cell size at the given location
+            scalar cellSize(const point& pt) const;
+
+            scalarField cellSize(const pointField& pts) const;
+
+            //- Return the cell alignment at the given location
+            tensor cellAlignment(const point& pt) const;
+
+            void cellSizeAndAlignment
+            (
+                const point& pt,
+                scalar& size,
+                tensor& alignment
+            ) const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#include "cellShapeControlI.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

applications/utilities/mesh/generation/foamyHexMesh/conformalVoronoiMesh/cellShapeControl/cellShapeControl/cellShapeControlI.H

@@ -0,0 +1,68 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012-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/>.
+
+\*---------------------------------------------------------------------------*/
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+inline Foam::cellShapeControlMesh&
+Foam::cellShapeControl::shapeControlMesh()
+{
+    return shapeControlMesh_;
+}
+
+
+inline const Foam::cellShapeControlMesh&
+Foam::cellShapeControl::shapeControlMesh() const
+{
+    return shapeControlMesh_;
+}
+
+
+inline const Foam::scalar& Foam::cellShapeControl::defaultCellSize() const
+{
+    return defaultCellSize_;
+}
+
+
+inline const Foam::cellAspectRatioControl&
+Foam::cellShapeControl::aspectRatio() const
+{
+    return aspectRatio_;
+}
+
+
+inline const Foam::cellSizeAndAlignmentControls&
+Foam::cellShapeControl::sizeAndAlignment() const
+{
+    return sizeAndAlignment_;
+}
+
+
+inline const Foam::scalar& Foam::cellShapeControl::minimumCellSize() const
+{
+    return minimumCellSize_;
+}
+
+
+// ************************************************************************* //

applications/utilities/mesh/generation/foamyHexMesh/conformalVoronoiMesh/cellShapeControl/cellShapeControlMesh/cellShapeControlMesh.C

@@ -0,0 +1,815 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012-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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "cellShapeControlMesh.H"
+#include "cellSizeAndAlignmentControls.H"
+#include "pointIOField.H"
+#include "scalarIOField.H"
+#include "triadIOField.H"
+#include "tetrahedron.H"
+#include "plane.H"
+#include "transform.H"
+#include "meshTools.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+defineTypeNameAndDebug(cellShapeControlMesh, 0);
+
+word cellShapeControlMesh::meshSubDir = "cellShapeControlMesh";
+}
+
+
+// * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * * //
+
+//Foam::tensor Foam::cellShapeControlMesh::requiredAlignment
+//(
+//    const Foam::point& pt,
+//    const searchableSurfaces& allGeometry,
+//    const conformationSurfaces& geometryToConformTo
+//) const
+//{
+//    pointIndexHit surfHit;
+//    label hitSurface;
+//
+//    geometryToConformTo.findSurfaceNearest
+//    (
+//        pt,
+//        sqr(GREAT),
+//        surfHit,
+//        hitSurface
+//    );
+//
+//    if (!surfHit.hit())
+//    {
+//        FatalErrorIn
+//        (
+//            "Foam::tensor Foam::conformalVoronoiMesh::requiredAlignment"
+//        )   << "findSurfaceNearest did not find a hit across the surfaces."
+//            << exit(FatalError) << endl;
+//    }
+//
+//    // Primary alignment
+//
+//    vectorField norm(1);
+//
+//    allGeometry[hitSurface].getNormal
+//    (
+//        List<pointIndexHit>(1, surfHit),
+//        norm
+//    );
+//
+//    const vector np = norm[0];
+//
+//    // Generate equally spaced 'spokes' in a circle normal to the
+//    // direction from the vertex to the closest point on the surface
+//    // and look for a secondary intersection.
+//
+//    const vector d = surfHit.hitPoint() - pt;
+//
+//    const tensor Rp = rotationTensor(vector(0,0,1), np);
+//
+//    const label s = 36;//foamyHexMeshControls().alignmentSearchSpokes();
+//
+//    scalar closestSpokeHitDistance = GREAT;
+//
+//    pointIndexHit closestSpokeHit;
+//
+//    label closestSpokeSurface = -1;
+//
+//    const scalar spanMag = geometryToConformTo.globalBounds().mag();
+//
+//    for (label i = 0; i < s; i++)
+//    {
+//        vector spoke
+//        (
+//            Foam::cos(i*constant::mathematical::twoPi/s),
+//            Foam::sin(i*constant::mathematical::twoPi/s),
+//            0
+//        );
+//
+//        spoke *= spanMag;
+//
+//        spoke = Rp & spoke;
+//
+//        pointIndexHit spokeHit;
+//
+//        label spokeSurface = -1;
+//
+//        // internal spoke
+//
+//        geometryToConformTo.findSurfaceNearestIntersection
+//        (
+//            pt,
+//            pt + spoke,
+//            spokeHit,
+//            spokeSurface
+//        );
+//
+//        if (spokeHit.hit())
+//        {
+//            scalar spokeHitDistance = mag
+//            (
+//                spokeHit.hitPoint() - pt
+//            );
+//
+//            if (spokeHitDistance < closestSpokeHitDistance)
+//            {
+//                closestSpokeHit = spokeHit;
+//                closestSpokeSurface = spokeSurface;
+//                closestSpokeHitDistance = spokeHitDistance;
+//            }
+//        }
+//
+//        //external spoke
+//
+//        Foam::point mirrorPt = pt + 2*d;
+//
+//        geometryToConformTo.findSurfaceNearestIntersection
+//        (
+//            mirrorPt,
+//            mirrorPt + spoke,
+//            spokeHit,
+//            spokeSurface
+//        );
+//
+//        if (spokeHit.hit())
+//        {
+//            scalar spokeHitDistance = mag
+//            (
+//                spokeHit.hitPoint() - mirrorPt
+//            );
+//
+//            if (spokeHitDistance < closestSpokeHitDistance)
+//            {
+//                closestSpokeHit = spokeHit;
+//                closestSpokeSurface = spokeSurface;
+//                closestSpokeHitDistance = spokeHitDistance;
+//            }
+//        }
+//    }
+//
+//    if (closestSpokeSurface == -1)
+//    {
+////        WarningIn
+////        (
+////            "conformalVoronoiMesh::requiredAlignment"
+////            "("
+////                "const Foam::point& pt"
+////            ") const"
+////        )   << "No secondary surface hit found in spoke search "
+////            << "using " << s
+////            << " spokes, try increasing alignmentSearchSpokes."
+////            << endl;
+//
+//        return I;
+//    }
+//
+//    // Auxiliary alignment generated by spoke intersection normal.
+//
+//    allGeometry[closestSpokeSurface].getNormal
+//    (
+//        List<pointIndexHit>(1, closestSpokeHit),
+//        norm
+//    );
+//
+//    const vector& na = norm[0];
+//
+//    // Secondary alignment
+//    vector ns = np ^ na;
+//
+//    if (mag(ns) < SMALL)
+//    {
+//        FatalErrorIn("conformalVoronoiMesh::requiredAlignment")
+//            << "Parallel normals detected in spoke search." << nl
+//            << "point: " << pt << nl
+//            << "closest surface point: " << surfHit.hitPoint() << nl
+//            << "closest spoke hit: " << closestSpokeHit.hitPoint() << nl
+//            << "np: " << surfHit.hitPoint() + np << nl
+//            << "ns: " << closestSpokeHit.hitPoint() + na << nl
+//            << exit(FatalError);
+//    }
+//
+//    ns /= mag(ns);
+//
+//    tensor Rs = rotationTensor((Rp & vector(0,1,0)), ns);
+//
+//    return (Rs & Rp);
+//}
+
+
+Foam::label Foam::cellShapeControlMesh::removePoints()
+{
+    label nRemoved = 0;
+    for
+    (
+        CellSizeDelaunay::Finite_vertices_iterator vit =
+            finite_vertices_begin();
+        vit != finite_vertices_end();
+        ++vit
+    )
+    {
+        std::list<Vertex_handle> verts;
+        adjacent_vertices(vit, std::back_inserter(verts));
+
+        bool removePt = true;
+        for
+        (
+            std::list<Vertex_handle>::iterator aVit = verts.begin();
+            aVit != verts.end();
+            ++aVit
+        )
+        {
+            Vertex_handle avh = *aVit;
+
+            scalar diff =
+                mag(avh->targetCellSize() - vit->targetCellSize())
+               /max(vit->targetCellSize(), 1e-6);
+
+            if (diff > 0.05)
+            {
+                removePt = false;
+            }
+        }
+
+        if (removePt)
+        {
+            remove(vit);
+            nRemoved++;
+        }
+    }
+
+    return nRemoved;
+}
+
+
+Foam::tmp<Foam::pointField> Foam::cellShapeControlMesh::cellCentres() const
+{
+    tmp<pointField> tcellCentres(new pointField(number_of_finite_cells()));
+    pointField& cellCentres = tcellCentres();
+
+    label count = 0;
+    for
+    (
+        CellSizeDelaunay::Finite_cells_iterator c = finite_cells_begin();
+        c != finite_cells_end();
+        ++c
+    )
+    {
+        if (c->hasFarPoint())
+        {
+            continue;
+        }
+
+        scalarList bary;
+        cellShapeControlMesh::Cell_handle ch;
+
+        const Foam::point centre = topoint
+        (
+            CGAL::centroid<baseK>
+            (
+                c->vertex(0)->point(),
+                c->vertex(1)->point(),
+                c->vertex(2)->point(),
+                c->vertex(3)->point()
+            )
+        );
+
+        cellCentres[count++] = centre;
+    }
+
+    cellCentres.resize(count);
+
+    return tcellCentres;
+}
+
+
+void Foam::cellShapeControlMesh::writeTriangulation()
+{
+    OFstream str
+    (
+        "refinementTriangulation_"
+      + name(Pstream::myProcNo())
+      + ".obj"
+    );
+
+    label count = 0;
+
+    Info<< "Write refinementTriangulation" << endl;
+
+    for
+    (
+        CellSizeDelaunay::Finite_edges_iterator e = finite_edges_begin();
+        e != finite_edges_end();
+        ++e
+    )
+    {
+        Cell_handle c = e->first;
+        Vertex_handle vA = c->vertex(e->second);
+        Vertex_handle vB = c->vertex(e->third);
+
+        // Don't write far edges
+        if (vA->farPoint() || vB->farPoint())
+        {
+            continue;
+        }
+
+        // Don't write unowned edges
+        if (vA->referred() && vB->referred())
+        {
+            continue;
+        }
+
+        pointFromPoint p1 = topoint(vA->point());
+        pointFromPoint p2 = topoint(vB->point());
+
+        meshTools::writeOBJ(str, p1, p2, count);
+    }
+
+    if (is_valid())
+    {
+        Info<< "    Triangulation is valid" << endl;
+    }
+    else
+    {
+        FatalErrorIn
+        (
+            "Foam::triangulatedMesh::writeRefinementTriangulation()"
+        )   << "Triangulation is not valid"
+            << abort(FatalError);
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::cellShapeControlMesh::cellShapeControlMesh(const Time& runTime)
+:
+    DistributedDelaunayMesh<CellSizeDelaunay>
+    (
+        runTime,
+        meshSubDir
+    ),
+    runTime_(runTime),
+    defaultCellSize_(0.0)
+{
+    if (this->vertexCount())
+    {
+        fvMesh mesh
+        (
+            IOobject
+            (
+                meshSubDir,
+                runTime.timeName(),
+                runTime,
+                IOobject::READ_IF_PRESENT,
+                IOobject::NO_WRITE
+            )
+        );
+
+        if (mesh.nPoints() == this->vertexCount())
+        {
+            pointScalarField sizes
+            (
+                IOobject
+                (
+                    "sizes",
+                    runTime.timeName(),
+                    meshSubDir,
+                    runTime,
+                    IOobject::READ_IF_PRESENT,
+                    IOobject::NO_WRITE
+                ),
+                pointMesh::New(mesh)
+            );
+
+            triadIOField alignments
+            (
+                IOobject
+                (
+                    "alignments",
+                    mesh.time().timeName(),
+                    meshSubDir,
+                    mesh.time(),
+                    IOobject::READ_IF_PRESENT,
+                    IOobject::AUTO_WRITE
+                )
+            );
+
+            if
+            (
+                sizes.size() == this->vertexCount()
+             && alignments.size() == this->vertexCount()
+            )
+            {
+                for
+                (
+                    Finite_vertices_iterator vit = finite_vertices_begin();
+                    vit != finite_vertices_end();
+                    ++vit
+                )
+                {
+                    vit->targetCellSize() = sizes[vit->index()];
+                    vit->alignment() = alignments[vit->index()];
+                }
+            }
+            else
+            {
+                FatalErrorIn
+                (
+                    "Foam::cellShapeControlMesh::cellShapeControlMesh"
+                    "(const Time&)"
+                )   << "Cell size point field is not the same size as the "
+                    << "mesh."
+                    << abort(FatalError);
+            }
+        }
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::cellShapeControlMesh::~cellShapeControlMesh()
+{}
+
+
+// * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
+
+void Foam::cellShapeControlMesh::barycentricCoords
+(
+    const Foam::point& pt,
+    scalarList& bary,
+    Cell_handle& ch
+) const
+{
+    // Use the previous cell handle as a hint on where to start searching
+    // Giving a hint causes strange errors...
+    ch = locate(toPoint(pt));
+
+    if (dimension() > 2 && !is_infinite(ch))
+    {
+        oldCellHandle_ = ch;
+
+        tetPointRef tet
+        (
+            topoint(ch->vertex(0)->point()),
+            topoint(ch->vertex(1)->point()),
+            topoint(ch->vertex(2)->point()),
+            topoint(ch->vertex(3)->point())
+        );
+
+        tet.barycentric(pt, bary);
+    }
+}
+
+
+Foam::boundBox Foam::cellShapeControlMesh::bounds() const
+{
+    DynamicList<Foam::point> pts(number_of_vertices());
+
+    for
+    (
+        Finite_vertices_iterator vit = finite_vertices_begin();
+        vit != finite_vertices_end();
+        ++vit
+    )
+    {
+        if (vit->real())
+        {
+            pts.append(topoint(vit->point()));
+        }
+    }
+
+    boundBox bb(pts);
+
+    return bb;
+}
+
+
+void Foam::cellShapeControlMesh::distribute
+(
+    const backgroundMeshDecomposition& decomposition
+)
+{
+    DynamicList<Foam::point> points(number_of_vertices());
+    DynamicList<scalar> sizes(number_of_vertices());
+    DynamicList<tensor> alignments(number_of_vertices());
+
+    DynamicList<Vb> farPts(8);
+
+    for
+    (
+        Finite_vertices_iterator vit = finite_vertices_begin();
+        vit != finite_vertices_end();
+        ++vit
+    )
+    {
+        if (vit->real())
+        {
+            points.append(topoint(vit->point()));
+            sizes.append(vit->targetCellSize());
+            alignments.append(vit->alignment());
+        }
+        else if (vit->farPoint())
+        {
+            farPts.append
+            (
+                Vb
+                (
+                    vit->point(),
+                    -1,
+                    Vb::vtFar,
+                    Pstream::myProcNo()
+                )
+            );
+
+            farPts.last().targetCellSize() = vit->targetCellSize();
+            farPts.last().alignment() = vit->alignment();
+        }
+    }
+
+    autoPtr<mapDistribute> mapDist =
+        DistributedDelaunayMesh<CellSizeDelaunay>::distribute
+        (
+            decomposition,
+            points
+        );
+
+    mapDist().distribute(sizes);
+    mapDist().distribute(alignments);
+
+    // Reset the entire tessellation
+    DelaunayMesh<CellSizeDelaunay>::reset();
+
+
+    // Internal points have to be inserted first
+    DynamicList<Vb> verticesToInsert(points.size());
+
+
+    forAll(farPts, ptI)
+    {
+        verticesToInsert.append(farPts[ptI]);
+    }
+
+
+    forAll(points, pI)
+    {
+        verticesToInsert.append
+        (
+            Vb
+            (
+                toPoint(points[pI]),
+                -1,
+                Vb::vtInternal,
+                Pstream::myProcNo()
+            )
+        );
+
+        verticesToInsert.last().targetCellSize() = sizes[pI];
+        verticesToInsert.last().alignment() = alignments[pI];
+    }
+
+    Info<< nl << "    Inserting distributed background tessellation..." << endl;
+
+    this->rangeInsertWithInfo
+    (
+        verticesToInsert.begin(),
+        verticesToInsert.end(),
+        true
+    );
+
+    sync(decomposition.procBounds());
+
+    Info<< "    Total number of vertices after redistribution "
+        << returnReduce(label(number_of_vertices()), sumOp<label>()) << endl;
+}
+
+
+Foam::tensorField Foam::cellShapeControlMesh::dumpAlignments() const
+{
+    tensorField alignmentsTmp(number_of_vertices(), tensor::zero);
+
+    label count = 0;
+    for
+    (
+        Finite_vertices_iterator vit = finite_vertices_begin();
+        vit != finite_vertices_end();
+        ++vit
+    )
+    {
+        alignmentsTmp[count++] = vit->alignment();
+    }
+
+    return alignmentsTmp;
+}
+
+
+void Foam::cellShapeControlMesh::write() const
+{
+    Info<< "Writing " << meshSubDir << endl;
+
+    // Reindex the cells
+    label cellCount = 0;
+    for
+    (
+        Finite_cells_iterator cit = finite_cells_begin();
+        cit != finite_cells_end();
+        ++cit
+    )
+    {
+        if (!cit->hasFarPoint() && !is_infinite(cit))
+        {
+            cit->cellIndex() = cellCount++;
+        }
+    }
+
+    DelaunayMesh<CellSizeDelaunay>::labelTolabelPairHashTable vertexMap;
+    labelList cellMap;
+
+    autoPtr<polyMesh> meshPtr = DelaunayMesh<CellSizeDelaunay>::createMesh
+    (
+        meshSubDir,
+        vertexMap,
+        cellMap
+    );
+    const polyMesh& mesh = meshPtr();
+
+    pointScalarField sizes
+    (
+        IOobject
+        (
+            "sizes",
+            mesh.time().timeName(),
+            meshSubDir,
+            mesh.time(),
+            IOobject::NO_READ,
+            IOobject::AUTO_WRITE
+        ),
+        pointMesh::New(mesh),
+        scalar(0)
+    );
+
+    triadIOField alignments
+    (
+        IOobject
+        (
+            "alignments",
+            mesh.time().timeName(),
+            meshSubDir,
+            mesh.time(),
+            IOobject::NO_READ,
+            IOobject::AUTO_WRITE
+        ),
+        sizes.size()
+    );
+
+    // Write alignments
+//    OFstream str(runTime_.path()/"alignments.obj");
+
+    for
+    (
+        Finite_vertices_iterator vit = finite_vertices_begin();
+        vit != finite_vertices_end();
+        ++vit
+    )
+    {
+        if (!vit->farPoint())
+        {
+            // Populate sizes
+            sizes[vertexMap[labelPair(vit->index(), vit->procIndex())]] =
+                vit->targetCellSize();
+
+            alignments[vertexMap[labelPair(vit->index(), vit->procIndex())]] =
+                vit->alignment();
+
+//            // Write alignments
+//            const tensor& alignment = vit->alignment();
+//            pointFromPoint pt = topoint(vit->point());
+//
+//            if
+//            (
+//                alignment.x() == triad::unset[0]
+//             || alignment.y() == triad::unset[0]
+//             || alignment.z() == triad::unset[0]
+//            )
+//            {
+//                Info<< "Bad alignment = " << vit->info();
+//
+//                vit->alignment() = tensor::I;
+//
+//                Info<< "New alignment = " << vit->info();
+//
+//                continue;
+//            }
+//
+//            meshTools::writeOBJ(str, pt, alignment.x() + pt);
+//            meshTools::writeOBJ(str, pt, alignment.y() + pt);
+//            meshTools::writeOBJ(str, pt, alignment.z() + pt);
+        }
+    }
+
+    mesh.write();
+    sizes.write();
+    alignments.write();
+}
+
+
+Foam::label Foam::cellShapeControlMesh::estimateCellCount
+(
+    const autoPtr<backgroundMeshDecomposition>& decomposition
+) const
+{
+    // Loop over all the tets and estimate the cell count in each one
+
+    scalar cellCount = 0;
+
+    for
+    (
+        Finite_cells_iterator cit = finite_cells_begin();
+        cit != finite_cells_end();
+        ++cit
+    )
+    {
+        if (!cit->hasFarPoint() && !is_infinite(cit))
+        {
+            // @todo Check if tet centre is on the processor..
+            CGAL::Tetrahedron_3<baseK> tet
+            (
+                cit->vertex(0)->point(),
+                cit->vertex(1)->point(),
+                cit->vertex(2)->point(),
+                cit->vertex(3)->point()
+            );
+
+            pointFromPoint centre = topoint(CGAL::centroid(tet));
+
+            if
+            (
+                Pstream::parRun()
+             && !decomposition().positionOnThisProcessor(centre)
+            )
+            {
+                continue;
+            }
+
+            scalar volume = CGAL::to_double(tet.volume());
+
+            scalar averagedPointCellSize = 0;
+            //scalar averagedPointCellSize = 1;
+
+            // Get an average volume by averaging the cell size of the vertices
+            for (label vI = 0; vI < 4; ++vI)
+            {
+                averagedPointCellSize += cit->vertex(vI)->targetCellSize();
+                //averagedPointCellSize *= cit->vertex(vI)->targetCellSize();
+            }
+
+            averagedPointCellSize /= 4;
+            //averagedPointCellSize = ::sqrt(averagedPointCellSize);
+
+//            if (averagedPointCellSize < SMALL)
+//            {
+//                Pout<< "Volume = " << volume << endl;
+//
+//                for (label vI = 0; vI < 4; ++vI)
+//                {
+//                    Pout<< "Point " << vI
+//                        << ", point = " << topoint(cit->vertex(vI)->point())
+//                        << ", size = " << cit->vertex(vI)->targetCellSize()
+//                        << endl;
+//                }
+//            }
+
+            cellCount += volume/pow(averagedPointCellSize, 3);
+        }
+    }
+
+    return cellCount;
+}
+
+
+// ************************************************************************* //

applications/utilities/mesh/generation/foamyHexMesh/conformalVoronoiMesh/cellShapeControl/cellShapeControlMesh/cellShapeControlMesh.H

@@ -0,0 +1,178 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012-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/>.
+
+Class
+    Foam::cellShapeControlMesh
+
+Description
+
+SourceFiles
+    cellShapeControlMeshI.H
+    cellShapeControlMesh.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef cellShapeControlMesh_H
+#define cellShapeControlMesh_H
+
+#include "Time.H"
+#include "scalar.H"
+#include "point.H"
+#include "tensor.H"
+#include "triad.H"
+#include "fileName.H"
+#include "searchableSurfaces.H"
+#include "conformationSurfaces.H"
+#include "DistributedDelaunayMesh.H"
+#include "CGALTriangulation3Ddefs.H"
+#include "backgroundMeshDecomposition.H"
+#include "boundBox.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+class cellSizeAndAlignmentControls;
+
+/*---------------------------------------------------------------------------*\
+                      Class cellShapeControlMesh Declaration
+\*---------------------------------------------------------------------------*/
+
+class cellShapeControlMesh
+:
+    public DistributedDelaunayMesh<CellSizeDelaunay>
+{
+public:
+
+        typedef CellSizeDelaunay::Cell_handle      Cell_handle;
+        typedef CellSizeDelaunay::Vertex_handle    Vertex_handle;
+        typedef CellSizeDelaunay::Point            Point;
+
+
+private:
+
+        // Private data
+
+        const Time& runTime_;
+
+        mutable Cell_handle oldCellHandle_;
+
+        const scalar defaultCellSize_;
+
+
+    // Private Member Functions
+
+        //- Disallow default bitwise copy construct
+        cellShapeControlMesh(const cellShapeControlMesh&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const cellShapeControlMesh&);
+
+
+public:
+
+    //- Runtime type information
+    ClassName("cellShapeControlMesh");
+
+    //- Return the mesh sub-directory name (usually "cellShapeControlMesh")
+    static word meshSubDir;
+
+
+    // Constructors
+
+        explicit cellShapeControlMesh(const Time& runTime);
+
+
+    //- Destructor
+    ~cellShapeControlMesh();
+
+
+    // Member Functions
+
+        // Query
+
+            const Time& time() const
+            {
+                return runTime_;
+            }
+
+            //- Calculate and return the barycentric coordinates for
+            //  interpolating quantities on the background mesh
+            void barycentricCoords
+            (
+                const Foam::point& pt,
+                scalarList& bary,
+                Cell_handle& ch
+            ) const;
+
+            boundBox bounds() const;
+
+
+        // Edit
+
+            label removePoints();
+
+            //- Get the centres of all the tets
+            tmp<pointField> cellCentres() const;
+
+            inline Vertex_handle insert
+            (
+                const Foam::point& pt,
+                const scalar& size,
+                const triad& alignment,
+                const Foam::indexedVertexEnum::vertexType type = Vb::vtInternal
+            );
+
+            inline Vertex_handle insertFar
+            (
+                const Foam::point& pt
+            );
+
+            void distribute(const backgroundMeshDecomposition& decomposition);
+
+            tensorField dumpAlignments() const;
+
+            void writeTriangulation();
+
+            void write() const;
+
+            label estimateCellCount
+            (
+                const autoPtr<backgroundMeshDecomposition>& decomposition
+            ) const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#include "cellShapeControlMeshI.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+#endif
+
+// ************************************************************************* //

applications/utilities/mesh/generation/foamyHexMesh/conformalVoronoiMesh/cellShapeControl/cellShapeControlMesh/cellShapeControlMeshI.H

@@ -0,0 +1,68 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012-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/>.
+
+\*---------------------------------------------------------------------------*/
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+Foam::cellShapeControlMesh::Vertex_handle Foam::cellShapeControlMesh::insert
+(
+    const Foam::point& pt,
+    const scalar& size,
+    const triad& alignment,
+    const Foam::indexedVertexEnum::vertexType type
+)
+{
+    Vertex_handle v = CellSizeDelaunay::insert
+    (
+        Point(pt.x(), pt.y(), pt.z())
+    );
+    v->type() = type;
+    v->index() = getNewVertexIndex();
+    v->procIndex() = Pstream::myProcNo();
+    v->targetCellSize() = size;
+    v->alignment() = tensor(alignment.x(), alignment.y(), alignment.z());
+
+    return v;
+}
+
+
+Foam::cellShapeControlMesh::Vertex_handle Foam::cellShapeControlMesh::insertFar
+(
+    const Foam::point& pt
+)
+{
+    Vertex_handle v = CellSizeDelaunay::insert
+    (
+        Point(pt.x(), pt.y(), pt.z())
+    );
+    v->type() = Vb::vtFar;
+//    v->type() = Vb::vtExternalFeaturePoint;
+    v->index() = getNewVertexIndex();
+    v->procIndex() = Pstream::myProcNo();
+
+    return v;
+}
+
+
+// ************************************************************************* //

applications/utilities/mesh/generation/foamyHexMesh/conformalVoronoiMesh/cellShapeControl/cellSizeAndAlignmentControl/cellSizeAndAlignmentControl/cellSizeAndAlignmentControl.C

@@ -0,0 +1,130 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012-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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "cellSizeAndAlignmentControl.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+defineTypeNameAndDebug(cellSizeAndAlignmentControl, 0);
+defineRunTimeSelectionTable(cellSizeAndAlignmentControl, dictionary);
+}
+
+
+// * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * * //
+
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::cellSizeAndAlignmentControl::cellSizeAndAlignmentControl
+(
+    const Time& runTime,
+    const word& name,
+    const dictionary& controlFunctionDict,
+    const conformationSurfaces& geometryToConformTo,
+    const scalar& defaultCellSize
+)
+:
+    runTime_(runTime),
+    defaultCellSize_(defaultCellSize),
+    forceInitialPointInsertion_
+    (
+        controlFunctionDict.lookupOrDefault<Switch>
+        (
+            "forceInitialPointInsertion",
+            "off"
+        )
+    ),
+    name_(name)
+{}
+
+
+// * * * * * * * * * * * * * * * * * Selectors * * * * * * * * * * * * * * * //
+
+Foam::autoPtr<Foam::cellSizeAndAlignmentControl>
+Foam::cellSizeAndAlignmentControl::New
+(
+    const Time& runTime,
+    const word& name,
+    const dictionary& controlFunctionDict,
+    const conformationSurfaces& geometryToConformTo,
+    const scalar& defaultCellSize
+)
+{
+    word cellSizeAndAlignmentControlTypeName
+    (
+        controlFunctionDict.lookup("type")
+    );
+
+    Info<< indent << "Selecting cellSizeAndAlignmentControl "
+        << cellSizeAndAlignmentControlTypeName << endl;
+
+    dictionaryConstructorTable::iterator cstrIter =
+        dictionaryConstructorTablePtr_->find
+        (
+            cellSizeAndAlignmentControlTypeName
+        );
+
+    if (cstrIter == dictionaryConstructorTablePtr_->end())
+    {
+        FatalErrorIn
+        (
+            "cellSizeAndAlignmentControl::New()"
+        )   << "Unknown cellSizeAndAlignmentControl type "
+            << cellSizeAndAlignmentControlTypeName
+            << endl << endl
+            << "Valid cellSizeAndAlignmentControl types are :" << endl
+            << dictionaryConstructorTablePtr_->toc()
+            << exit(FatalError);
+    }
+
+    return autoPtr<cellSizeAndAlignmentControl>
+    (
+        cstrIter()
+        (
+            runTime,
+            name,
+            controlFunctionDict,
+            geometryToConformTo,
+            defaultCellSize
+        )
+    );
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::cellSizeAndAlignmentControl::~cellSizeAndAlignmentControl()
+{}
+
+
+// * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
+
+
+
+// ************************************************************************* //

applications/utilities/mesh/generation/foamyHexMesh/conformalVoronoiMesh/cellShapeControl/cellSizeAndAlignmentControl/cellSizeAndAlignmentControl/cellSizeAndAlignmentControl.H

@@ -0,0 +1,184 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012-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/>.
+
+Class
+    Foam::cellSizeAndAlignmentControl
+
+Description
+
+SourceFiles
+    cellSizeAndAlignmentControlI.H
+    cellSizeAndAlignmentControl.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef cellSizeAndAlignmentControl_H
+#define cellSizeAndAlignmentControl_H
+
+#include "dictionary.H"
+#include "conformationSurfaces.H"
+#include "Time.H"
+#include "quaternion.H"
+#include "triadField.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+
+/*---------------------------------------------------------------------------*\
+                Class cellSizeAndAlignmentControl Declaration
+\*---------------------------------------------------------------------------*/
+
+class cellSizeAndAlignmentControl
+{
+protected:
+
+        const Time& runTime_;
+
+        const scalar& defaultCellSize_;
+
+        Switch forceInitialPointInsertion_;
+
+
+private:
+
+    // Private data
+
+        const word name_;
+
+
+    // Private Member Functions
+
+        //- Disallow default bitwise copy construct
+        cellSizeAndAlignmentControl(const cellSizeAndAlignmentControl&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const cellSizeAndAlignmentControl&);
+
+
+public:
+
+    //- Runtime type information
+    TypeName("cellSizeAndAlignmentControl");
+
+
+    // Declare run-time constructor selection table
+
+        declareRunTimeSelectionTable
+        (
+            autoPtr,
+            cellSizeAndAlignmentControl,
+            dictionary,
+            (
+                const Time& runTime,
+                const word& name,
+                const dictionary& controlFunctionDict,
+                const conformationSurfaces& geometryToConformTo,
+                const scalar& defaultCellSize
+            ),
+            (
+                runTime,
+                name,
+                controlFunctionDict,
+                geometryToConformTo,
+                defaultCellSize
+            )
+        );
+
+
+    // Constructors
+
+        //- Construct from dictionary and references to conformalVoronoiMesh and
+        //  searchableSurfaces
+        cellSizeAndAlignmentControl
+        (
+            const Time& runTime,
+            const word& name,
+            const dictionary& controlFunctionDict,
+            const conformationSurfaces& geometryToConformTo,
+            const scalar& defaultCellSize
+        );
+
+
+    // Selectors
+
+        //- Return a reference to the selected cellShapeControl
+        static autoPtr<cellSizeAndAlignmentControl> New
+        (
+            const Time& runTime,
+            const word& name,
+            const dictionary& controlFunctionDict,
+            const conformationSurfaces& geometryToConformTo,
+            const scalar& defaultCellSize
+        );
+
+
+    //- Destructor
+    virtual ~cellSizeAndAlignmentControl();
+
+
+    // Member Functions
+
+        // Access
+
+            const word& name() const
+            {
+                return name_;
+            }
+
+            const Switch& forceInitialPointInsertion() const
+            {
+                return forceInitialPointInsertion_;
+            }
+
+
+        // Query
+
+            virtual label maxPriority() const = 0;
+
+            virtual void cellSizeFunctionVertices
+            (
+                DynamicList<Foam::point>& pts,
+                DynamicList<scalar>& sizes
+            ) const = 0;
+
+            virtual void initialVertices
+            (
+                pointField& pts,
+                scalarField& sizes,
+                triadField& alignments
+            ) const = 0;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

applications/utilities/mesh/generation/foamyHexMesh/conformalVoronoiMesh/cellShapeControl/cellSizeAndAlignmentControl/cellSizeAndAlignmentControls.C

@@ -0,0 +1,180 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012-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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "cellSizeAndAlignmentControls.H"
+#include "searchableSurfaceControl.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+defineTypeNameAndDebug(cellSizeAndAlignmentControls, 0);
+}
+
+
+// * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * * //
+
+bool Foam::cellSizeAndAlignmentControls::evalCellSizeFunctions
+(
+    const point& pt,
+    scalar& minSize,
+    label& maxPriority
+) const
+{
+    bool anyFunctionFound = false;
+
+    // Regions requesting with the same priority take the smallest
+
+    if (controlFunctions_.size())
+    {
+        // Maintain priority of current hit. Initialise so it always goes
+        // through at least once.
+        label previousPriority = labelMin;
+
+        forAll(controlFunctions_, i)
+        {
+            const cellSizeAndAlignmentControl& cSF = controlFunctions_[i];
+
+            if (isA<searchableSurfaceControl>(cSF))
+            {
+                const searchableSurfaceControl& sSC =
+                    refCast<const searchableSurfaceControl>(cSF);
+
+                anyFunctionFound = sSC.cellSize(pt, minSize, previousPriority);
+
+                if (previousPriority > maxPriority)
+                {
+                    maxPriority = previousPriority;
+                }
+            }
+        }
+    }
+
+    return anyFunctionFound;
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::cellSizeAndAlignmentControls::cellSizeAndAlignmentControls
+(
+    const Time& runTime,
+    const dictionary& shapeControlDict,
+    const conformationSurfaces& geometryToConformTo,
+    const scalar& defaultCellSize
+)
+:
+    shapeControlDict_(shapeControlDict),
+    geometryToConformTo_(geometryToConformTo),
+    controlFunctions_(shapeControlDict_.size()),
+    defaultCellSize_(defaultCellSize)
+{
+    label functionI = 0;
+
+    forAllConstIter(dictionary, shapeControlDict_, iter)
+    {
+        word shapeControlEntryName = iter().keyword();
+
+        const dictionary& controlFunctionDict
+        (
+            shapeControlDict_.subDict(shapeControlEntryName)
+        );
+
+        Info<< nl << "Shape Control : " << shapeControlEntryName << endl;
+        Info<< incrIndent;
+
+        controlFunctions_.set
+        (
+            functionI,
+            cellSizeAndAlignmentControl::New
+            (
+                runTime,
+                shapeControlEntryName,
+                controlFunctionDict,
+                geometryToConformTo_,
+                defaultCellSize_
+            )
+        );
+
+        Info<< decrIndent;
+
+        functionI++;
+    }
+
+    // Sort controlFunctions_ by maxPriority
+    SortableList<label> functionPriorities(functionI);
+
+    forAll(controlFunctions_, funcI)
+    {
+        functionPriorities[funcI] = controlFunctions_[funcI].maxPriority();
+    }
+
+    functionPriorities.reverseSort();
+
+    labelList invertedFunctionPriorities =
+        invert(functionPriorities.size(), functionPriorities.indices());
+
+    controlFunctions_.reorder(invertedFunctionPriorities);
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::cellSizeAndAlignmentControls::~cellSizeAndAlignmentControls()
+{}
+
+
+// * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
+
+Foam::scalar Foam::cellSizeAndAlignmentControls::cellSize
+(
+    const point& pt
+) const
+{
+    scalar size = defaultCellSize_;
+    label maxPriority = -1;
+
+    evalCellSizeFunctions(pt, size, maxPriority);
+
+    return size;
+}
+
+
+Foam::scalar Foam::cellSizeAndAlignmentControls::cellSize
+(
+    const point& pt,
+    label& maxPriority
+) const
+{
+    scalar size = defaultCellSize_;
+    maxPriority = -1;
+
+    evalCellSizeFunctions(pt, size, maxPriority);
+
+    return size;
+}
+
+
+// ************************************************************************* //

applications/utilities/mesh/generation/foamyHexMesh/conformalVoronoiMesh/cellShapeControl/cellSizeAndAlignmentControl/cellSizeAndAlignmentControls.H

@@ -0,0 +1,132 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012-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/>.
+
+Class
+    Foam::cellSizeAndAlignmentControls
+
+Description
+
+SourceFiles
+    cellSizeAndAlignmentControls.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef cellSizeAndAlignmentControls_H
+#define cellSizeAndAlignmentControls_H
+
+#include "dictionary.H"
+#include "cellSizeAndAlignmentControl.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                     Class cellSizeAndAlignmentControls Declaration
+\*---------------------------------------------------------------------------*/
+
+class cellSizeAndAlignmentControls
+{
+    // Private data
+
+        const dictionary& shapeControlDict_;
+
+        const conformationSurfaces& geometryToConformTo_;
+
+        PtrList<cellSizeAndAlignmentControl> controlFunctions_;
+
+        const scalar defaultCellSize_;
+
+
+    // Private Member Functions
+
+        bool evalCellSizeFunctions
+        (
+            const point& pt,
+            scalar& minSize,
+            label& maxPriority
+        ) const;
+
+        //- Disallow default bitwise copy construct
+        cellSizeAndAlignmentControls(const cellSizeAndAlignmentControls&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const cellSizeAndAlignmentControls&);
+
+
+public:
+
+        //- Runtime type information
+        ClassName("cellSizeAndAlignmentControls");
+
+
+    // Constructors
+
+        //- Construct from dictionary
+        cellSizeAndAlignmentControls
+        (
+            const Time& runTime,
+            const dictionary& shapeControlDict,
+            const conformationSurfaces& geometryToConformTo,
+            const scalar& defaultCellSize
+        );
+
+
+    //- Destructor
+    virtual ~cellSizeAndAlignmentControls();
+
+
+    // Member Functions
+
+        // Access
+
+            inline const PtrList<cellSizeAndAlignmentControl>&
+            controlFunctions() const
+            {
+                return controlFunctions_;
+            }
+
+            inline const conformationSurfaces& geometryToConformTo() const
+            {
+                return geometryToConformTo_;
+            }
+
+
+        // Query
+
+            scalar cellSize(const point& pt) const;
+
+            scalar cellSize(const point& pt, label& maxPriority) const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

applications/utilities/mesh/generation/foamyHexMesh/conformalVoronoiMesh/cellShapeControl/cellSizeAndAlignmentControl/fileControl/fileControl.C

@@ -0,0 +1,256 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012-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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "fileControl.H"
+#include "addToRunTimeSelectionTable.H"
+#include "tetrahedron.H"
+#include "scalarList.H"
+#include "vectorTools.H"
+#include "pointIOField.H"
+#include "scalarIOField.H"
+#include "triadIOField.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+defineTypeNameAndDebug(fileControl, 0);
+addToRunTimeSelectionTable
+(
+    cellSizeAndAlignmentControl,
+    fileControl,
+    dictionary
+);
+
+}
+
+
+// * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::fileControl::fileControl
+(
+    const Time& runTime,
+    const word& name,
+    const dictionary& controlFunctionDict,
+    const conformationSurfaces& geometryToConformTo,
+    const scalar& defaultCellSize
+)
+:
+    cellSizeAndAlignmentControl
+    (
+        runTime,
+        name,
+        controlFunctionDict,
+        geometryToConformTo,
+        defaultCellSize
+    ),
+    pointsFile_(controlFunctionDict.lookup("pointsFile")),
+    sizesFile_(controlFunctionDict.lookup("sizesFile")),
+    alignmentsFile_(controlFunctionDict.lookup("alignmentsFile")),
+    maxPriority_(readLabel(controlFunctionDict.lookup("priority")))
+{
+    Info<< indent << "Loading " << name << " from file:" << nl
+        << indent << "    priority   : " << maxPriority_ << nl
+        << indent << "    points     : " << pointsFile_ << nl
+        << indent << "    sizes      : " << sizesFile_ << nl
+        << indent << "    alignments : " << alignmentsFile_
+        << endl;
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::fileControl::~fileControl()
+{}
+
+
+// * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
+//
+//Foam::scalar Foam::fileControl::cellSize(const point& pt) const
+//{
+//    scalarList bary;
+//    Cell_handle ch;
+//
+//    triangulatedMesh_.barycentricCoords(pt, bary, ch);
+//
+//    scalar size = 0;
+//    forAll(bary, pI)
+//    {
+//        size += bary[pI]*ch->vertex(pI)->size();
+//    }
+//
+//    return size;
+//}
+//
+//
+////- Return the cell alignment at the given location
+//Foam::tensor Foam::fileControl::cellAlignment(const point& pt) const
+//{
+//    scalarList bary;
+//    Cell_handle ch;
+//
+//    triangulatedMesh_.barycentricCoords(pt, bary, ch);
+//
+//    label nearest = 0;
+//
+//    tensor alignment = Foam::tensor::zero;
+//    forAll(bary, pI)
+//    {
+//        //alignment += bary[pI]*ch->vertex(pI)->alignment();
+//
+//        // Find nearest point
+//        if (bary[pI] > nearest)
+//        {
+//            alignment = ch->vertex(pI)->alignment();
+//            nearest = bary[pI];
+//        }
+//    }
+//
+//    return alignment;
+//}
+//
+//
+////- Return the cell alignment at the given location
+//void Foam::fileControl::cellSizeAndAlignment
+//(
+//    const point& pt,
+//    scalar& size,
+//    tensor& alignment
+//) const
+//{
+//    scalarList bary;
+//    Cell_handle ch;
+//
+//    triangulatedMesh_.barycentricCoords(pt, bary, ch);
+//
+//    size = 0;
+//    forAll(bary, pI)
+//    {
+//        size += bary[pI]*ch->vertex(pI)->size();
+//    }
+//
+////    alignment = Foam::tensor::zero;
+////    forAll(bary, pI)
+////    {
+////        alignment += bary[pI]*ch->vertex(pI)->alignment();
+////    }
+//
+//    alignment = cellAlignment(pt);
+//}
+
+
+void Foam::fileControl::cellSizeFunctionVertices
+(
+    DynamicList<Foam::point>& pts,
+    DynamicList<scalar>& sizes
+) const
+{
+    return;
+}
+
+
+void Foam::fileControl::initialVertices
+(
+    pointField& pts,
+    scalarField& sizes,
+    triadField& alignments
+) const
+{
+    Info<< "    Reading points from file     : " << pointsFile_ << endl;
+
+    pointIOField pointsTmp
+    (
+        IOobject
+        (
+            pointsFile_,
+            runTime_.constant(),
+            runTime_,
+            IOobject::MUST_READ,
+            IOobject::NO_WRITE,
+            false
+        )
+    );
+
+    pts.transfer(pointsTmp);
+
+    Info<< "    Reading sizes from file      : " << sizesFile_ << endl;
+
+    scalarIOField sizesTmp
+    (
+        IOobject
+        (
+            sizesFile_,
+            runTime_.constant(),
+            runTime_,
+            IOobject::MUST_READ,
+            IOobject::NO_WRITE,
+            false
+        )
+    );
+
+    sizes.transfer(sizesTmp);
+
+    Info<< "    Reading alignments from file : " << alignmentsFile_ << endl;
+
+    triadIOField alignmentsTmp
+    (
+        IOobject
+        (
+            alignmentsFile_,
+            runTime_.constant(),
+            runTime_,
+            IOobject::MUST_READ,
+            IOobject::NO_WRITE,
+            false
+        )
+    );
+
+    alignments.transfer(alignmentsTmp);
+
+    if ((pts.size() != sizes.size()) || (pts.size() != alignments.size()))
+    {
+        FatalErrorIn
+        (
+            "Foam::fileControl::initialVertices"
+            "("
+            "   pointField&,"
+            "   scalarField&,"
+            "   Field<triad>&"
+            ")"
+        )   << "Size of list of points, sizes and alignments do not match:"
+            << nl
+            << "Points size     = " << pts.size() << nl
+            << "Sizes size      = " << sizes.size() << nl
+            << "Alignments size = " << alignments.size()
+            << abort(FatalError);
+    }
+}
+
+
+// ************************************************************************* //

applications/utilities/mesh/generation/foamyHexMesh/conformalVoronoiMesh/cellShapeControl/cellSizeAndAlignmentControl/fileControl/fileControl.H

@@ -0,0 +1,147 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012-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/>.
+
+Class
+    Foam::fileControl
+
+Description
+
+SourceFiles
+    fileControl.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef fileControl_H
+#define fileControl_H
+
+#include "cellSizeAndAlignmentControl.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+
+/*---------------------------------------------------------------------------*\
+                      Class fileControl Declaration
+\*---------------------------------------------------------------------------*/
+
+class fileControl
+:
+    public cellSizeAndAlignmentControl
+{
+    // Private data
+
+        const fileName pointsFile_;
+
+        const fileName sizesFile_;
+
+        const fileName alignmentsFile_;
+
+        label maxPriority_;
+
+
+    // Private Member Functions
+
+        //- Disallow default bitwise copy construct
+        fileControl(const fileControl&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const fileControl&);
+
+
+public:
+
+    //- Runtime type information
+    TypeName("fileControl");
+
+
+    // Constructors
+
+        //- Construct from dictionary and references to conformalVoronoiMesh and
+        //  searchableSurfaces
+        fileControl
+        (
+            const Time& runTime,
+            const word& name,
+            const dictionary& controlFunctionDict,
+            const conformationSurfaces& geometryToConformTo,
+            const scalar& defaultCellSize
+        );
+
+    //- Destructor
+    ~fileControl();
+
+
+    // Member Functions
+
+        // Access
+
+
+        // Query
+
+//            //- Return the cell size at the given location
+//            virtual scalar cellSize(const point& pt) const;
+//
+//            //- Return the cell alignment at the given location
+//            virtual tensor cellAlignment(const point& pt) const;
+//
+//            virtual void cellSizeAndAlignment
+//            (
+//                const point& pt,
+//                scalar& size,
+//                tensor& alignment
+//            ) const;
+
+
+            virtual label maxPriority() const
+            {
+                return maxPriority_;
+            }
+
+        // Edit
+
+            virtual void cellSizeFunctionVertices
+            (
+                DynamicList<Foam::point>& pts,
+                DynamicList<scalar>& sizes
+            ) const;
+
+            virtual void initialVertices
+            (
+                pointField& pts,
+                scalarField& sizes,
+                triadField& alignments
+            ) const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

applications/utilities/mesh/generation/foamyHexMesh/conformalVoronoiMesh/cellShapeControl/cellSizeAndAlignmentControl/searchableSurfaceControl/searchableSurfaceControl.C

@@ -0,0 +1,586 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012-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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "searchableSurfaceControl.H"
+#include "addToRunTimeSelectionTable.H"
+#include "cellSizeFunction.H"
+#include "triSurfaceMesh.H"
+#include "searchableBox.H"
+#include "tetrahedron.H"
+#include "vectorTools.H"
+#include "quaternion.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+defineTypeNameAndDebug(searchableSurfaceControl, 0);
+addToRunTimeSelectionTable
+(
+    cellSizeAndAlignmentControl,
+    searchableSurfaceControl,
+    dictionary
+);
+
+}
+
+
+// * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * * //
+
+//Foam::tensor Foam::surfaceControl::requiredAlignment
+//(
+//    const Foam::point& pt,
+//    const vectorField& ptNormals
+//) const
+//{
+////    pointIndexHit surfHit;
+////    label hitSurface;
+////
+////    geometryToConformTo_.findSurfaceNearest
+////    (
+////        pt,
+////        sqr(GREAT),
+////        surfHit,
+////        hitSurface
+////    );
+////
+////    if (!surfHit.hit())
+////    {
+////        FatalErrorIn
+////        (
+////            "Foam::tensor Foam::conformalVoronoiMesh::requiredAlignment"
+////        )
+////            << "findSurfaceNearest did not find a hit across the surfaces."
+////            << exit(FatalError) << endl;
+////    }
+////
+//////     Primary alignment
+////
+////    vectorField norm(1);
+////
+////    allGeometry_[hitSurface].getNormal
+////    (
+////        List<pointIndexHit>(1, surfHit),
+////        norm
+////    );
+////
+////    const vector np = norm[0];
+////
+////    const tensor Rp = rotationTensor(vector(0,0,1), np);
+////
+////    return (Rp);
+//
+////    Info<< "Point : " << pt << endl;
+////    forAll(ptNormals, pnI)
+////    {
+////        Info<< "    normal " << pnI << " : " << ptNormals[pnI] << endl;
+////    }
+//
+//    vector np = ptNormals[0];
+//
+//    const tensor Rp = rotationTensor(vector(0,0,1), np);
+//
+//    vector na = vector::zero;
+//
+//    scalar smallestAngle = GREAT;
+//
+//    for (label pnI = 1; pnI < ptNormals.size(); ++pnI)
+//    {
+//        const vector& nextNormal = ptNormals[pnI];
+//
+//        const scalar cosPhi = vectorTools::cosPhi(np, nextNormal);
+//
+//        if (mag(cosPhi) < smallestAngle)
+//        {
+//            na = nextNormal;
+//            smallestAngle = cosPhi;
+//        }
+//    }
+//
+//    // Secondary alignment
+//    vector ns = np ^ na;
+//
+//    if (mag(ns) < SMALL)
+//    {
+//        WarningIn("conformalVoronoiMesh::requiredAlignment")
+//            << "Parallel normals detected in spoke search." << nl
+//            << "point: " << pt << nl
+//            << "np   : " << np << nl
+//            << "na   : " << na << nl
+//            << "ns   : " << ns << nl
+//            << endl;
+//
+//        ns = np;
+//    }
+//
+//    ns /= mag(ns);
+//
+//    tensor Rs = rotationTensor((Rp & vector(0,1,0)), ns);
+//
+////    Info<< "Point " << pt << nl
+////        << "      np : " << np << nl
+////        << "      ns : " << ns << nl
+////        << "      Rp : " << Rp << nl
+////        << "      Rs : " << Rs << nl
+////        << "    Rs&Rp: " << (Rs & Rp) << endl;
+//
+//    return (Rs & Rp);
+//}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::searchableSurfaceControl::searchableSurfaceControl
+(
+    const Time& runTime,
+    const word& name,
+    const dictionary& controlFunctionDict,
+    const conformationSurfaces& geometryToConformTo,
+    const scalar& defaultCellSize
+)
+:
+    cellSizeAndAlignmentControl
+    (
+        runTime,
+        name,
+        controlFunctionDict,
+        geometryToConformTo,
+        defaultCellSize
+    ),
+    surfaceName_(controlFunctionDict.lookupOrDefault<word>("surface", name)),
+    searchableSurface_(geometryToConformTo.geometry()[surfaceName_]),
+    geometryToConformTo_(geometryToConformTo),
+    cellSizeFunctions_(1),
+    regionToCellSizeFunctions_(searchableSurface_.regions().size(), -1),
+    maxPriority_(-1)
+{
+    Info<< indent << "Master settings:" << endl;
+    Info<< incrIndent;
+
+    cellSizeFunctions_.set
+    (
+        0,
+        cellSizeFunction::New
+        (
+            controlFunctionDict,
+            searchableSurface_,
+            defaultCellSize_,
+            labelList()
+        )
+    );
+
+    Info<< decrIndent;
+
+    PtrList<cellSizeFunction> regionCellSizeFunctions;
+
+    DynamicList<label> defaultCellSizeRegions;
+
+    label nRegionCellSizeFunctions = 0;
+
+    // Loop over regions - if any entry is not specified they should
+    // inherit values from the parent surface.
+    if (controlFunctionDict.found("regions"))
+    {
+        const dictionary& regionsDict = controlFunctionDict.subDict("regions");
+        const wordList& regionNames = searchableSurface_.regions();
+
+        label nRegions = regionsDict.size();
+
+        regionCellSizeFunctions.setSize(nRegions);
+        defaultCellSizeRegions.setCapacity(nRegions);
+
+        forAll(regionNames, regionI)
+        {
+            const word& regionName = regionNames[regionI];
+
+            label regionID = geometryToConformTo_.geometry().findSurfaceRegionID
+            (
+                this->name(),
+                regionName
+            );
+
+            if (regionsDict.found(regionName))
+            {
+                // Get the dictionary for region
+                const dictionary& regionDict = regionsDict.subDict(regionName);
+
+                Info<< indent << "Region " << regionName
+                    << " (ID = " << regionID << ")" << " settings:"
+                    << endl;
+                Info<< incrIndent;
+
+                regionCellSizeFunctions.set
+                (
+                    nRegionCellSizeFunctions,
+                    cellSizeFunction::New
+                    (
+                        regionDict,
+                        searchableSurface_,
+                        defaultCellSize_,
+                        labelList(1, regionID)
+                    )
+                );
+                Info<< decrIndent;
+
+                regionToCellSizeFunctions_[regionID] = nRegionCellSizeFunctions;
+
+                nRegionCellSizeFunctions++;
+            }
+            else
+            {
+                // Add to default list
+                defaultCellSizeRegions.append(regionID);
+            }
+        }
+    }
+
+    if (defaultCellSizeRegions.empty() && !regionCellSizeFunctions.empty())
+    {
+        cellSizeFunctions_.transfer(regionCellSizeFunctions);
+    }
+    else if (nRegionCellSizeFunctions > 0)
+    {
+        regionCellSizeFunctions.setSize(nRegionCellSizeFunctions + 1);
+
+        regionCellSizeFunctions.set
+        (
+            nRegionCellSizeFunctions,
+            cellSizeFunction::New
+            (
+                controlFunctionDict,
+                searchableSurface_,
+                defaultCellSize_,
+                labelList()
+            )
+        );
+
+        const wordList& regionNames = searchableSurface_.regions();
+
+        forAll(regionNames, regionI)
+        {
+            if (regionToCellSizeFunctions_[regionI] == -1)
+            {
+                regionToCellSizeFunctions_[regionI] = nRegionCellSizeFunctions;
+            }
+        }
+
+        cellSizeFunctions_.transfer(regionCellSizeFunctions);
+    }
+    else
+    {
+        const wordList& regionNames = searchableSurface_.regions();
+
+        forAll(regionNames, regionI)
+        {
+            if (regionToCellSizeFunctions_[regionI] == -1)
+            {
+                regionToCellSizeFunctions_[regionI] = 0;
+            }
+        }
+    }
+
+
+    forAll(cellSizeFunctions_, funcI)
+    {
+        const label funcPriority = cellSizeFunctions_[funcI].priority();
+
+        if (funcPriority > maxPriority_)
+        {
+            maxPriority_ = funcPriority;
+        }
+    }
+
+    // Sort controlFunctions_ by maxPriority
+    SortableList<label> functionPriorities(cellSizeFunctions_.size());
+
+    forAll(cellSizeFunctions_, funcI)
+    {
+        functionPriorities[funcI] = cellSizeFunctions_[funcI].priority();
+    }
+
+    functionPriorities.reverseSort();
+
+    labelList invertedFunctionPriorities =
+        invert(functionPriorities.size(), functionPriorities.indices());
+
+    cellSizeFunctions_.reorder(invertedFunctionPriorities);
+
+    Info<< nl << indent << "There are " << cellSizeFunctions_.size()
+        << " region control functions" << endl;
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::searchableSurfaceControl::~searchableSurfaceControl()
+{}
+
+
+// * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
+
+void Foam::searchableSurfaceControl::initialVertices
+(
+    pointField& pts,
+    scalarField& sizes,
+    triadField& alignments
+) const
+{
+    pts = searchableSurface_.points();
+    sizes.setSize(pts.size());
+    alignments.setSize(pts.size());
+
+    const scalar nearFeatDistSqrCoeff = 1e-8;
+
+    forAll(pts, pI)
+    {
+        // Is the point in the extendedFeatureEdgeMesh? If so get the
+        // point normal, otherwise get the surface normal from
+        // searchableSurface
+
+        pointIndexHit info;
+        label infoFeature;
+        geometryToConformTo_.findFeaturePointNearest
+        (
+            pts[pI],
+            nearFeatDistSqrCoeff,
+            info,
+            infoFeature
+        );
+
+        scalar limitedCellSize = GREAT;
+
+        autoPtr<triad> pointAlignment;
+
+        if (info.hit())
+        {
+            const extendedFeatureEdgeMesh& features =
+                geometryToConformTo_.features()[infoFeature];
+
+            vectorField norms = features.featurePointNormals(info.index());
+
+            // Create a triad from these norms.
+            pointAlignment.set(new triad());
+            forAll(norms, nI)
+            {
+                pointAlignment() += norms[nI];
+            }
+
+            pointAlignment().normalize();
+            pointAlignment().orthogonalize();
+        }
+        else
+        {
+            geometryToConformTo_.findEdgeNearest
+            (
+                pts[pI],
+                nearFeatDistSqrCoeff,
+                info,
+                infoFeature
+            );
+
+            if (info.hit())
+            {
+                const extendedFeatureEdgeMesh& features =
+                    geometryToConformTo_.features()[infoFeature];
+
+                vectorField norms = features.edgeNormals(info.index());
+
+                // Create a triad from these norms.
+                pointAlignment.set(new triad());
+                forAll(norms, nI)
+                {
+                    pointAlignment() += norms[nI];
+                }
+
+                pointAlignment().normalize();
+                pointAlignment().orthogonalize();
+            }
+            else
+            {
+                pointField ptField(1, pts[pI]);
+                scalarField distField(1, nearFeatDistSqrCoeff);
+                List<pointIndexHit> infoList(1, pointIndexHit());
+
+                searchableSurface_.findNearest(ptField, distField, infoList);
+
+                vectorField normals(1);
+                searchableSurface_.getNormal(infoList, normals);
+
+                if (mag(normals[0]) < SMALL)
+                {
+                    normals[0] = vector(1, 1, 1);
+                }
+
+                pointAlignment.set(new triad(normals[0]));
+
+                if (infoList[0].hit())
+                {
+                    // Limit cell size
+                    const vector vN =
+                        infoList[0].hitPoint()
+                      - 2.0*normals[0]*defaultCellSize_;
+
+                    List<pointIndexHit> intersectionList;
+                    searchableSurface_.findLineAny
+                    (
+                        ptField,
+                        pointField(1, vN),
+                        intersectionList
+                    );
+                }
+
+//                if (intersectionList[0].hit())
+//                {
+//                    scalar dist =
+//                        mag(intersectionList[0].hitPoint() - pts[pI]);
+//
+//                    limitedCellSize = dist/2.0;
+//                }
+            }
+        }
+
+        label priority = -1;
+        if (!cellSize(pts[pI], sizes[pI], priority))
+        {
+            sizes[pI] = defaultCellSize_;
+//            FatalErrorIn
+//            (
+//                "Foam::searchableSurfaceControl::initialVertices"
+//                "(pointField&, scalarField&, tensorField&)"
+//            )   << "Could not calculate cell size"
+//                << abort(FatalError);
+        }
+
+        sizes[pI] = min(limitedCellSize, sizes[pI]);
+
+        alignments[pI] = pointAlignment();
+    }
+}
+
+
+void Foam::searchableSurfaceControl::cellSizeFunctionVertices
+(
+    DynamicList<Foam::point>& pts,
+    DynamicList<scalar>& sizes
+) const
+{
+    const tmp<pointField> tmpPoints = searchableSurface_.points();
+    const pointField& points = tmpPoints();
+
+    const scalar nearFeatDistSqrCoeff = 1e-8;
+
+    pointField ptField(1, vector::min);
+    scalarField distField(1, nearFeatDistSqrCoeff);
+    List<pointIndexHit> infoList(1, pointIndexHit());
+
+    vectorField normals(1);
+    labelList region(1, -1);
+
+    forAll(points, pI)
+    {
+        // Is the point in the extendedFeatureEdgeMesh? If so get the
+        // point normal, otherwise get the surface normal from
+        // searchableSurface
+        ptField[0] = points[pI];
+
+        searchableSurface_.findNearest(ptField, distField, infoList);
+
+        if (infoList[0].hit())
+        {
+            searchableSurface_.getNormal(infoList, normals);
+            searchableSurface_.getRegion(infoList, region);
+
+            const cellSizeFunction& sizeFunc =
+                sizeFunctions()[regionToCellSizeFunctions_[region[0]]];
+
+            pointField extraPts;
+            scalarField extraSizes;
+            sizeFunc.sizeLocations
+            (
+                infoList[0],
+                normals[0],
+                extraPts,
+                extraSizes
+            );
+
+            pts.append(extraPts);
+            sizes.append(extraSizes);
+        }
+    }
+}
+
+
+bool Foam::searchableSurfaceControl::cellSize
+(
+    const Foam::point& pt,
+    scalar& cellSize,
+    label& priority
+) const
+{
+    bool anyFunctionFound = false;
+
+    forAll(sizeFunctions(), funcI)
+    {
+        const cellSizeFunction& sizeFunc = sizeFunctions()[funcI];
+
+        if (sizeFunc.priority() < priority)
+        {
+            continue;
+        }
+
+        scalar sizeI = -1;
+
+        if (sizeFunc.cellSize(pt, sizeI))
+        {
+            anyFunctionFound = true;
+
+            if (sizeFunc.priority() == priority)
+            {
+                if (sizeI < cellSize)
+                {
+                    cellSize = sizeI;
+                }
+            }
+            else
+            {
+                cellSize = sizeI;
+
+                priority = sizeFunc.priority();
+            }
+
+            if (debug)
+            {
+                Info<< "    sizeI " << sizeI
+                    <<"    minSize " << cellSize << endl;
+            }
+        }
+    }
+
+    return anyFunctionFound;
+}
+
+
+// ************************************************************************* //

applications/utilities/mesh/generation/foamyHexMesh/conformalVoronoiMesh/cellShapeControl/cellSizeAndAlignmentControl/searchableSurfaceControl/searchableSurfaceControl.H

@@ -0,0 +1,191 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012-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/>.
+
+Class
+    Foam::searchableSurfaceControl
+
+Description
+
+SourceFiles
+    searchableSurfaceControl.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef searchableSurfaceControl_H
+#define searchableSurfaceControl_H
+
+#include "cellSizeFunction.H"
+#include "triad.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+
+/*---------------------------------------------------------------------------*\
+                      Class surfaceControl Declaration
+\*---------------------------------------------------------------------------*/
+
+class searchableSurfaceControl
+:
+    public cellSizeAndAlignmentControl
+{
+    // Private data
+
+        //- Name of the surface
+        const word surfaceName_;
+
+        //- Reference to the searchableSurface object holding the geometry data
+        const searchableSurface& searchableSurface_;
+
+        const conformationSurfaces& geometryToConformTo_;
+
+        PtrList<cellSizeFunction> cellSizeFunctions_;
+
+        labelList regionToCellSizeFunctions_;
+
+        label maxPriority_;
+
+
+//        const conformationSurfaces& geometryToConformTo_;
+//
+//        //- Indices of surfaces in allGeometry that are to be conformed to
+//        labelList surfaces_;
+//
+//        //- A list of all of the cellSizeFunction objects
+//        PtrList<cellSizeFunction> cellSizeFunctions_;
+//
+//        autoPtr<triangulatedMesh> triangulatedMesh_;
+//
+//
+//    // Private Member Functions
+//
+//        //-
+//        tensor requiredAlignment
+//        (
+//            const point& pt,
+//            const vectorField& ptNormals
+//        ) const;
+
+        //- Disallow default bitwise copy construct
+        searchableSurfaceControl(const searchableSurfaceControl&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const searchableSurfaceControl&);
+
+
+public:
+
+    //- Runtime type information
+    TypeName("searchableSurfaceControl");
+
+
+    // Constructors
+
+        //- Construct from dictionary and references to conformalVoronoiMesh and
+        //  searchableSurfaces
+        searchableSurfaceControl
+        (
+            const Time& runTime,
+            const word& name,
+            const dictionary& controlFunctionDict,
+            const conformationSurfaces& geometryToConformTo,
+            const scalar& defaultCellSize
+        );
+
+    //- Destructor
+    ~searchableSurfaceControl();
+
+
+    // Member Functions
+
+        // Access
+
+//            //- Return reference to the searchableSurfaces object containing
+//            //  all of the geometry
+//            inline const searchableSurfaces& geometry() const;
+//
+//            //- Return the surface indices
+//            inline const labelList& surfaces() const;
+//
+//
+//        // Query
+//
+//            //- Return the cell size at the given location
+//            virtual scalar cellSize(const point& pt) const;
+//
+//            //- Return the cell alignment at the given location
+//            virtual tensor cellAlignment(const point& pt) const;
+//
+//            virtual void cellSizeAndAlignment
+//            (
+//                const point& pt,
+//                scalar& size,
+//                tensor& alignment
+//            ) const;
+
+        virtual void cellSizeFunctionVertices
+        (
+            DynamicList<Foam::point>& pts,
+            DynamicList<scalar>& sizes
+        ) const;
+
+        virtual void initialVertices
+        (
+            pointField& pts,
+            scalarField& sizes,
+            triadField& alignments
+        ) const;
+
+        const PtrList<cellSizeFunction>& sizeFunctions() const
+        {
+            return cellSizeFunctions_;
+        }
+
+        virtual label maxPriority() const
+        {
+            return maxPriority_;
+        }
+
+        bool cellSize
+        (
+            const Foam::point& pt,
+            scalar& cellSize,
+            label& priority
+        ) const;
+
+        // Edit
+
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

applications/utilities/mesh/generation/foamyHexMesh/conformalVoronoiMesh/cellShapeControl/controlMeshRefinement/controlMeshRefinement.C

@@ -0,0 +1,786 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "controlMeshRefinement.H"
+#include "cellSizeAndAlignmentControl.H"
+#include "OFstream.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+defineTypeNameAndDebug(controlMeshRefinement, 0);
+}
+
+// * * * * * * * * * * * * * Static Member Functions * * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+Foam::scalar Foam::controlMeshRefinement::calcFirstDerivative
+(
+    const Foam::point& a,
+    const scalar& cellSizeA,
+    const Foam::point& b,
+    const scalar& cellSizeB
+) const
+{
+    return (cellSizeA - cellSizeB)/mag(a - b);
+}
+
+
+//Foam::scalar Foam::controlMeshRefinement::calcSecondDerivative
+//(
+//    const Foam::point& a,
+//    const scalar& cellSizeA,
+//    const Foam::point& midPoint,
+//    const scalar& cellSizeMid,
+//    const Foam::point& b,
+//    const scalar& cellSizeB
+//) const
+//{
+//    return (cellSizeA - 2*cellSizeMid + cellSizeB)/magSqr((a - b)/2);
+//}
+
+
+bool Foam::controlMeshRefinement::detectEdge
+(
+    const Foam::point& startPt,
+    const Foam::point& endPt,
+    pointHit& pointFound,
+    const scalar tolSqr,
+    const scalar secondDerivTolSqr
+) const
+{
+    Foam::point a(startPt);
+    Foam::point b(endPt);
+
+    Foam::point midPoint = (a + b)/2.0;
+
+    label nIterations = 0;
+
+    while (true)
+    {
+        nIterations++;
+
+        if
+        (
+            magSqr(a - b) < tolSqr
+        )
+        {
+            pointFound.setPoint(midPoint);
+            pointFound.setHit();
+
+            return true;
+        }
+
+        // Split into two regions
+
+        scalar cellSizeA = sizeControls_.cellSize(a);
+        scalar cellSizeB = sizeControls_.cellSize(b);
+
+//        if (magSqr(cellSizeA - cellSizeB) < 1e-6)
+//        {
+//            return false;
+//        }
+
+        scalar cellSizeMid = sizeControls_.cellSize(midPoint);
+
+        // Region 1
+        Foam::point midPoint1 = (a + midPoint)/2.0;
+        const scalar cellSizeMid1 = sizeControls_.cellSize(midPoint1);
+
+//        scalar firstDerivative1 =
+//            calcFirstDerivative(cellSizeA, cellSizeMid);
+
+        scalar secondDerivative1 =
+            calcSecondDerivative
+            (
+                a,
+                cellSizeA,
+                midPoint1,
+                cellSizeMid1,
+                midPoint,
+                cellSizeMid
+            );
+
+        // Region 2
+        Foam::point midPoint2 = (midPoint + b)/2.0;
+        const scalar cellSizeMid2 = sizeControls_.cellSize(midPoint2);
+
+//        scalar firstDerivative2 =
+//            calcFirstDerivative(f, cellSizeMid, cellSizeB);
+
+        scalar secondDerivative2 =
+            calcSecondDerivative
+            (
+                midPoint,
+                cellSizeMid,
+                midPoint2,
+                cellSizeMid2,
+                b,
+                cellSizeB
+            );
+
+        // Neither region appears to have an inflection
+        // To be sure should use higher order derivatives
+        if
+        (
+            magSqr(secondDerivative1) < secondDerivTolSqr
+         && magSqr(secondDerivative2) < secondDerivTolSqr
+        )
+        {
+            return false;
+        }
+
+        // Pick region with greatest second derivative
+        if (magSqr(secondDerivative1) > magSqr(secondDerivative2))
+        {
+            b = midPoint;
+            midPoint = midPoint1;
+        }
+        else
+        {
+            a = midPoint;
+            midPoint = midPoint2;
+        }
+    }
+}
+
+
+Foam::pointHit Foam::controlMeshRefinement::findDiscontinuities
+(
+    const linePointRef& l
+) const
+{
+    pointHit p(point::max);
+
+    const scalar tolSqr = sqr(1e-3);
+    const scalar secondDerivTolSqr = sqr(1e-3);
+
+    detectEdge
+    (
+        l.start(),
+        l.end(),
+        p,
+        tolSqr,
+        secondDerivTolSqr
+    );
+
+    return p;
+}
+
+
+// * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::controlMeshRefinement::controlMeshRefinement
+(
+    cellShapeControl& shapeController
+)
+:
+    shapeController_(shapeController),
+    mesh_(shapeController.shapeControlMesh()),
+    sizeControls_(shapeController.sizeAndAlignment()),
+    geometryToConformTo_(sizeControls_.geometryToConformTo())
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::controlMeshRefinement::~controlMeshRefinement()
+{}
+
+
+// * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
+
+void Foam::controlMeshRefinement::initialMeshPopulation
+(
+    const autoPtr<backgroundMeshDecomposition>& decomposition
+)
+{
+    if (shapeController_.shapeControlMesh().vertexCount() > 0)
+    {
+        // Mesh already populated.
+        Info<< "Cell size and alignment mesh already populated." << endl;
+        return;
+    }
+
+    autoPtr<boundBox> overallBoundBox;
+
+    // Need to pass in the background mesh decomposition so that can test if
+    // a point to insert is on the processor.
+    if (Pstream::parRun())
+    {
+//        overallBoundBox.set(new boundBox(decomposition().procBounds()));
+    }
+    else
+    {
+//        overallBoundBox.set
+//        (
+//            new boundBox(geometryToConformTo_.geometry().bounds())
+//        );
+//
+//        mesh_.insertBoundingPoints
+//        (
+//            overallBoundBox(),
+//            sizeControls_
+//        );
+    }
+
+    Map<label> priorityMap;
+
+    const PtrList<cellSizeAndAlignmentControl>& controlFunctions =
+        sizeControls_.controlFunctions();
+
+    forAll(controlFunctions, fI)
+    {
+        const cellSizeAndAlignmentControl& controlFunction =
+            controlFunctions[fI];
+
+        const Switch& forceInsertion =
+            controlFunction.forceInitialPointInsertion();
+
+        Info<< "Inserting points from " << controlFunction.name()
+            << " (" << controlFunction.type() << ")" << endl;
+        Info<< "    Force insertion is " << forceInsertion.asText() << endl;
+
+        pointField pts;
+        scalarField sizes;
+        triadField alignments;
+
+        controlFunction.initialVertices(pts, sizes, alignments);
+
+        Info<< "    Got initial vertices list of size " << pts.size() << endl;
+
+        List<Vb> vertices(pts.size());
+
+        // Clip the minimum size
+        for (label vI = 0; vI < pts.size(); ++vI)
+        {
+            vertices[vI] = Vb(pts[vI], Vb::vtInternalNearBoundary);
+
+            label maxPriority = -1;
+            scalar size = sizeControls_.cellSize(pts[vI], maxPriority);
+
+            if (maxPriority > controlFunction.maxPriority())
+            {
+                vertices[vI].targetCellSize() = max
+                (
+                    size,
+                    shapeController_.minimumCellSize()
+                );
+            }
+//            else if (maxPriority == controlFunction.maxPriority())
+//            {
+//                vertices[vI].targetCellSize() = max
+//                (
+//                    min(sizes[vI], size),
+//                    shapeController_.minimumCellSize()
+//                );
+//            }
+            else
+            {
+                vertices[vI].targetCellSize() = max
+                (
+                    sizes[vI],
+                    shapeController_.minimumCellSize()
+                );
+            }
+
+            vertices[vI].alignment() = alignments[vI];
+        }
+
+        Info<< "    Clipped minimum size" << endl;
+
+        pts.clear();
+        sizes.clear();
+        alignments.clear();
+
+        PackedBoolList keepVertex(vertices.size(), true);
+
+        forAll(vertices, vI)
+        {
+            bool keep = true;
+
+            pointFromPoint pt = topoint(vertices[vI].point());
+
+            if (Pstream::parRun())
+            {
+                keep = decomposition().positionOnThisProcessor(pt);
+            }
+
+            if (keep && geometryToConformTo_.wellOutside(pt, SMALL))
+            {
+                keep = false;
+            }
+
+            if (!keep)
+            {
+                keepVertex[vI] = false;
+            }
+        }
+
+        inplaceSubset(keepVertex, vertices);
+
+        const label preInsertedSize = mesh_.number_of_vertices();
+
+        Info<< "    Check sizes" << endl;
+
+        forAll(vertices, vI)
+        {
+            bool insertPoint = false;
+
+            pointFromPoint pt(topoint(vertices[vI].point()));
+
+            if
+            (
+                mesh_.dimension() < 3
+             || mesh_.is_infinite
+                (
+                    mesh_.locate(vertices[vI].point())
+                )
+            )
+            {
+                insertPoint = true;
+            }
+
+            const scalar interpolatedCellSize = shapeController_.cellSize(pt);
+            const triad interpolatedAlignment =
+                shapeController_.cellAlignment(pt);
+            const scalar calculatedCellSize = vertices[vI].targetCellSize();
+            const triad calculatedAlignment = vertices[vI].alignment();
+
+            if (debug)
+            {
+                Info<< "Point = " << pt << nl
+                    << "  Size(interp) = " << interpolatedCellSize << nl
+                    << "    Size(calc) = " << calculatedCellSize << nl
+                    << " Align(interp) = " << interpolatedAlignment << nl
+                    << "   Align(calc) = " << calculatedAlignment << nl
+                    << endl;
+            }
+
+            const scalar sizeDiff =
+                mag(interpolatedCellSize - calculatedCellSize);
+            const scalar alignmentDiff =
+                diff(interpolatedAlignment, calculatedAlignment);
+
+            if (debug)
+            {
+                Info<< "    size difference = " << sizeDiff << nl
+                    << ", alignment difference = " << alignmentDiff << endl;
+            }
+
+            // @todo Also need to base it on the alignments
+            if
+            (
+                sizeDiff/interpolatedCellSize > 0.1
+             || alignmentDiff > 0.15
+            )
+            {
+                insertPoint = true;
+            }
+
+            if (forceInsertion || insertPoint)
+            {
+                const label oldSize = mesh_.vertexCount();
+
+                cellShapeControlMesh::Vertex_handle insertedVert = mesh_.insert
+                (
+                    pt,
+                    calculatedCellSize,
+                    vertices[vI].alignment(),
+                    Vb::vtInternalNearBoundary
+                );
+
+                if (oldSize == mesh_.vertexCount() - 1)
+                {
+                    priorityMap.insert
+                    (
+                        insertedVert->index(),
+                        controlFunction.maxPriority()
+                    );
+                }
+            }
+        }
+
+        //mesh_.rangeInsertWithInfo(vertices.begin(), vertices.end());
+
+        Info<< "    Inserted "
+            << returnReduce
+               (
+                   label(mesh_.number_of_vertices()) - preInsertedSize,
+                   sumOp<label>()
+               )
+            << "/" << returnReduce(vertices.size(), sumOp<label>())
+            << endl;
+    }
+
+
+
+    forAll(controlFunctions, fI)
+    {
+        const cellSizeAndAlignmentControl& controlFunction =
+            controlFunctions[fI];
+
+        const Switch& forceInsertion =
+            controlFunction.forceInitialPointInsertion();
+
+        Info<< "Inserting points from " << controlFunction.name()
+            << " (" << controlFunction.type() << ")" << endl;
+        Info<< "    Force insertion is " << forceInsertion.asText() << endl;
+
+        DynamicList<Foam::point> extraPts;
+        DynamicList<scalar> extraSizes;
+
+        controlFunction.cellSizeFunctionVertices(extraPts, extraSizes);
+
+        List<Vb> vertices(extraPts.size());
+
+        // Clip the minimum size
+        for (label vI = 0; vI < extraPts.size(); ++vI)
+        {
+            vertices[vI] = Vb(extraPts[vI], Vb::vtUnassigned);
+
+            label maxPriority = -1;
+            scalar size = sizeControls_.cellSize(extraPts[vI], maxPriority);
+
+            if (maxPriority > controlFunction.maxPriority())
+            {
+                vertices[vI].targetCellSize() = max
+                (
+                    size,
+                    shapeController_.minimumCellSize()
+                );
+            }
+            else if (maxPriority == controlFunction.maxPriority())
+            {
+                vertices[vI].targetCellSize() = max
+                (
+                    min(extraSizes[vI], size),
+                    shapeController_.minimumCellSize()
+                );
+            }
+            else
+            {
+                vertices[vI].targetCellSize() = max
+                (
+                    extraSizes[vI],
+                    shapeController_.minimumCellSize()
+                );
+            }
+        }
+
+        PackedBoolList keepVertex(vertices.size(), true);
+
+        forAll(vertices, vI)
+        {
+            bool keep = true;
+
+            pointFromPoint pt = topoint(vertices[vI].point());
+
+            if (Pstream::parRun())
+            {
+                keep = decomposition().positionOnThisProcessor(pt);
+            }
+
+            if (keep && geometryToConformTo_.wellOutside(pt, SMALL))
+            {
+                keep = false;
+            }
+
+            if (!keep)
+            {
+                keepVertex[vI] = false;
+            }
+        }
+
+        inplaceSubset(keepVertex, vertices);
+
+        const label preInsertedSize = mesh_.number_of_vertices();
+
+        forAll(vertices, vI)
+        {
+            bool insertPoint = false;
+
+            pointFromPoint pt(topoint(vertices[vI].point()));
+
+            if
+            (
+                mesh_.dimension() < 3
+             || mesh_.is_infinite
+                (
+                    mesh_.locate(vertices[vI].point())
+                )
+            )
+            {
+                insertPoint = true;
+            }
+
+            const scalar interpolatedCellSize = shapeController_.cellSize(pt);
+            const scalar calculatedCellSize = vertices[vI].targetCellSize();
+
+            if (debug)
+            {
+                Info<< "Point = " << pt << nl
+                    << "  Size(interp) = " << interpolatedCellSize << nl
+                    << "    Size(calc) = " << calculatedCellSize << nl
+                    << endl;
+            }
+
+            const scalar sizeDiff =
+                mag(interpolatedCellSize - calculatedCellSize);
+
+            if (debug)
+            {
+                Info<< "    size difference = " << sizeDiff << endl;
+            }
+
+            // @todo Also need to base it on the alignments
+            if (sizeDiff/interpolatedCellSize > 0.1)
+            {
+                insertPoint = true;
+            }
+
+            if (forceInsertion || insertPoint)
+            {
+                // Check the priority
+
+//                cellShapeControlMesh::Cell_handle ch =
+//                    mesh_.locate(toPoint<cellShapeControlMesh::Point>(pt));
+
+//                if (mesh_.is_infinite(ch))
+//                {
+//                    continue;
+//                }
+
+//                const label newPtPriority = controlFunction.maxPriority();
+
+//                label highestPriority = -1;
+//                for (label cI = 0; cI < 4; ++cI)
+//                {
+//                    if (mesh_.is_infinite(ch->vertex(cI)))
+//                    {
+//                        continue;
+//                    }
+
+//                    const label vertPriority =
+//                        priorityMap[ch->vertex(cI)->index()];
+
+//                    if (vertPriority > highestPriority)
+//                    {
+//                        highestPriority = vertPriority;
+//                    }
+//                }
+
+//                if (newPtPriority >= highestPriority)
+//                {
+//                    const label oldSize = mesh_.vertexCount();
+//
+//                    cellShapeControlMesh::Vertex_handle insertedVert =
+                        mesh_.insert
+                        (
+                            pt,
+                            calculatedCellSize,
+                            vertices[vI].alignment(),
+                            Vb::vtInternal
+                        );
+
+//                    if (oldSize == mesh_.vertexCount() - 1)
+//                    {
+//                        priorityMap.insert
+//                        (
+//                            insertedVert->index(),
+//                            newPtPriority
+//                        );
+//                    }
+//                }
+            }
+        }
+
+       //mesh_.rangeInsertWithInfo(vertices.begin(), vertices.end());
+
+        Info<< "    Inserted extra points "
+            << returnReduce
+               (
+                   label(mesh_.number_of_vertices()) - preInsertedSize,
+                   sumOp<label>()
+               )
+            << "/" << returnReduce(vertices.size(), sumOp<label>())
+            << endl;
+    }
+
+    // Change cell size function of bounding points to be consistent
+    // with their nearest neighbours
+//    for
+//    (
+//        CellSizeDelaunay::Finite_vertices_iterator vit =
+//            mesh_.finite_vertices_begin();
+//        vit != mesh_.finite_vertices_end();
+//        ++vit
+//    )
+//    {
+//        if (vit->uninitialised())
+//        {
+//            // Get its adjacent vertices
+//            std::list<CellSizeDelaunay::Vertex_handle> adjacentVertices;
+//
+//            mesh_.adjacent_vertices
+//            (
+//                vit,
+//                std::back_inserter(adjacentVertices)
+//            );
+//
+//            scalar totalCellSize = 0;
+//            label nVerts = 0;
+//
+//            for
+//            (
+//                std::list<CellSizeDelaunay::Vertex_handle>::iterator avit =
+//                    adjacentVertices.begin();
+//                avit != adjacentVertices.end();
+//                ++avit
+//            )
+//            {
+//                if (!(*avit)->uninitialised())
+//                {
+//                    totalCellSize += (*avit)->targetCellSize();
+//                    nVerts++;
+//                }
+//            }
+//
+//            Pout<< "Changing " << vit->info();
+//
+//            vit->targetCellSize() = totalCellSize/nVerts;
+//            vit->type() = Vb::vtInternalNearBoundary;
+//
+//            Pout<< "to " << vit->info() << endl;
+//        }
+//    }
+}
+
+
+Foam::label Foam::controlMeshRefinement::refineMesh
+(
+    const autoPtr<backgroundMeshDecomposition>& decomposition
+)
+{
+    Info<< "Iterate over "
+        << returnReduce(label(mesh_.number_of_finite_edges()), sumOp<label>())
+        << " cell size mesh edges" << endl;
+
+    DynamicList<Vb> verts(mesh_.number_of_vertices());
+
+    label count = 0;
+
+    for
+    (
+        CellSizeDelaunay::Finite_edges_iterator eit =
+            mesh_.finite_edges_begin();
+        eit != mesh_.finite_edges_end();
+        ++eit
+    )
+    {
+        if (count % 10000 == 0)
+        {
+            Info<< count << " edges, inserted " << verts.size()
+                << " Time = " << mesh_.time().elapsedCpuTime()
+                << endl;
+        }
+        count++;
+
+        CellSizeDelaunay::Cell_handle c = eit->first;
+        CellSizeDelaunay::Vertex_handle vA = c->vertex(eit->second);
+        CellSizeDelaunay::Vertex_handle vB = c->vertex(eit->third);
+
+        if
+        (
+            mesh_.is_infinite(vA)
+         || mesh_.is_infinite(vB)
+         || (vA->referred() && vB->referred())
+         || (vA->referred() && (vA->procIndex() > vB->procIndex()))
+         || (vB->referred() && (vB->procIndex() > vA->procIndex()))
+        )
+        {
+            continue;
+        }
+
+        pointFromPoint ptA(topoint(vA->point()));
+        pointFromPoint ptB(topoint(vB->point()));
+
+        linePointRef l(ptA, ptB);
+
+        const pointHit hitPt = findDiscontinuities(l);
+
+        if (hitPt.hit())
+        {
+            const Foam::point& pt = hitPt.hitPoint();
+
+            if (!geometryToConformTo_.inside(pt))
+            {
+                continue;
+            }
+
+            if (Pstream::parRun())
+            {
+                if (!decomposition().positionOnThisProcessor(pt))
+                {
+                    continue;
+                }
+            }
+
+            verts.append
+            (
+                Vb
+                (
+                    toPoint(pt),
+                    Vb::vtInternal
+                )
+            );
+
+            verts.last().targetCellSize() = sizeControls_.cellSize(pt);
+            verts.last().alignment() = triad::unset;
+        }
+    }
+
+    mesh_.insertPoints(verts, false);
+
+    return verts.size();
+}
+
+
+// * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * * Friend Functions  * * * * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * * Friend Operators * * * * * * * * * * * * * * //
+
+
+// ************************************************************************* //

applications/utilities/mesh/generation/foamyHexMesh/conformalVoronoiMesh/cellShapeControl/controlMeshRefinement/controlMeshRefinement.H

@@ -0,0 +1,149 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 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/>.
+
+Class
+    Foam::controlMeshRefinement
+
+Description
+
+SourceFiles
+    controlMeshRefinementI.H
+    controlMeshRefinement.C
+    controlMeshRefinementIO.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef controlMeshRefinement_H
+#define controlMeshRefinement_H
+
+#include "cellShapeControl.H"
+#include "cellShapeControlMesh.H"
+#include "cellSizeAndAlignmentControls.H"
+#include "conformationSurfaces.H"
+#include "backgroundMeshDecomposition.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                   Class controlMeshRefinement Declaration
+\*---------------------------------------------------------------------------*/
+
+class controlMeshRefinement
+{
+    // Private data
+
+        const cellShapeControl& shapeController_;
+
+        cellShapeControlMesh& mesh_;
+
+        const cellSizeAndAlignmentControls& sizeControls_;
+
+        const conformationSurfaces& geometryToConformTo_;
+
+
+    // Private Member Functions
+
+        scalar calcFirstDerivative
+        (
+            const Foam::point& a,
+            const scalar& cellSizeA,
+            const Foam::point& b,
+            const scalar& cellSizeB
+        ) const;
+
+        scalar calcSecondDerivative
+        (
+            const Foam::point& a,
+            const scalar& cellSizeA,
+            const Foam::point& midPoint,
+            const scalar& cellSizeMid,
+            const Foam::point& b,
+            const scalar& cellSizeB
+        ) const
+        {
+            return (cellSizeA - 2*cellSizeMid + cellSizeB)/magSqr((a - b)/2);
+        }
+
+
+        bool detectEdge
+        (
+            const Foam::point& startPt,
+            const Foam::point& endPt,
+            pointHit& pointFound,
+            const scalar tolSqr,
+            const scalar secondDerivTolSqr
+        ) const;
+
+        pointHit findDiscontinuities(const linePointRef& l) const;
+
+        //- Disallow default bitwise copy construct
+        controlMeshRefinement(const controlMeshRefinement&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const controlMeshRefinement&);
+
+
+public:
+
+        //- Runtime type information
+        ClassName("controlMeshRefinement");
+
+
+    // Constructors
+
+        //- Construct null
+        controlMeshRefinement(cellShapeControl& shapeController);
+
+
+    //- Destructor
+    ~controlMeshRefinement();
+
+
+    // Member Functions
+
+        // Edit
+
+            void initialMeshPopulation
+            (
+                const autoPtr<backgroundMeshDecomposition>& decomposition
+            );
+
+            label refineMesh
+            (
+                const autoPtr<backgroundMeshDecomposition>& decomposition
+            );
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

applications/utilities/mesh/generation/foamyHexMesh/conformalVoronoiMesh/cellShapeControl/smoothAlignmentSolver/smoothAlignmentSolver.C

@@ -0,0 +1,480 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "smoothAlignmentSolver.H"
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+template<class Triangulation, class Type>
+Foam::tmp<Foam::Field<Type> > Foam::smoothAlignmentSolver::filterFarPoints
+(
+    const Triangulation& mesh,
+    const Field<Type>& field
+)
+{
+    tmp<Field<Type> > tNewField(new Field<Type>(field.size()));
+    Field<Type>& newField = tNewField();
+
+    label added = 0;
+    label count = 0;
+
+    for
+    (
+        typename Triangulation::Finite_vertices_iterator vit =
+            mesh.finite_vertices_begin();
+        vit != mesh.finite_vertices_end();
+        ++vit
+    )
+    {
+        if (vit->real())
+        {
+            newField[added++] = field[count];
+        }
+
+        count++;
+    }
+
+    newField.resize(added);
+
+    return tNewField;
+}
+
+
+template<class Triangulation>
+Foam::autoPtr<Foam::mapDistribute> Foam::smoothAlignmentSolver::buildReferredMap
+(
+    const Triangulation& mesh,
+    labelList& indices
+)
+{
+    globalIndex globalIndexing(mesh.vertexCount());
+
+    DynamicList<label> dynIndices(mesh.vertexCount()/10);
+
+    for
+    (
+        typename Triangulation::Finite_vertices_iterator vit =
+            mesh.finite_vertices_begin();
+        vit != mesh.finite_vertices_end();
+        ++vit
+    )
+    {
+        if (vit->referred())
+        {
+            dynIndices.append
+            (
+                globalIndexing.toGlobal(vit->procIndex(), vit->index())
+            );
+        }
+    }
+
+    indices.transfer(dynIndices);
+
+    List<Map<label> > compactMap;
+    return autoPtr<mapDistribute>
+    (
+        new mapDistribute
+        (
+            globalIndexing,
+            indices,
+            compactMap
+        )
+    );
+}
+
+
+template<class Triangulation>
+Foam::autoPtr<Foam::mapDistribute> Foam::smoothAlignmentSolver::buildMap
+(
+    const Triangulation& mesh,
+    labelListList& pointPoints
+)
+{
+    pointPoints.setSize(mesh.vertexCount());
+
+    globalIndex globalIndexing(mesh.vertexCount());
+
+    for
+    (
+        typename Triangulation::Finite_vertices_iterator vit =
+            mesh.finite_vertices_begin();
+        vit != mesh.finite_vertices_end();
+        ++vit
+    )
+    {
+        if (!vit->real())
+        {
+            continue;
+        }
+
+        std::list<typename Triangulation::Vertex_handle> adjVerts;
+        mesh.finite_adjacent_vertices(vit, std::back_inserter(adjVerts));
+
+        DynamicList<label> indices(adjVerts.size());
+
+        for
+        (
+            typename std::list<typename Triangulation::Vertex_handle>::
+                const_iterator adjVertI = adjVerts.begin();
+            adjVertI != adjVerts.end();
+            ++adjVertI
+        )
+        {
+            typename Triangulation::Vertex_handle vh = *adjVertI;
+
+            if (!vh->farPoint())
+            {
+                indices.append
+                (
+                    globalIndexing.toGlobal(vh->procIndex(), vh->index())
+                );
+            }
+        }
+
+        pointPoints[vit->index()].transfer(indices);
+    }
+
+    List<Map<label> > compactMap;
+    return autoPtr<mapDistribute>
+    (
+        new mapDistribute
+        (
+            globalIndexing,
+            pointPoints,
+            compactMap
+        )
+    );
+}
+
+
+template<class Triangulation>
+Foam::tmp<Foam::triadField> Foam::smoothAlignmentSolver::buildAlignmentField
+(
+    const Triangulation& mesh
+)
+{
+    tmp<triadField> tAlignments
+    (
+        new triadField(mesh.vertexCount(), triad::unset)
+    );
+    triadField& alignments = tAlignments();
+
+    for
+    (
+        typename Triangulation::Finite_vertices_iterator vit =
+            mesh.finite_vertices_begin();
+        vit != mesh.finite_vertices_end();
+        ++vit
+    )
+    {
+        if (!vit->real())
+        {
+            continue;
+        }
+
+        alignments[vit->index()] = vit->alignment();
+    }
+
+    return tAlignments;
+}
+
+
+template<class Triangulation>
+Foam::tmp<Foam::pointField> Foam::smoothAlignmentSolver::buildPointField
+(
+    const Triangulation& mesh
+)
+{
+    tmp<pointField> tPoints
+    (
+        new pointField(mesh.vertexCount(), point(GREAT, GREAT, GREAT))
+    );
+    pointField& points = tPoints();
+
+    for
+    (
+        typename Triangulation::Finite_vertices_iterator vit =
+            mesh.finite_vertices_begin();
+        vit != mesh.finite_vertices_end();
+        ++vit
+    )
+    {
+        if (!vit->real())
+        {
+            continue;
+        }
+
+        points[vit->index()] = topoint(vit->point());
+    }
+
+    return tPoints;
+}
+
+
+void Foam::smoothAlignmentSolver::applyBoundaryConditions
+(
+    const triad& fixedAlignment,
+    triad& t
+) const
+{
+    label nFixed = 0;
+
+    forAll(fixedAlignment, dirI)
+    {
+        if (fixedAlignment.set(dirI))
+        {
+            nFixed++;
+        }
+    }
+
+    if (nFixed == 1)
+    {
+        forAll(fixedAlignment, dirI)
+        {
+            if (fixedAlignment.set(dirI))
+            {
+                t.align(fixedAlignment[dirI]);
+            }
+        }
+    }
+    else if (nFixed == 2)
+    {
+        forAll(fixedAlignment, dirI)
+        {
+            if (fixedAlignment.set(dirI))
+            {
+                t[dirI] = fixedAlignment[dirI];
+            }
+            else
+            {
+                t[dirI] = triad::unset[dirI];
+            }
+        }
+
+        t.orthogonalize();
+    }
+    else if (nFixed == 3)
+    {
+        forAll(fixedAlignment, dirI)
+        {
+            if (fixedAlignment.set(dirI))
+            {
+                t[dirI] = fixedAlignment[dirI];
+            }
+        }
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::smoothAlignmentSolver::smoothAlignmentSolver(cellShapeControlMesh& mesh)
+:
+    mesh_(mesh)
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::smoothAlignmentSolver::~smoothAlignmentSolver()
+{}
+
+
+// * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * * //
+
+void Foam::smoothAlignmentSolver::smoothAlignments
+(
+    const label maxSmoothingIterations
+)
+{
+    scalar minResidual = 0;
+
+    labelListList pointPoints;
+    autoPtr<mapDistribute> meshDistributor = buildMap
+    (
+        mesh_,
+        pointPoints
+    );
+
+    triadField alignments(buildAlignmentField(mesh_));
+    pointField points(buildPointField(mesh_));
+
+    // Setup the sizes and alignments on each point
+    triadField fixedAlignments(mesh_.vertexCount(), triad::unset);
+
+    for
+    (
+        CellSizeDelaunay::Finite_vertices_iterator vit =
+            mesh_.finite_vertices_begin();
+        vit != mesh_.finite_vertices_end();
+        ++vit
+    )
+    {
+        if (vit->real())
+        {
+            fixedAlignments[vit->index()] = vit->alignment();
+        }
+    }
+
+    Info<< nl << "Smoothing alignments" << endl;
+
+
+    for (label iter = 0; iter < maxSmoothingIterations; iter++)
+    {
+        Info<< "Iteration " << iter;
+
+        meshDistributor().distribute(points);
+        meshDistributor().distribute(fixedAlignments);
+        meshDistributor().distribute(alignments);
+
+        scalar residual = 0;
+
+        triadField triadAv(alignments.size(), triad::unset);
+
+        forAll(pointPoints, pI)
+        {
+            const labelList& pPoints = pointPoints[pI];
+
+            if (pPoints.empty())
+            {
+                continue;
+            }
+
+            triad& newTriad = triadAv[pI];
+
+            forAll(pPoints, adjPointI)
+            {
+                const label adjPointIndex = pPoints[adjPointI];
+
+                scalar dist = mag(points[pI] - points[adjPointIndex]);
+
+                triad tmpTriad = alignments[adjPointIndex];
+
+                for (direction dir = 0; dir < 3; dir++)
+                {
+                    if (tmpTriad.set(dir))
+                    {
+                        tmpTriad[dir] *= 1.0/(dist + SMALL);
+                    }
+                }
+
+                newTriad += tmpTriad;
+            }
+        }
+
+        // Update the alignment field
+        forAll(alignments, pI)
+        {
+            const triad& oldTriad = alignments[pI];
+            triad& newTriad = triadAv[pI];
+
+            newTriad.normalize();
+            newTriad.orthogonalize();
+
+            // Enforce the boundary conditions
+            const triad& fixedAlignment = fixedAlignments[pI];
+
+            applyBoundaryConditions
+            (
+                fixedAlignment,
+                newTriad
+            );
+
+            newTriad = newTriad.sortxyz();
+
+            // Residual Calculation
+            for (direction dir = 0; dir < 3; ++dir)
+            {
+                if
+                (
+                    newTriad.set(dir)
+                 && oldTriad.set(dir)
+                 && !fixedAlignment.set(dir)
+                )
+                {
+                    residual += diff(oldTriad, newTriad);
+                }
+            }
+
+            alignments[pI] = newTriad;
+        }
+
+        reduce(residual, sumOp<scalar>());
+
+        Info<< ", Residual = "
+            << residual
+              /returnReduce(points.size(), sumOp<label>())
+            << endl;
+
+        if (iter > 0 && residual <= minResidual)
+        {
+            break;
+        }
+    }
+
+    meshDistributor().distribute(alignments);
+
+    for
+    (
+        CellSizeDelaunay::Finite_vertices_iterator vit =
+            mesh_.finite_vertices_begin();
+        vit != mesh_.finite_vertices_end();
+        ++vit
+    )
+    {
+        if (vit->real())
+        {
+            vit->alignment() = alignments[vit->index()];
+        }
+    }
+
+    labelList referredPoints;
+    autoPtr<mapDistribute> referredDistributor = buildReferredMap
+    (
+        mesh_,
+        referredPoints
+    );
+
+    alignments.setSize(mesh_.vertexCount());
+    referredDistributor().distribute(alignments);
+
+    label referredI = 0;
+    for
+    (
+        CellSizeDelaunay::Finite_vertices_iterator vit =
+            mesh_.finite_vertices_begin();
+        vit != mesh_.finite_vertices_end();
+        ++vit
+    )
+    {
+        if (vit->referred())
+        {
+            vit->alignment() = alignments[referredPoints[referredI++]];
+        }
+    }
+}
+
+
+// ************************************************************************* //

applications/utilities/mesh/generation/foamyHexMesh/conformalVoronoiMesh/cellShapeControl/smoothAlignmentSolver/smoothAlignmentSolver.H

@@ -0,0 +1,130 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 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/>.
+
+Class
+    Foam::smoothAlignmentSolver
+
+Description
+
+SourceFiles
+    smoothAlignmentSolverI.H
+    smoothAlignmentSolver.C
+    smoothAlignmentSolverIO.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef smoothAlignmentSolver_H
+#define smoothAlignmentSolver_H
+
+#include "cellShapeControlMesh.H"
+#include "triadField.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                   Class smoothAlignmentSolver Declaration
+\*---------------------------------------------------------------------------*/
+
+class smoothAlignmentSolver
+{
+    // Private data
+
+        cellShapeControlMesh& mesh_;
+
+
+    // Private Member Functions
+
+        template<class Triangulation, class Type>
+        tmp<Field<Type> > filterFarPoints
+        (
+            const Triangulation& mesh,
+            const Field<Type>& field
+        );
+
+        template<class Triangulation>
+        autoPtr<mapDistribute> buildMap
+        (
+            const Triangulation& mesh,
+            labelListList& pointPoints
+        );
+
+        template<class Triangulation>
+        autoPtr<mapDistribute> buildReferredMap
+        (
+            const Triangulation& mesh,
+            labelList& indices
+        );
+
+        template<class Triangulation>
+        tmp<triadField> buildAlignmentField(const Triangulation& mesh);
+
+        template<class Triangulation>
+        tmp<pointField> buildPointField(const Triangulation& mesh);
+
+        //- Apply the fixed alignments to the triad
+        void applyBoundaryConditions
+        (
+            const triad& fixedAlignment,
+            triad& t
+        ) const;
+
+        //- Disallow default bitwise copy construct
+        smoothAlignmentSolver(const smoothAlignmentSolver&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const smoothAlignmentSolver&);
+
+
+public:
+
+    // Constructors
+
+        //- Construct null
+        smoothAlignmentSolver(cellShapeControlMesh& mesh);
+
+
+    //- Destructor
+    ~smoothAlignmentSolver();
+
+
+    // Member Functions
+
+        // Edit
+
+            //- Smooth the alignments on the mesh
+            void smoothAlignments(const label maxSmoothingIterations);
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

applications/utilities/mesh/generation/foamyHexMesh/conformalVoronoiMesh/cellSizeControlSurfaces/cellSizeFunction/cellSizeFunction/cellSizeFunction.C

@@ -0,0 +1,169 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012-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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "cellSizeFunction.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(cellSizeFunction, 0);
+    defineRunTimeSelectionTable(cellSizeFunction, dictionary);
+
+    scalar cellSizeFunction::snapToSurfaceTol_ = 1e-10;
+}
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::cellSizeFunction::cellSizeFunction
+(
+    const word& type,
+    const dictionary& cellSizeFunctionDict,
+    const searchableSurface& surface,
+    const scalar& defaultCellSize,
+    const labelList regionIndices
+)
+:
+    dictionary(cellSizeFunctionDict),
+    surface_(surface),
+    surfaceCellSizeFunction_
+    (
+        surfaceCellSizeFunction::New
+        (
+            cellSizeFunctionDict,
+            surface,
+            defaultCellSize
+        )
+    ),
+    coeffsDict_(subDict(type + "Coeffs")),
+    defaultCellSize_(defaultCellSize),
+    regionIndices_(regionIndices),
+    sideMode_(),
+    priority_(readLabel(cellSizeFunctionDict.lookup("priority", true)))
+{
+    word mode = cellSizeFunctionDict.lookup("mode", true);
+
+    if (surface_.hasVolumeType())
+    {
+        if (mode == "inside")
+        {
+            sideMode_ = smInside;
+        }
+        else if (mode == "outside")
+        {
+            sideMode_ = smOutside;
+        }
+        else if (mode == "bothSides")
+        {
+            sideMode_ = rmBothsides;
+        }
+        else
+        {
+            FatalErrorIn("searchableSurfaceControl::searchableSurfaceControl")
+                << "Unknown mode, expected: inside, outside or bothSides" << nl
+                << exit(FatalError);
+        }
+    }
+    else
+    {
+        if (mode != "bothSides")
+        {
+            WarningIn("searchableSurfaceControl::searchableSurfaceControl")
+                << "surface does not support volumeType, defaulting mode to "
+                << "bothSides."
+                << endl;
+        }
+
+        sideMode_ = rmBothsides;
+    }
+
+    if (debug)
+    {
+        Info<< nl
+            << "Cell size function for surface " << surface.name()
+            << ", " << mode
+            << ", priority = " << priority_
+            << ", regions = " << regionIndices_
+            << endl;
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * * Selectors * * * * * * * * * * * * * * * //
+
+Foam::autoPtr<Foam::cellSizeFunction> Foam::cellSizeFunction::New
+(
+    const dictionary& cellSizeFunctionDict,
+    const searchableSurface& surface,
+    const scalar& defaultCellSize,
+    const labelList regionIndices
+)
+{
+    word cellSizeFunctionTypeName
+    (
+        cellSizeFunctionDict.lookup("cellSizeFunction")
+    );
+
+    Info<< indent << "Selecting cellSizeFunction " << cellSizeFunctionTypeName
+        << endl;
+
+    dictionaryConstructorTable::iterator cstrIter =
+        dictionaryConstructorTablePtr_->find(cellSizeFunctionTypeName);
+
+    if (cstrIter == dictionaryConstructorTablePtr_->end())
+    {
+        FatalErrorIn
+        (
+            "cellSizeFunction::New(dictionary&, "
+            "const conformalVoronoiMesh&, const searchableSurface&)"
+        )   << "Unknown cellSizeFunction type "
+            << cellSizeFunctionTypeName
+            << endl << endl
+            << "Valid cellSizeFunction types are :" << endl
+            << dictionaryConstructorTablePtr_->toc()
+            << exit(FatalError);
+    }
+
+    return autoPtr<cellSizeFunction>
+    (
+        cstrIter()
+        (
+            cellSizeFunctionDict,
+            surface,
+            defaultCellSize,
+            regionIndices
+        )
+    );
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::cellSizeFunction::~cellSizeFunction()
+{}
+
+
+// ************************************************************************* //

applications/utilities/mesh/generation/foamyHexMesh/conformalVoronoiMesh/cellSizeControlSurfaces/cellSizeFunction/cellSizeFunction/cellSizeFunction.H

@@ -0,0 +1,221 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012-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/>.
+
+Class
+    Foam::cellSizeFunction
+
+Description
+    Abstract base class for specifying target cell sizes
+
+SourceFiles
+    cellSizeFunction.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef cellSizeFunction_H
+#define cellSizeFunction_H
+
+#include "point.H"
+#include "conformalVoronoiMesh.H"
+#include "searchableSurface.H"
+#include "dictionary.H"
+#include "autoPtr.H"
+#include "runTimeSelectionTables.H"
+#include "surfaceCellSizeFunction.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                     Class cellSizeFunction Declaration
+\*---------------------------------------------------------------------------*/
+
+class cellSizeFunction
+:
+    public dictionary
+{
+
+public:
+
+    //- Surface side mode
+    enum sideMode
+    {
+        smInside,         // Control inside the surface
+        smOutside,        // Control outside the surface
+        rmBothsides       // Control on both sides of a surface
+    };
+
+    //- Runtime type information
+    TypeName("cellSizeFunction");
+
+
+protected:
+
+    // Static data
+
+        //- Point closeness tolerance to a surface where the function "snaps" to
+        //  including the surface
+        static scalar snapToSurfaceTol_;
+
+
+    // Protected data
+
+        //- Reference to the searchableSurface that cellSizeFunction
+        //  relates to
+        const searchableSurface& surface_;
+
+        //- Cell size at the surface
+        scalarField surfaceCellSize_;
+
+        autoPtr<surfaceCellSizeFunction> surfaceCellSizeFunction_;
+
+        //- Method details dictionary
+        dictionary coeffsDict_;
+
+        const scalar& defaultCellSize_;
+
+        //- Index of the region of the surface that this cell size function
+        //  applies to
+        const labelList regionIndices_;
+
+        //- Mode of size specification, i.e. inside, outside or bothSides
+        sideMode sideMode_;
+
+        label priority_;
+
+
+private:
+
+    // Private Member Functions
+
+        //- Disallow default bitwise copy construct
+        cellSizeFunction(const cellSizeFunction&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const cellSizeFunction&);
+
+
+public:
+
+    // Declare run-time constructor selection table
+
+        declareRunTimeSelectionTable
+        (
+            autoPtr,
+            cellSizeFunction,
+            dictionary,
+            (
+                const dictionary& cellSizeFunctionDict,
+                const searchableSurface& surface,
+                const scalar& defaultCellSize,
+                const labelList regionIndices
+            ),
+            (cellSizeFunctionDict, surface, defaultCellSize, regionIndices)
+        );
+
+
+    // Constructors
+
+        //- Construct from components
+        cellSizeFunction
+        (
+            const word& type,
+            const dictionary& cellSizeFunctionDict,
+            const searchableSurface& surface,
+            const scalar& defaultCellSize,
+            const labelList regionIndices
+        );
+
+
+    // Selectors
+
+        //- Return a reference to the selected cellSizeFunction
+        static autoPtr<cellSizeFunction> New
+        (
+            const dictionary& cellSizeFunctionDict,
+            const searchableSurface& surface,
+            const scalar& defaultCellSize,
+            const labelList regionIndices
+        );
+
+
+    //- Destructor
+    virtual ~cellSizeFunction();
+
+
+    // Member Functions
+
+        //- Const access to the details dictionary
+        inline const dictionary& coeffsDict() const
+        {
+            return coeffsDict_;
+        }
+
+        virtual bool sizeLocations
+        (
+            const pointIndexHit& hitPt,
+            const vector& n,
+            pointField& shapePts,
+            scalarField& shapeSizes
+        ) const = 0;
+
+        //- Modify scalar argument to the cell size specified by function.
+        //  Return a boolean specifying if the function was used, i.e. false if
+        //  the point was not in range of the surface for a spatially varying
+        //  size.
+        virtual bool cellSize
+        (
+            const point& pt,
+            scalar& size
+        ) const = 0;
+
+
+        virtual bool setCellSize
+        (
+            const pointField& pts
+        )
+        {
+            WarningIn("cellSizeFunction::setCellSize(const pointField&)")
+                << "Not overloaded."
+                << endl;
+            return false;
+        }
+
+        label priority() const
+        {
+            return priority_;
+        }
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

applications/utilities/mesh/generation/foamyHexMesh/conformalVoronoiMesh/cellSizeControlSurfaces/cellSizeFunction/linearDistance/linearDistance.C

@@ -0,0 +1,256 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012-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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "linearDistance.H"
+#include "addToRunTimeSelectionTable.H"
+#include "triSurfaceMesh.H"
+#include "triSurfaceFields.H"
+#include "volumeType.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+defineTypeNameAndDebug(linearDistance, 0);
+addToRunTimeSelectionTable(cellSizeFunction, linearDistance, dictionary);
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+linearDistance::linearDistance
+(
+    const dictionary& initialPointsDict,
+    const searchableSurface& surface,
+    const scalar& defaultCellSize,
+    const labelList regionIndices
+)
+:
+    cellSizeFunction
+    (
+        typeName,
+        initialPointsDict,
+        surface,
+        defaultCellSize,
+        regionIndices
+    ),
+    distanceCellSize_
+    (
+        readScalar(coeffsDict().lookup("distanceCellSizeCoeff"))
+       *defaultCellSize
+    ),
+    distance_
+    (
+        readScalar(coeffsDict().lookup("distanceCoeff"))*defaultCellSize
+    ),
+    distanceSqr_(sqr(distance_))
+{}
+
+
+// * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * * //
+
+scalar linearDistance::sizeFunction
+(
+    const point& pt,
+    scalar d,
+    label index
+) const
+{
+    const scalar interpolatedSize
+        = surfaceCellSizeFunction_().interpolate(pt, index);
+
+    scalar gradient
+        = (distanceCellSize_ - interpolatedSize)
+          /distance_;
+
+    scalar size = gradient*d + interpolatedSize;
+
+    return size;
+}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+bool linearDistance::sizeLocations
+(
+    const pointIndexHit& hitPt,
+    const vector& n,
+    pointField& shapePts,
+    scalarField& shapeSizes
+) const
+{
+    const Foam::point& pt = hitPt.hitPoint();
+
+    if (sideMode_ == rmBothsides)
+    {
+        shapePts.resize(2);
+        shapeSizes.resize(2);
+
+        shapePts[0] = pt - n*distance_;
+        shapeSizes[0] = distanceCellSize_;
+
+        shapePts[1] = pt + n*distance_;
+        shapeSizes[1] = distanceCellSize_;
+    }
+    else if (sideMode_ == smInside)
+    {
+        shapePts.resize(1);
+        shapeSizes.resize(1);
+
+        shapePts[0] = pt - n*distance_;
+        shapeSizes[0] = distanceCellSize_;
+    }
+    else if (sideMode_ == smOutside)
+    {
+        shapePts.resize(1);
+        shapeSizes.resize(1);
+
+        shapePts[0] = pt + n*distance_;
+        shapeSizes[0] = distanceCellSize_;
+    }
+
+    return false;
+}
+
+
+bool linearDistance::cellSize(const point& pt, scalar& size) const
+{
+    size = 0;
+
+    List<pointIndexHit> hits;
+
+    surface_.findNearest
+    (
+        pointField(1, pt),
+        scalarField(1, distanceSqr_),
+        regionIndices_,
+        hits
+    );
+
+    const pointIndexHit& hitInfo = hits[0];
+
+    if (hitInfo.hit())
+    {
+        const point& hitPt = hitInfo.hitPoint();
+        const label hitIndex = hitInfo.index();
+
+        const scalar dist = mag(pt - hitPt);
+
+        if (sideMode_ == rmBothsides)
+        {
+            size = sizeFunction(hitPt, dist, hitIndex);
+
+            return true;
+        }
+
+        // If the nearest point is essentially on the surface, do not do a
+        // getVolumeType calculation, as it will be prone to error.
+        if (dist < snapToSurfaceTol_)
+        {
+            size = sizeFunction(hitPt, 0, hitIndex);
+
+            return true;
+        }
+
+        pointField ptF(1, pt);
+        List<volumeType> vTL;
+
+        surface_.getVolumeType(ptF, vTL);
+
+        bool functionApplied = false;
+
+        if
+        (
+            sideMode_ == smInside
+         && vTL[0] == volumeType::INSIDE
+        )
+        {
+            size = sizeFunction(hitPt, dist, hitIndex);
+
+            functionApplied = true;
+        }
+        else if
+        (
+            sideMode_ == smOutside
+         && vTL[0] == volumeType::OUTSIDE
+        )
+        {
+            size = sizeFunction(hitPt, dist, hitIndex);
+
+            functionApplied = true;
+        }
+
+        return functionApplied;
+    }
+
+    return false;
+}
+
+
+bool linearDistance::setCellSize(const pointField& pts)
+{
+//    labelHashSet surfaceAlreadyHit(surfaceCellSize_.size());
+
+//    forAll(pts, ptI)
+//    {
+//        const Foam::point& pt = pts[ptI];
+
+//        List<pointIndexHit> hits;
+
+//        surface_.findNearest
+//        (
+//            pointField(1, pt),
+//            scalarField(1, distanceSqr_),
+//            regionIndices_,
+//            hits
+//        );
+
+//        const label surfHitI = hits[0].index();
+
+//        if
+//        (
+//            hits[0].hit()
+//         && !surfaceAlreadyHit.found(surfHitI)
+//        )
+//        {
+//            // Halving cell size is arbitrary
+//            surfaceCellSizeFunction_().refineSurfaceSize(surfHitI);
+
+//            surfaceAlreadyHit.insert(surfHitI);
+//        }
+//    }
+
+//    return true;
+    return false;
+}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// ************************************************************************* //

applications/utilities/mesh/generation/foamyHexMesh/conformalVoronoiMesh/cellSizeControlSurfaces/cellSizeFunction/linearDistance/linearDistance.H

@@ -0,0 +1,132 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012-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/>.
+
+Class
+    Foam::linearDistance
+
+Description
+
+SourceFiles
+    linearDistance.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef linearDistance_H
+#define linearDistance_H
+
+#include "cellSizeFunction.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                         Class linearDistance Declaration
+\*---------------------------------------------------------------------------*/
+
+class linearDistance
+:
+    public cellSizeFunction
+{
+
+private:
+
+    // Private data
+
+        //- cell size at distance_ from the surface
+        scalar distanceCellSize_;
+
+        //- distance from the surface to control over
+        scalar distance_;
+
+        //- distance squared
+        scalar distanceSqr_;
+
+
+    // Private Member Functions
+
+        //- Calculate the cell size as a function of the given distance
+        scalar sizeFunction(const point& pt, scalar d, label index) const;
+
+
+public:
+
+    //- Runtime type information
+    TypeName("linearDistance");
+
+    // Constructors
+
+        //- Construct from components
+        linearDistance
+        (
+            const dictionary& initialPointsDict,
+            const searchableSurface& surface,
+            const scalar& defaultCellSize,
+            const labelList regionIndices
+        );
+
+
+    //- Destructor
+    virtual ~linearDistance()
+    {}
+
+
+    // Member Functions
+
+
+        virtual bool sizeLocations
+        (
+            const pointIndexHit& hitPt,
+            const vector& n,
+            pointField& shapePts,
+            scalarField& shapeSizes
+        ) const;
+
+        //- Modify scalar argument to the cell size specified by function.
+        //  Return a boolean specifying if the function was used, i.e. false if
+        //  the point was not in range of the surface for a spatially varying
+        //  size.
+        virtual bool cellSize
+        (
+            const point& pt,
+            scalar& size
+        ) const;
+
+        //- Adapt local cell size. Return true if anything changed.
+        virtual bool setCellSize
+        (
+            const pointField& pts
+        );
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

applications/utilities/mesh/generation/foamyHexMesh/conformalVoronoiMesh/cellSizeControlSurfaces/cellSizeFunction/linearSpatial/linearSpatial.C

@@ -0,0 +1,180 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012-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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "linearSpatial.H"
+#include "addToRunTimeSelectionTable.H"
+#include "volumeType.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+defineTypeNameAndDebug(linearSpatial, 0);
+addToRunTimeSelectionTable(cellSizeFunction, linearSpatial, dictionary);
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+linearSpatial::linearSpatial
+(
+    const dictionary& initialPointsDict,
+    const searchableSurface& surface,
+    const scalar& defaultCellSize,
+    const labelList regionIndices
+)
+:
+    cellSizeFunction
+    (
+        typeName,
+        initialPointsDict,
+        surface,
+        defaultCellSize,
+        regionIndices
+    ),
+    referencePoint_(coeffsDict().lookup("referencePoint")),
+    referenceCellSize_
+    (
+        readScalar(coeffsDict().lookup("referenceCellSizeCoeff"))
+       *defaultCellSize
+    ),
+    direction_(coeffsDict().lookup("direction")),
+    cellSizeGradient_(readScalar(coeffsDict().lookup("cellSizeGradient")))
+{
+    direction_ /= mag(direction_);
+}
+
+
+// * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * * //
+
+scalar linearSpatial::sizeFunction(const point& pt) const
+{
+    return
+        referenceCellSize_
+      + ((pt - referencePoint_) & direction_)*cellSizeGradient_;
+}
+
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+bool linearSpatial::sizeLocations
+(
+    const pointIndexHit& hitPt,
+    const vector& n,
+    pointField& shapePts,
+    scalarField& shapeSizes
+) const
+{
+    if (sideMode_ == rmBothsides)
+    {
+    }
+    else if (sideMode_ == smInside)
+    {
+    }
+    else if (sideMode_ == smOutside)
+    {
+    }
+
+    return false;
+}
+
+
+bool linearSpatial::cellSize
+(
+    const point& pt,
+    scalar& size
+) const
+{
+    if (sideMode_ == rmBothsides)
+    {
+        size = sizeFunction(pt);
+
+        return true;
+    }
+
+    size = 0;
+
+    List<pointIndexHit> hits;
+
+    surface_.findNearest
+    (
+        pointField(1, pt),
+        scalarField(1, sqr(snapToSurfaceTol_)),
+        regionIndices_,
+        hits
+    );
+
+    const pointIndexHit& hitInfo = hits[0];
+
+    // If the nearest point is essentially on the surface, do not do a
+    // getVolumeType calculation, as it will be prone to error.
+    if (hitInfo.hit())
+    {
+        size = sizeFunction(pt);
+
+        return true;
+    }
+
+    pointField ptF(1, pt);
+    List<volumeType> vTL;
+
+    surface_.getVolumeType(ptF, vTL);
+
+    bool functionApplied = false;
+
+    if
+    (
+        sideMode_ == smInside
+     && vTL[0] == volumeType::INSIDE
+    )
+    {
+        size = sizeFunction(pt);
+
+        functionApplied = true;
+    }
+    else if
+    (
+        sideMode_ == smOutside
+     && vTL[0] == volumeType::OUTSIDE
+    )
+    {
+        size = sizeFunction(pt);
+
+        functionApplied = true;
+    }
+
+    return functionApplied;
+
+}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// ************************************************************************* //

applications/utilities/mesh/generation/foamyHexMesh/conformalVoronoiMesh/cellSizeControlSurfaces/cellSizeFunction/linearSpatial/linearSpatial.H

@@ -0,0 +1,130 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012-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/>.
+
+Class
+    Foam::linearSpatial
+
+Description
+
+SourceFiles
+    linearSpatial.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef linearSpatial_H
+#define linearSpatial_H
+
+#include "cellSizeFunction.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                         Class linearSpatial Declaration
+\*---------------------------------------------------------------------------*/
+
+class linearSpatial
+:
+    public cellSizeFunction
+{
+
+private:
+
+    // Private data
+
+        //- Reference point for spatial size grading
+        point referencePoint_;
+
+        //- Cell size at reference point
+        scalar referenceCellSize_;
+
+        //- Direction of cell size grading, stored as unit vector, may be
+        //  supplied with any magnitude
+        vector direction_;
+
+        //- Gradient of cell size change in direction of direction_
+        scalar cellSizeGradient_;
+
+
+    // Private Member Functions
+
+        //- Calculate the cell size as a function of the given position
+        scalar sizeFunction(const point& pt) const;
+
+
+public:
+
+    //- Runtime type information
+    TypeName("linearSpatial");
+
+    // Constructors
+
+        //- Construct from components
+        linearSpatial
+        (
+            const dictionary& initialPointsDict,
+            const searchableSurface& surface,
+            const scalar& defaultCellSize,
+            const labelList regionIndices
+        );
+
+
+    //- Destructor
+    virtual ~linearSpatial()
+    {}
+
+
+    // Member Functions
+
+
+        virtual bool sizeLocations
+        (
+            const pointIndexHit& hitPt,
+            const vector& n,
+            pointField& shapePts,
+            scalarField& shapeSizes
+        ) const;
+
+        //- Modify scalar argument to the cell size specified by function.
+        //  Return a boolean specifying if the function was used, i.e. false if
+        //  the point was not in range of the surface for a spatially varying
+        //  size.
+        virtual bool cellSize
+        (
+            const point& pt,
+            scalar& size
+        ) const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

applications/utilities/mesh/generation/foamyHexMesh/conformalVoronoiMesh/cellSizeControlSurfaces/cellSizeFunction/surfaceOffsetLinearDistance/surfaceOffsetLinearDistance.C

@@ -0,0 +1,298 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012-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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "surfaceOffsetLinearDistance.H"
+#include "addToRunTimeSelectionTable.H"
+#include "volumeType.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+defineTypeNameAndDebug(surfaceOffsetLinearDistance, 0);
+addToRunTimeSelectionTable
+(
+    cellSizeFunction,
+    surfaceOffsetLinearDistance,
+    dictionary
+);
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+surfaceOffsetLinearDistance::surfaceOffsetLinearDistance
+(
+    const dictionary& initialPointsDict,
+    const searchableSurface& surface,
+    const scalar& defaultCellSize,
+    const labelList regionIndices
+)
+:
+    cellSizeFunction
+    (
+        typeName,
+        initialPointsDict,
+        surface,
+        defaultCellSize,
+        regionIndices
+    ),
+    distanceCellSize_
+    (
+        readScalar(coeffsDict().lookup("distanceCellSizeCoeff"))
+       *defaultCellSize
+    ),
+    surfaceOffset_
+    (
+        readScalar(coeffsDict().lookup("surfaceOffsetCoeff"))*defaultCellSize
+    ),
+    totalDistance_(),
+    totalDistanceSqr_()
+{
+    if
+    (
+        coeffsDict().found("totalDistanceCoeff")
+     || coeffsDict().found("linearDistanceCoeff")
+    )
+    {
+        if
+        (
+            coeffsDict().found("totalDistanceCoeff")
+         && coeffsDict().found("linearDistanceCoeff")
+        )
+        {
+            FatalErrorIn
+            (
+                "surfaceOffsetLinearDistance::surfaceOffsetLinearDistance"
+                "("
+                "    const dictionary& initialPointsDict,"
+                "    const searchableSurface& surface,"
+                "    const scalar& defaultCellSize"
+                ")"
+            )
+                << "totalDistanceCoeff and linearDistanceCoeff found, "
+                << "specify one or other, not both."
+                << nl << exit(FatalError) << endl;
+        }
+
+        if (coeffsDict().found("totalDistanceCoeff"))
+        {
+            totalDistance_ =
+                readScalar(coeffsDict().lookup("totalDistanceCoeff"))
+               *defaultCellSize;
+        }
+        else
+        {
+            totalDistance_ =
+                readScalar(coeffsDict().lookup("linearDistanceCoeff"))
+               *defaultCellSize
+              + surfaceOffset_;
+        }
+    }
+    else
+    {
+        FatalErrorIn
+        (
+            "surfaceOffsetLinearDistance::surfaceOffsetLinearDistance"
+            "("
+            "    const dictionary& initialPointsDict,"
+            "    const searchableSurface& surface,"
+            "    const scalar& defaultCellSize"
+            ")"
+        )
+            << "totalDistanceCoeff or linearDistanceCoeff not found."
+            << nl << exit(FatalError) << endl;
+    }
+
+    totalDistanceSqr_ = sqr(totalDistance_);
+}
+
+
+// * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * * //
+
+scalar surfaceOffsetLinearDistance::sizeFunction
+(
+    const point& pt,
+    scalar d,
+    label index
+) const
+{
+    const scalar interpolatedSize
+        = surfaceCellSizeFunction_().interpolate(pt, index);
+
+    if (d <= surfaceOffset_)
+    {
+        return interpolatedSize;
+    }
+
+    scalar gradient =
+        (distanceCellSize_ - interpolatedSize)
+       /(totalDistance_ - surfaceOffset_);
+
+    scalar intercept = interpolatedSize - gradient*surfaceOffset_;
+
+    return gradient*d + intercept;
+}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+bool surfaceOffsetLinearDistance::sizeLocations
+(
+    const pointIndexHit& hitPt,
+    const vector& n,
+    pointField& shapePts,
+    scalarField& shapeSizes
+) const
+{
+    const Foam::point& pt = hitPt.hitPoint();
+
+    const scalar offsetCellSize =
+        surfaceCellSizeFunction_().interpolate(pt, hitPt.index());
+
+    if (sideMode_ == rmBothsides)
+    {
+        shapePts.resize(4);
+        shapeSizes.resize(4);
+
+        shapePts[0] = pt - n*surfaceOffset_;
+        shapeSizes[0] = offsetCellSize;
+        shapePts[1] = pt - n*totalDistance_;
+        shapeSizes[1] = distanceCellSize_;
+
+        shapePts[2] = pt + n*surfaceOffset_;
+        shapeSizes[2] = offsetCellSize;
+        shapePts[3] = pt + n*totalDistance_;
+        shapeSizes[3] = distanceCellSize_;
+    }
+    else if (sideMode_ == smInside)
+    {
+        shapePts.resize(2);
+        shapeSizes.resize(2);
+
+        shapePts[0] = pt - n*surfaceOffset_;
+        shapeSizes[0] = offsetCellSize;
+        shapePts[1] = pt - n*totalDistance_;
+        shapeSizes[1] = distanceCellSize_;
+    }
+    else if (sideMode_ == smOutside)
+    {
+        shapePts.resize(2);
+        shapeSizes.resize(2);
+
+        shapePts[0] = pt + n*surfaceOffset_;
+        shapeSizes[0] = offsetCellSize;
+        shapePts[1] = pt + n*totalDistance_;
+        shapeSizes[1] = distanceCellSize_;
+    }
+
+    return true;
+}
+
+
+bool surfaceOffsetLinearDistance::cellSize
+(
+    const point& pt,
+    scalar& size
+) const
+{
+    size = 0;
+
+    List<pointIndexHit> hits;
+
+    surface_.findNearest
+    (
+        pointField(1, pt),
+        scalarField(1, totalDistanceSqr_),
+        regionIndices_,
+        hits
+    );
+
+    const pointIndexHit& hitInfo = hits[0];
+
+    if (hitInfo.hit())
+    {
+        const point& hitPt = hitInfo.hitPoint();
+        const label hitIndex = hitInfo.index();
+
+        const scalar dist = mag(pt - hitPt);
+
+        if (sideMode_ == rmBothsides)
+        {
+            size = sizeFunction(hitPt, dist, hitIndex);
+
+            return true;
+        }
+
+        // If the nearest point is essentially on the surface, do not do a
+        // getVolumeType calculation, as it will be prone to error.
+        if (mag(pt  - hitInfo.hitPoint()) < snapToSurfaceTol_)
+        {
+            size = sizeFunction(hitPt, 0, hitIndex);
+
+            return true;
+        }
+
+        pointField ptF(1, pt);
+        List<volumeType> vTL;
+
+        surface_.getVolumeType(ptF, vTL);
+
+        bool functionApplied = false;
+
+        if
+        (
+            sideMode_ == smInside
+         && vTL[0] == volumeType::INSIDE
+        )
+        {
+            size = sizeFunction(hitPt, dist, hitIndex);
+
+            functionApplied = true;
+        }
+        else if
+        (
+            sideMode_ == smOutside
+         && vTL[0] == volumeType::OUTSIDE
+        )
+        {
+            size = sizeFunction(hitPt, dist, hitIndex);
+
+            functionApplied = true;
+        }
+
+        return functionApplied;
+    }
+
+    return false;
+}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// ************************************************************************* //

applications/utilities/mesh/generation/foamyHexMesh/conformalVoronoiMesh/cellSizeControlSurfaces/cellSizeFunction/surfaceOffsetLinearDistance/surfaceOffsetLinearDistance.H

@@ -0,0 +1,129 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012-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/>.
+
+Class
+    Foam::surfaceOffsetLinearDistance
+
+Description
+
+SourceFiles
+    surfaceOffsetLinearDistance.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef surfaceOffsetLinearDistance_H
+#define surfaceOffsetLinearDistance_H
+
+#include "cellSizeFunction.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                 Class surfaceOffsetLinearDistance Declaration
+\*---------------------------------------------------------------------------*/
+
+class surfaceOffsetLinearDistance
+:
+    public cellSizeFunction
+{
+
+private:
+
+    // Private data
+
+        //- cell size at distance_ from the surface
+        scalar distanceCellSize_;
+
+        //- Offset distance from surface for constant size portion
+        scalar surfaceOffset_;
+
+        //- Total distance from the surface to control over (distance +
+        //  surfaceOffset)
+        scalar totalDistance_;
+
+        //- totalDistance squared
+        scalar totalDistanceSqr_;
+
+
+    // Private Member Functions
+
+        //- Calculate the cell size as a function of the given distance
+        scalar sizeFunction(const point& pt, scalar d, label index) const;
+
+
+public:
+
+    //- Runtime type information
+    TypeName("surfaceOffsetLinearDistance");
+
+    // Constructors
+
+        //- Construct from components
+        surfaceOffsetLinearDistance
+        (
+            const dictionary& initialPointsDict,
+            const searchableSurface& surface,
+            const scalar& defaultCellSize,
+            const labelList regionIndices
+        );
+
+
+    //- Destructor
+    virtual ~surfaceOffsetLinearDistance()
+    {}
+
+
+    // Member Functions
+
+        virtual bool sizeLocations
+        (
+            const pointIndexHit& hitPt,
+            const vector& n,
+            pointField& shapePts,
+            scalarField& shapeSizes
+        ) const;
+
+        //- Modify scalar argument to the cell size specified by function.
+        //  Return a boolean specifying if the function was used, i.e. false if
+        //  the point was not in range of the surface for a spatially varying
+        //  size.
+        virtual bool cellSize
+        (
+            const point& pt,
+            scalar& size
+        ) const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

applications/utilities/mesh/generation/foamyHexMesh/conformalVoronoiMesh/cellSizeControlSurfaces/cellSizeFunction/uniform/uniform.C

@@ -0,0 +1,202 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012-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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "uniform.H"
+#include "addToRunTimeSelectionTable.H"
+#include "volumeType.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+defineTypeNameAndDebug(uniform, 0);
+addToRunTimeSelectionTable(cellSizeFunction, uniform, dictionary);
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+uniform::uniform
+(
+    const dictionary& initialPointsDict,
+    const searchableSurface& surface,
+    const scalar& defaultCellSize,
+    const labelList regionIndices
+)
+:
+    cellSizeFunction
+    (
+        typeName,
+        initialPointsDict,
+        surface,
+        defaultCellSize,
+        regionIndices
+    )
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+bool uniform::sizeLocations
+(
+    const pointIndexHit& hitPt,
+    const vector& n,
+    pointField& shapePts,
+    scalarField& shapeSizes
+) const
+{
+    shapePts.setSize(0);
+    shapeSizes.setSize(0);
+
+    return true;
+}
+
+
+bool uniform::cellSize
+(
+    const point& pt,
+    scalar& size
+) const
+{
+    List<pointIndexHit> hits;
+
+    surface_.findNearest
+    (
+        pointField(1, pt),
+        scalarField(1, sqr(GREAT)),
+        regionIndices_,
+        hits
+    );
+
+    const pointIndexHit& hitInfo = hits[0];
+
+    if (hitInfo.hit())
+    {
+        const point& hitPt = hitInfo.hitPoint();
+        const label index = hitInfo.index();
+
+        if (sideMode_ == rmBothsides)
+        {
+            size = surfaceCellSizeFunction_().interpolate(hitPt, index);
+
+            return true;
+        }
+
+        size = 0;
+
+        List<pointIndexHit> closeToSurfaceHits;
+
+        surface_.findNearest
+        (
+            pointField(1, pt),
+            scalarField(1, sqr(snapToSurfaceTol_)),
+            regionIndices_,
+            closeToSurfaceHits
+        );
+
+        const pointIndexHit& closeToSurface = closeToSurfaceHits[0];
+
+        // If the nearest point is essentially on the surface, do not do a
+        // getVolumeType calculation, as it will be prone to error.
+        if (closeToSurface.hit())
+        {
+            size = surfaceCellSizeFunction_().interpolate(hitPt, index);
+
+            return true;
+        }
+
+        pointField ptF(1, pt);
+        List<volumeType> vTL(1);
+
+        surface_.getVolumeType(ptF, vTL);
+
+        bool functionApplied = false;
+
+        if
+        (
+            sideMode_ == smInside
+         && vTL[0] == volumeType::INSIDE
+        )
+        {
+            size = surfaceCellSizeFunction_().interpolate(hitPt, index);
+
+            functionApplied = true;
+        }
+        else if
+        (
+            sideMode_ == smOutside
+         && vTL[0] == volumeType::OUTSIDE
+        )
+        {
+            size = surfaceCellSizeFunction_().interpolate(hitPt, index);
+
+            functionApplied = true;
+        }
+
+        return functionApplied;
+    }
+
+    return false;
+}
+
+
+bool uniform::setCellSize
+(
+    const pointField& pts
+)
+{
+//    labelHashSet surfaceAlreadyHit(cellSize_.size());
+//
+//    forAll(pts, ptI)
+//    {
+//        const Foam::point& pt = pts[ptI];
+//
+//        List<pointIndexHit> hits;
+//
+//        surface_.findNearest
+//        (
+//            pointField(1, pt),
+//            scalarField(1, sqr(GREAT)),
+//            hits
+//        );
+//
+//        if (hits[0].hit() && !surfaceAlreadyHit.found(hits[0].index()))
+//        {
+//            surfaceCellSizeFunction_().refineCellSize(hits[0].index());
+//
+//            surfaceAlreadyHit.insert(hits[0].index());
+//        }
+//    }
+
+    return true;
+}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// ************************************************************************* //

applications/utilities/mesh/generation/foamyHexMesh/conformalVoronoiMesh/cellSizeControlSurfaces/cellSizeFunction/uniform/uniform.H

@@ -0,0 +1,116 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012-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/>.
+
+Class
+    Foam::uniform
+
+Description
+
+SourceFiles
+    uniform.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef uniform_H
+#define uniform_H
+
+#include "cellSizeFunction.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                           Class uniform Declaration
+\*---------------------------------------------------------------------------*/
+
+class uniform
+:
+    public cellSizeFunction
+{
+
+private:
+
+    // Private data
+
+
+public:
+
+    //- Runtime type information
+    TypeName("uniform");
+
+    // Constructors
+
+        //- Construct from components
+        uniform
+        (
+            const dictionary& initialPointsDict,
+            const searchableSurface& surface,
+            const scalar& defaultCellSize,
+            const labelList regionIndices
+        );
+
+
+    //- Destructor
+    virtual ~uniform()
+    {}
+
+
+    // Member Functions
+
+        virtual bool sizeLocations
+        (
+            const pointIndexHit& hitPt,
+            const vector& n,
+            pointField& shapePts,
+            scalarField& shapeSizes
+        ) const;
+
+        //- Modify scalar argument to the cell size specified by function.
+        //  Return a boolean specifying if the function was used, i.e. false if
+        //  the point was not in range of the surface for a spatially varying
+        //  size.
+        virtual bool cellSize
+        (
+            const point& pt,
+            scalar& size
+        ) const;
+
+        //- Adapt local cell size. Return true if anything changed.
+        virtual bool setCellSize
+        (
+            const pointField& pts
+        );
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

applications/utilities/mesh/generation/foamyHexMesh/conformalVoronoiMesh/cellSizeControlSurfaces/cellSizeFunction/uniformDistance/uniformDistance.C

@@ -0,0 +1,229 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012-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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "uniformDistance.H"
+#include "addToRunTimeSelectionTable.H"
+#include "volumeType.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+defineTypeNameAndDebug(uniformDistance, 0);
+addToRunTimeSelectionTable(cellSizeFunction, uniformDistance, dictionary);
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+uniformDistance::uniformDistance
+(
+    const dictionary& initialPointsDict,
+    const searchableSurface& surface,
+    const scalar& defaultCellSize,
+    const labelList regionIndices
+)
+:
+    cellSizeFunction
+    (
+        typeName,
+        initialPointsDict,
+        surface,
+        defaultCellSize,
+        regionIndices
+    ),
+    distance_
+    (
+        readScalar(coeffsDict().lookup("distanceCoeff"))*defaultCellSize
+    ),
+    distanceSqr_(sqr(distance_))
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+
+bool uniformDistance::sizeLocations
+(
+    const pointIndexHit& hitPt,
+    const vector& n,
+    pointField& shapePts,
+    scalarField& shapeSizes
+) const
+{
+    const Foam::point& pt = hitPt.hitPoint();
+
+    const scalar distanceCellSize =
+        surfaceCellSizeFunction_().interpolate(pt, hitPt.index());
+
+    if (sideMode_ == rmBothsides)
+    {
+        shapePts.resize(2);
+        shapeSizes.resize(2);
+
+        shapePts[0] = pt - n*distance_;
+        shapeSizes[0] = distanceCellSize;
+
+        shapePts[1] = pt + n*distance_;
+        shapeSizes[1] = distanceCellSize;
+    }
+    else if (sideMode_ == smInside)
+    {
+        shapePts.resize(1);
+        shapeSizes.resize(1);
+
+        shapePts[0] = pt - n*distance_;
+        shapeSizes[0] = distanceCellSize;
+    }
+    else if (sideMode_ == smOutside)
+    {
+        shapePts.resize(1);
+        shapeSizes.resize(1);
+
+        shapePts[0] = pt - n*distance_;
+        shapeSizes[0] = distanceCellSize;
+    }
+
+    return false;
+}
+
+
+bool uniformDistance::cellSize
+(
+    const point& pt,
+    scalar& size
+) const
+{
+    size = 0;
+
+    List<pointIndexHit> hits;
+
+    surface_.findNearest
+    (
+        pointField(1, pt),
+        scalarField(1, distanceSqr_),
+        regionIndices_,
+        hits
+    );
+
+    const pointIndexHit& hitInfo = hits[0];
+
+    if (hitInfo.hit())
+    {
+        const point& hitPt = hitInfo.hitPoint();
+        const label index = hitInfo.index();
+
+        if (sideMode_ == rmBothsides)
+        {
+            size = surfaceCellSizeFunction_().interpolate(hitPt, index);
+
+            return true;
+        }
+
+        // If the nearest point is essentially on the surface, do not do a
+        // getVolumeType calculation, as it will be prone to error.
+        if (mag(pt  - hitInfo.hitPoint()) < snapToSurfaceTol_)
+        {
+            size = surfaceCellSizeFunction_().interpolate(hitPt, index);
+
+            return true;
+        }
+
+        pointField ptF(1, pt);
+        List<volumeType> vTL;
+
+        surface_.getVolumeType(ptF, vTL);
+
+        bool functionApplied = false;
+
+        if
+        (
+            sideMode_ == smInside
+         && vTL[0] == volumeType::INSIDE
+        )
+        {
+            size = surfaceCellSizeFunction_().interpolate(hitPt, index);
+
+            functionApplied = true;
+        }
+        else if
+        (
+            sideMode_ == smOutside
+         && vTL[0] == volumeType::OUTSIDE
+        )
+        {
+            size = surfaceCellSizeFunction_().interpolate(hitPt, index);
+
+            functionApplied = true;
+        }
+
+        return functionApplied;
+    }
+
+    return false;
+}
+
+
+bool uniformDistance::setCellSize
+(
+    const pointField& pts
+)
+{
+//    labelHashSet surfaceAlreadyHit(surface_.size());
+//
+//    forAll(pts, ptI)
+//    {
+//        const Foam::point& pt = pts[ptI];
+//
+//        List<pointIndexHit> hits;
+//
+//        surface_.findNearest
+//        (
+//            pointField(1, pt),
+//            scalarField(1, distanceSqr_),
+//            regionIndices_,
+//            hits
+//        );
+//
+//        if (hits[0].hit() && !surfaceAlreadyHit.found(hits[0].index()))
+//        {
+//            surfaceCellSizeFunction_().refineSurfaceSize(hits[0].index());
+//
+//            surfaceAlreadyHit.insert(hits[0].index());
+//        }
+//    }
+//
+//    return true;
+
+    return false;
+}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// ************************************************************************* //

applications/utilities/mesh/generation/foamyHexMesh/conformalVoronoiMesh/cellSizeControlSurfaces/cellSizeFunction/uniformDistance/uniformDistance.H

@@ -0,0 +1,122 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012-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/>.
+
+Class
+    Foam::uniformDistance
+
+Description
+
+SourceFiles
+    uniformDistance.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef uniformDistance_H
+#define uniformDistance_H
+
+#include "cellSizeFunction.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                        Class uniformDistance Declaration
+\*---------------------------------------------------------------------------*/
+
+class uniformDistance
+:
+    public cellSizeFunction
+{
+
+private:
+
+    // Private data
+
+        //- Distance
+        scalar distance_;
+
+        //- Distance squared
+        scalar distanceSqr_;
+
+
+public:
+
+    //- Runtime type information
+    TypeName("uniformDistance");
+
+    // Constructors
+
+        //- Construct from components
+        uniformDistance
+        (
+            const dictionary& initialPointsDict,
+            const searchableSurface& surface,
+            const scalar& defaultCellSize,
+            const labelList regionIndices
+        );
+
+
+    //- Destructor
+    virtual ~uniformDistance()
+    {}
+
+
+    // Member Functions
+
+        virtual bool sizeLocations
+        (
+            const pointIndexHit& hitPt,
+            const vector& n,
+            pointField& shapePts,
+            scalarField& shapeSizes
+        ) const;
+
+        //- Modify scalar argument to the cell size specified by function.
+        //  Return a boolean specifying if the function was used, i.e. false if
+        //  the point was not in range of the surface for a spatially varying
+        //  size.
+        virtual bool cellSize
+        (
+            const point& pt,
+            scalar& size
+        ) const;
+
+        //- Adapt local cell size. Return true if anything changed.
+        virtual bool setCellSize
+        (
+            const pointField& pts
+        );
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

applications/utilities/mesh/generation/foamyHexMesh/conformalVoronoiMesh/cellSizeControlSurfaces/surfaceCellSizeFunction/cellSizeCalculationType/automatic/automatic.C

@@ -0,0 +1,305 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012-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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "automatic.H"
+#include "addToRunTimeSelectionTable.H"
+#include "triSurfaceMesh.H"
+#include "vtkSurfaceWriter.H"
+#include "primitivePatchInterpolation.H"
+#include "Time.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(automatic, 0);
+    addToRunTimeSelectionTable(cellSizeCalculationType, automatic, dictionary);
+}
+
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+void Foam::automatic::smoothField(triSurfaceScalarField& surf)
+{
+    label nSmoothingIterations = 10;
+
+    for (label iter = 0; iter < nSmoothingIterations; ++iter)
+    {
+        const pointField& faceCentres = surface_.faceCentres();
+
+        forAll(surf, sI)
+        {
+            const labelList& faceFaces = surface_.faceFaces()[sI];
+
+            const point& fC = faceCentres[sI];
+            const scalar value = surf[sI];
+
+            scalar newValue = 0;
+            scalar totalDist = 0;
+
+            label nFaces = 0;
+
+            forAll(faceFaces, fI)
+            {
+                const label faceLabel = faceFaces[fI];
+                const point& faceCentre = faceCentres[faceLabel];
+
+                const scalar faceValue = surf[faceLabel];
+                const scalar distance = mag(faceCentre - fC);
+
+                newValue += faceValue/(distance + SMALL);
+
+                totalDist += 1.0/(distance + SMALL);
+
+                if (value < faceValue)
+                {
+                    nFaces++;
+                }
+            }
+
+            // Do not smooth out the peak values
+            if (nFaces == faceFaces.size())
+            {
+                continue;
+            }
+
+            surf[sI] = newValue/totalDist;
+        }
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::automatic::automatic
+(
+    const dictionary& cellSizeCalcTypeDict,
+    const triSurfaceMesh& surface,
+    const scalar& defaultCellSize
+)
+:
+    cellSizeCalculationType
+    (
+        typeName,
+        cellSizeCalcTypeDict,
+        surface,
+        defaultCellSize
+    ),
+    coeffsDict_(cellSizeCalcTypeDict.subDict(typeName + "Coeffs")),
+    surfaceName_(surface.searchableSurface::name()),
+    readCurvature_(Switch(coeffsDict_.lookup("curvature"))),
+    curvatureFile_(coeffsDict_.lookup("curvatureFile")),
+    readFeatureProximity_(Switch(coeffsDict_.lookup("featureProximity"))),
+    featureProximityFile_(coeffsDict_.lookup("featureProximityFile")),
+    readInternalCloseness_(Switch(coeffsDict_.lookup("internalCloseness"))),
+    internalClosenessFile_(coeffsDict_.lookup("internalClosenessFile")),
+    curvatureCellSizeCoeff_
+    (
+        readScalar(coeffsDict_.lookup("curvatureCellSizeCoeff"))
+    ),
+    maximumCellSize_
+    (
+        readScalar(coeffsDict_.lookup("maximumCellSizeCoeff"))*defaultCellSize
+    )
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+Foam::tmp<Foam::triSurfacePointScalarField> Foam::automatic::load()
+{
+    Info<< indent
+        << "Calculating cell size on surface: " << surfaceName_ << endl;
+
+    tmp<triSurfacePointScalarField> tPointCellSize
+    (
+        new triSurfacePointScalarField
+        (
+            IOobject
+            (
+                surfaceName_ + ".cellSize",
+                surface_.searchableSurface::time().constant(),
+                "triSurface",
+                surface_.searchableSurface::time(),
+                IOobject::NO_READ,
+                IOobject::NO_WRITE
+            ),
+            surface_,
+            dimLength,
+            scalarField(surface_.nPoints(), maximumCellSize_)
+        )
+    );
+
+    triSurfacePointScalarField& pointCellSize = tPointCellSize();
+
+    if (readCurvature_)
+    {
+        Info<< indent
+            << "Reading curvature         : " << curvatureFile_ << endl;
+
+        triSurfacePointScalarField curvature
+        (
+            IOobject
+            (
+                curvatureFile_,
+                surface_.searchableSurface::time().constant(),
+                "triSurface",
+                surface_.searchableSurface::time(),
+                IOobject::MUST_READ,
+                IOobject::NO_WRITE
+            ),
+            surface_,
+            dimLength,
+            true
+        );
+
+        forAll(pointCellSize, pI)
+        {
+            pointCellSize[pI] =
+                min
+                (
+                    1.0
+                   /max
+                    (
+                        (1.0/curvatureCellSizeCoeff_)*mag(curvature[pI]),
+                        1.0/maximumCellSize_
+                    ),
+                    pointCellSize[pI]
+                );
+        }
+    }
+
+    PrimitivePatchInterpolation
+    <
+        PrimitivePatch<labelledTri, ::Foam::List, pointField, point>
+    > patchInterpolate(surface_);
+
+    const Map<label>& meshPointMap = surface_.meshPointMap();
+
+    if (readInternalCloseness_)
+    {
+        Info<< indent
+            << "Reading internal closeness: " << internalClosenessFile_ << endl;
+
+        triSurfaceScalarField internalCloseness
+        (
+            IOobject
+            (
+                internalClosenessFile_,
+                surface_.searchableSurface::time().constant(),
+                "triSurface",
+                surface_.searchableSurface::time(),
+                IOobject::MUST_READ,
+                IOobject::NO_WRITE
+            ),
+            surface_,
+            dimLength,
+            true
+        );
+
+        scalarField internalClosenessPointField
+        (
+            patchInterpolate.faceToPointInterpolate(internalCloseness)
+        );
+
+        forAll(pointCellSize, pI)
+        {
+            pointCellSize[pI] =
+                min
+                (
+                    internalClosenessPointField[meshPointMap[pI]],
+                    pointCellSize[pI]
+                );
+        }
+    }
+
+    if (readFeatureProximity_)
+    {
+        Info<< indent
+            << "Reading feature proximity : " << featureProximityFile_ << endl;
+
+        triSurfaceScalarField featureProximity
+        (
+            IOobject
+            (
+                featureProximityFile_,
+                surface_.searchableSurface::time().constant(),
+                "triSurface",
+                surface_.searchableSurface::time(),
+                IOobject::MUST_READ,
+                IOobject::NO_WRITE
+            ),
+            surface_,
+            dimLength,
+            true
+        );
+
+        scalarField featureProximityPointField
+        (
+            patchInterpolate.faceToPointInterpolate(featureProximity)
+        );
+
+        forAll(pointCellSize, pI)
+        {
+            pointCellSize[pI] =
+                min
+                (
+                    featureProximityPointField[meshPointMap[pI]],
+                    pointCellSize[pI]
+                );
+        }
+    }
+
+    //smoothField(surfaceCellSize);
+
+    pointCellSize.write();
+
+    if (debug)
+    {
+        faceList faces(surface_.size());
+
+        forAll(surface_, fI)
+        {
+            faces[fI] = surface_.triSurface::operator[](fI).triFaceFace();
+        }
+
+        vtkSurfaceWriter().write
+        (
+            surface_.searchableSurface::time().constant()/"triSurface",
+            surfaceName_.lessExt().name(),
+            surface_.points(),
+            faces,
+            "cellSize",
+            pointCellSize,
+            true,
+            true
+        );
+    }
+
+    return tPointCellSize;
+}
+
+
+// ************************************************************************* //

applications/utilities/mesh/generation/foamyHexMesh/conformalVoronoiMesh/cellSizeControlSurfaces/surfaceCellSizeFunction/cellSizeCalculationType/automatic/automatic.H

@@ -0,0 +1,127 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012-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/>.
+
+Class
+    Foam::automatic
+
+Description
+
+SourceFiles
+    automatic.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef automatic_H
+#define automatic_H
+
+#include "cellSizeCalculationType.H"
+#include "triSurfaceFields.H"
+#include "PrimitivePatchInterpolation.H"
+#include "Switch.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+class triSurfaceMesh;
+
+/*---------------------------------------------------------------------------*\
+                         Class automatic Declaration
+\*---------------------------------------------------------------------------*/
+
+class automatic
+:
+    public cellSizeCalculationType
+{
+
+private:
+
+    // Private data
+
+        //- Dictionary of coefficients for automatic cell sizing
+        const dictionary& coeffsDict_;
+
+        //- Name of the surface. Used to write the cell size field
+        const fileName surfaceName_;
+
+        const Switch readCurvature_;
+        const word curvatureFile_;
+
+        const Switch readFeatureProximity_;
+        const word featureProximityFile_;
+
+        const Switch readInternalCloseness_;
+        const word internalClosenessFile_;
+
+        //- The curvature values are multiplied by the inverse of this value to
+        //  get the cell size
+        const scalar curvatureCellSizeCoeff_;
+
+        //- The maximum allowable sell size
+        const scalar maximumCellSize_;
+
+
+    // Private Member Functions
+
+        void smoothField(triSurfaceScalarField& surf);
+
+
+public:
+
+    //- Runtime type information
+    TypeName("automatic");
+
+
+    // Constructors
+
+        //- Construct from components
+        automatic
+        (
+            const dictionary& cellSizeCalcTypeDict,
+            const triSurfaceMesh& surface,
+            const scalar& defaultCellSize
+        );
+
+
+    //- Destructor
+    virtual ~automatic()
+    {}
+
+
+    // Member Functions
+
+        //- Load the cell size field
+        virtual tmp<triSurfacePointScalarField> load();
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

applications/utilities/mesh/generation/foamyHexMesh/conformalVoronoiMesh/cellSizeControlSurfaces/surfaceCellSizeFunction/cellSizeCalculationType/cellSizeCalculationType/cellSizeCalculationType.C

@@ -0,0 +1,101 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012-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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "cellSizeCalculationType.H"
+#include "addToRunTimeSelectionTable.H"
+#include "triSurfaceMesh.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(cellSizeCalculationType, 0);
+    defineRunTimeSelectionTable(cellSizeCalculationType, dictionary);
+}
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::cellSizeCalculationType::cellSizeCalculationType
+(
+    const word& type,
+    const dictionary& cellSizeCalculationTypeDict,
+    const triSurfaceMesh& surface,
+    const scalar& defaultCellSize
+)
+:
+    cellSizeCalculationTypeDict_(cellSizeCalculationTypeDict),
+    surface_(surface),
+    defaultCellSize_(defaultCellSize)
+{}
+
+
+// * * * * * * * * * * * * * * * * * Selectors * * * * * * * * * * * * * * * //
+
+Foam::autoPtr<Foam::cellSizeCalculationType> Foam::cellSizeCalculationType::New
+(
+    const dictionary& cellSizeCalculationTypeDict,
+    const triSurfaceMesh& surface,
+    const scalar& defaultCellSize
+)
+{
+    word cellSizeCalculationTypeTypeName
+    (
+        cellSizeCalculationTypeDict.lookup("cellSizeCalculationType")
+    );
+
+    Info<< indent << "Selecting cellSizeCalculationType "
+        << cellSizeCalculationTypeTypeName << endl;
+
+    dictionaryConstructorTable::iterator cstrIter =
+        dictionaryConstructorTablePtr_->find(cellSizeCalculationTypeTypeName);
+
+    if (cstrIter == dictionaryConstructorTablePtr_->end())
+    {
+        FatalErrorIn
+        (
+            "cellSizeCalculationType::New(dictionary&, "
+            "const conformalVoronoiMesh&, const searchableSurface&)"
+        )   << "Unknown cellSizeCalculationType type "
+            << cellSizeCalculationTypeTypeName
+            << endl << endl
+            << "Valid cellSizeCalculationType types are :" << endl
+            << dictionaryConstructorTablePtr_->toc()
+            << exit(FatalError);
+    }
+
+    return autoPtr<cellSizeCalculationType>
+    (
+        cstrIter()(cellSizeCalculationTypeDict, surface, defaultCellSize)
+    );
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::cellSizeCalculationType::~cellSizeCalculationType()
+{}
+
+
+// ************************************************************************* //

applications/utilities/mesh/generation/foamyHexMesh/conformalVoronoiMesh/cellSizeControlSurfaces/surfaceCellSizeFunction/cellSizeCalculationType/cellSizeCalculationType/cellSizeCalculationType.H

@@ -0,0 +1,141 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012-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/>.
+
+Class
+    Foam::cellSizeCalculationType
+
+Description
+    Abstract base class for specifying target cell sizes
+
+SourceFiles
+    cellSizeCalculationType.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef cellSizeCalculationType_H
+#define cellSizeCalculationType_H
+
+#include "autoPtr.H"
+#include "runTimeSelectionTables.H"
+#include "triSurfaceFields.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+class triSurfaceMesh;
+
+/*---------------------------------------------------------------------------*\
+                     Class cellSizeCalculationType Declaration
+\*---------------------------------------------------------------------------*/
+
+class cellSizeCalculationType
+{
+
+protected:
+
+        const dictionary& cellSizeCalculationTypeDict_;
+
+        //- Reference to the triSurfaceMesh
+        const triSurfaceMesh& surface_;
+
+        const scalar& defaultCellSize_;
+
+
+private:
+
+    // Private Member Functions
+
+        //- Disallow default bitwise copy construct
+        cellSizeCalculationType(const cellSizeCalculationType&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const cellSizeCalculationType&);
+
+
+public:
+
+    //- Runtime type information
+    TypeName("cellSizeCalculationType");
+
+
+    // Declare run-time constructor selection table
+
+        declareRunTimeSelectionTable
+        (
+            autoPtr,
+            cellSizeCalculationType,
+            dictionary,
+            (
+                const dictionary& cellSizeCalculationTypeDict,
+                const triSurfaceMesh& surface,
+                const scalar& defaultCellSize
+            ),
+            (cellSizeCalculationTypeDict, surface, defaultCellSize)
+        );
+
+
+    // Constructors
+
+        //- Construct from components
+        cellSizeCalculationType
+        (
+            const word& type,
+            const dictionary& cellSizeCalculationTypeDict,
+            const triSurfaceMesh& surface,
+            const scalar& defaultCellSize
+        );
+
+
+    // Selectors
+
+        //- Return a reference to the selected cellSizeCalculationType
+        static autoPtr<cellSizeCalculationType> New
+        (
+            const dictionary& cellSizeCalculationTypeDict,
+            const triSurfaceMesh& surface,
+            const scalar& defaultCellSize
+        );
+
+
+    //- Destructor
+    virtual ~cellSizeCalculationType();
+
+
+    // Member Functions
+
+        //- Load the cell size
+        virtual tmp<triSurfacePointScalarField> load() = 0;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

applications/utilities/mesh/generation/foamyHexMesh/conformalVoronoiMesh/cellSizeControlSurfaces/surfaceCellSizeFunction/cellSizeCalculationType/fieldFromFile/fieldFromFile.C

@@ -0,0 +1,104 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012-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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "fieldFromFile.H"
+#include "addToRunTimeSelectionTable.H"
+#include "triSurfaceMesh.H"
+#include "triSurfaceFields.H"
+#include "Time.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(fieldFromFile, 0);
+    addToRunTimeSelectionTable
+    (
+        cellSizeCalculationType,
+        fieldFromFile,
+        dictionary
+    );
+}
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::fieldFromFile::fieldFromFile
+(
+    const dictionary& cellSizeCalcTypeDict,
+    const triSurfaceMesh& surface,
+    const scalar& defaultCellSize
+)
+:
+    cellSizeCalculationType
+    (
+        typeName,
+        cellSizeCalcTypeDict,
+        surface,
+        defaultCellSize
+    ),
+    coeffsDict_(cellSizeCalcTypeDict.subDict(typeName + "Coeffs")),
+    fileName_
+    (
+        cellSizeCalcTypeDict.subDict(typeName + "Coeffs").lookup("fieldFile")
+    ),
+    cellSizeMultipleCoeff_
+    (
+        coeffsDict_.lookupOrDefault<scalar>("cellSizeMultipleCoeff", 1)
+    )
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+Foam::tmp<Foam::triSurfacePointScalarField> Foam::fieldFromFile::load()
+{
+    Info<< indent << "Loading: " << fileName_ << endl;
+
+    tmp<triSurfacePointScalarField> pointCellSize
+    (
+        new triSurfacePointScalarField
+        (
+            IOobject
+            (
+                fileName_,
+                surface_.searchableSurface::time().constant(),
+                "triSurface",
+                surface_.searchableSurface::time(),
+                IOobject::MUST_READ,
+                IOobject::NO_WRITE
+            ),
+            surface_,
+            dimLength,
+            true
+        )
+    );
+
+    pointCellSize() *= cellSizeMultipleCoeff_;
+
+    return pointCellSize;
+}
+
+
+// ************************************************************************* //

applications/utilities/mesh/generation/foamyHexMesh/conformalVoronoiMesh/cellSizeControlSurfaces/surfaceCellSizeFunction/cellSizeCalculationType/fieldFromFile/fieldFromFile.H

@@ -0,0 +1,109 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012-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/>.
+
+Class
+    Foam::fieldFromFile
+
+Description
+
+SourceFiles
+    fieldFromFile.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef fieldFromFile_H
+#define fieldFromFile_H
+
+#include "cellSizeCalculationType.H"
+#include "triSurfaceFields.H"
+#include "PrimitivePatchInterpolation.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+class triSurfaceMesh;
+
+/*---------------------------------------------------------------------------*\
+                       Class fieldFromFile Declaration
+\*---------------------------------------------------------------------------*/
+
+class fieldFromFile
+:
+    public cellSizeCalculationType
+{
+
+private:
+
+    // Private data
+
+        //- Dictionary of coefficients for automatic cell sizing
+        const dictionary& coeffsDict_;
+
+        //- Name of the triSurfaceScalarField file to load in. Must be in
+        //  constant/triSurface
+        const word fileName_;
+
+        //- Multiply all the point sizes by this value
+        const scalar cellSizeMultipleCoeff_;
+
+
+public:
+
+    //- Runtime type information
+    TypeName("fieldFromFile");
+
+
+    // Constructors
+
+        //- Construct from components
+        fieldFromFile
+        (
+            const dictionary& cellSizeCalcTypeDict,
+            const triSurfaceMesh& surface,
+            const scalar& defaultCellSize
+        );
+
+
+    //- Destructor
+    virtual ~fieldFromFile()
+    {}
+
+
+    // Member Functions
+
+        //- Load the cell size field
+        virtual tmp<triSurfacePointScalarField> load();
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

applications/utilities/mesh/generation/foamyHexMesh/conformalVoronoiMesh/cellSizeControlSurfaces/surfaceCellSizeFunction/nonUniformField/nonUniformField.C

@@ -0,0 +1,134 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012-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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "nonUniformField.H"
+#include "triSurfaceMesh.H"
+#include "searchableSurface.H"
+#include "addToRunTimeSelectionTable.H"
+#include "Time.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(nonUniformField, 0);
+    addToRunTimeSelectionTable
+    (
+        surfaceCellSizeFunction,
+        nonUniformField,
+        dictionary
+    );
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::nonUniformField::nonUniformField
+(
+    const dictionary& cellSizeFunctionDict,
+    const searchableSurface& surface,
+    const scalar& defaultCellSize
+)
+:
+    surfaceCellSizeFunction
+    (
+        typeName,
+        cellSizeFunctionDict,
+        surface,
+        defaultCellSize
+    ),
+    surfaceTriMesh_(refCast<const triSurfaceMesh>(surface)),
+    cellSizeCalculationType_
+    (
+        cellSizeCalculationType::New
+        (
+            coeffsDict(),
+            surfaceTriMesh_,
+            defaultCellSize
+        )
+    ),
+    pointCellSize_
+    (
+        IOobject
+        (
+            "pointCellSize.cellSize",
+            surfaceTriMesh_.searchableSurface::time().constant(),
+            "triSurface",
+            surfaceTriMesh_.searchableSurface::time(),
+            IOobject::NO_READ,
+            IOobject::NO_WRITE
+        ),
+        surfaceTriMesh_,
+        dimLength,
+        false
+    )
+{
+    Info<< incrIndent;
+
+    pointCellSize_ = cellSizeCalculationType_().load();
+
+    Info<< indent << "Cell size field statistics:" << nl
+        << indent << "    Minimum: " << min(pointCellSize_).value() << nl
+        << indent << "    Average: " << average(pointCellSize_).value() << nl
+        << indent << "    Maximum: " << max(pointCellSize_).value() << endl;
+
+    Info<< decrIndent;
+}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+Foam::scalar Foam::nonUniformField::interpolate
+(
+    const point& pt,
+    const label index
+) const
+{
+    const face& faceHitByPt = surfaceTriMesh_.triSurface::operator[](index);
+
+    const pointField& pts = surfaceTriMesh_.points();
+//    const Map<label>& pMap = surfaceTriMesh_.meshPointMap();
+
+    triPointRef tri
+    (
+        pts[faceHitByPt[0]],
+        pts[faceHitByPt[1]],
+        pts[faceHitByPt[2]]
+    );
+
+    scalarList bary(3, 0.0);
+
+    tri.barycentric(pt, bary);
+
+//    return pointCellSize_[pMap[faceHitByPt[0]]]*bary[0]
+//         + pointCellSize_[pMap[faceHitByPt[1]]]*bary[1]
+//         + pointCellSize_[pMap[faceHitByPt[2]]]*bary[2];
+    return pointCellSize_[faceHitByPt[0]]*bary[0]
+         + pointCellSize_[faceHitByPt[1]]*bary[1]
+         + pointCellSize_[faceHitByPt[2]]*bary[2];
+}
+
+
+// ************************************************************************* //

applications/utilities/mesh/generation/foamyHexMesh/conformalVoronoiMesh/cellSizeControlSurfaces/surfaceCellSizeFunction/nonUniformField/nonUniformField.H

@@ -0,0 +1,122 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012-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/>.
+
+Class
+    Foam::nonUniformField
+
+Description
+
+SourceFiles
+    nonUniformField.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef nonUniformField_H
+#define nonUniformField_H
+
+#include "triSurfaceFields.H"
+#include "PrimitivePatchInterpolation.H"
+#include "surfaceCellSizeFunction.H"
+#include "cellSizeCalculationType.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+class triSurfaceMesh;
+class searchableSurface;
+
+/*---------------------------------------------------------------------------*\
+                           Class nonUniformField Declaration
+\*---------------------------------------------------------------------------*/
+
+class nonUniformField
+:
+    public surfaceCellSizeFunction
+{
+
+protected:
+
+    // Private typedef
+
+        typedef PrimitivePatchInterpolation
+        <
+            PrimitivePatch<labelledTri, List, pointField, point>
+        >   primitivePatchInterpolation;
+
+
+    // Private data
+
+        const triSurfaceMesh& surfaceTriMesh_;
+
+        autoPtr<cellSizeCalculationType> cellSizeCalculationType_;
+
+        triSurfacePointScalarField pointCellSize_;
+
+
+public:
+
+    //- Runtime type information
+    TypeName("nonUniformField");
+
+
+    // Constructors
+
+        //- Construct from components
+        nonUniformField
+        (
+            const dictionary& cellSizeFunctionDict,
+            const searchableSurface& surface,
+            const scalar& defaultCellSize
+        );
+
+
+    //- Destructor
+    virtual ~nonUniformField()
+    {}
+
+
+    // Member Functions
+
+        // Query
+
+            //- Return the interpolated cell size for a point in the given
+            //  surface triangle
+            virtual scalar interpolate
+            (
+                const point& pt,
+                const label index
+            ) const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

applications/utilities/mesh/generation/foamyHexMesh/conformalVoronoiMesh/cellSizeControlSurfaces/surfaceCellSizeFunction/surfaceCellSizeFunction/surfaceCellSizeFunction.C

@@ -0,0 +1,105 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012-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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "surfaceCellSizeFunction.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(surfaceCellSizeFunction, 0);
+    defineRunTimeSelectionTable(surfaceCellSizeFunction, dictionary);
+}
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::surfaceCellSizeFunction::surfaceCellSizeFunction
+(
+    const word& type,
+    const dictionary& surfaceCellSizeFunctionDict,
+    const searchableSurface& surface,
+    const scalar& defaultCellSize
+)
+:
+    dictionary(surfaceCellSizeFunctionDict),
+    surface_(surface),
+    coeffsDict_(subDict(type + "Coeffs")),
+    defaultCellSize_(defaultCellSize),
+    refinementFactor_
+    (
+        lookupOrDefault<scalar>("refinementFactor", 1.0)
+    )
+{}
+
+
+// * * * * * * * * * * * * * * * * * Selectors * * * * * * * * * * * * * * * //
+
+Foam::autoPtr<Foam::surfaceCellSizeFunction> Foam::surfaceCellSizeFunction::New
+(
+    const dictionary& surfaceCellSizeFunctionDict,
+    const searchableSurface& surface,
+    const scalar& defaultCellSize
+)
+{
+    word surfaceCellSizeFunctionTypeName
+    (
+        surfaceCellSizeFunctionDict.lookup("surfaceCellSizeFunction")
+    );
+
+    Info<< indent << "Selecting surfaceCellSizeFunction "
+        << surfaceCellSizeFunctionTypeName << endl;
+
+    dictionaryConstructorTable::iterator cstrIter =
+        dictionaryConstructorTablePtr_->find(surfaceCellSizeFunctionTypeName);
+
+    if (cstrIter == dictionaryConstructorTablePtr_->end())
+    {
+        FatalErrorIn
+        (
+            "surfaceCellSizeFunction::New(dictionary&, "
+            "const conformalVoronoiMesh&, const searchableSurface&)"
+        )   << "Unknown surfaceCellSizeFunction type "
+            << surfaceCellSizeFunctionTypeName
+            << endl << endl
+            << "Valid surfaceCellSizeFunction types are :" << endl
+            << dictionaryConstructorTablePtr_->toc()
+            << exit(FatalError);
+    }
+
+    return autoPtr<surfaceCellSizeFunction>
+    (
+        cstrIter()(surfaceCellSizeFunctionDict, surface, defaultCellSize)
+    );
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::surfaceCellSizeFunction::~surfaceCellSizeFunction()
+{}
+
+
+// ************************************************************************* //

applications/utilities/mesh/generation/foamyHexMesh/conformalVoronoiMesh/cellSizeControlSurfaces/surfaceCellSizeFunction/surfaceCellSizeFunction/surfaceCellSizeFunction.H

@@ -0,0 +1,158 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012-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/>.
+
+Class
+    Foam::surfaceCellSizeFunction
+
+Description
+    Abstract base class for specifying target cell sizes
+
+SourceFiles
+    surfaceCellSizeFunction.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef surfaceCellSizeFunction_H
+#define surfaceCellSizeFunction_H
+
+#include "searchableSurface.H"
+#include "dictionary.H"
+#include "autoPtr.H"
+#include "runTimeSelectionTables.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                     Class surfaceCellSizeFunction Declaration
+\*---------------------------------------------------------------------------*/
+
+class surfaceCellSizeFunction
+:
+    public dictionary
+{
+
+protected:
+
+    // Protected data
+
+        //- Reference to the searchableSurface that surfaceCellSizeFunction
+        //  relates to
+        const searchableSurface& surface_;
+
+        const dictionary coeffsDict_;
+
+        const scalar& defaultCellSize_;
+
+        //- If cell resizing is allowed, this is the factor of the old cell size
+        //  to get the new cell size
+        scalar refinementFactor_;
+
+
+private:
+
+    // Private Member Functions
+
+        //- Disallow default bitwise copy construct
+        surfaceCellSizeFunction(const surfaceCellSizeFunction&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const surfaceCellSizeFunction&);
+
+
+public:
+
+    //- Runtime type information
+    TypeName("surfaceCellSizeFunction");
+
+
+    // Declare run-time constructor selection table
+
+        declareRunTimeSelectionTable
+        (
+            autoPtr,
+            surfaceCellSizeFunction,
+            dictionary,
+            (
+                const dictionary& surfaceCellSizeFunctionDict,
+                const searchableSurface& surface,
+                const scalar& defaultCellSize
+            ),
+            (surfaceCellSizeFunctionDict, surface, defaultCellSize)
+        );
+
+
+    // Constructors
+
+        //- Construct from components
+        surfaceCellSizeFunction
+        (
+            const word& type,
+            const dictionary& surfaceCellSizeFunctionDict,
+            const searchableSurface& surface,
+            const scalar& defaultCellSize
+        );
+
+
+    // Selectors
+
+        //- Return a reference to the selected surfaceCellSizeFunction
+        static autoPtr<surfaceCellSizeFunction> New
+        (
+            const dictionary& surfaceCellSizeFunctionDict,
+            const searchableSurface& surface,
+            const scalar& defaultCellSize
+        );
+
+
+    //- Destructor
+    virtual ~surfaceCellSizeFunction();
+
+
+    // Member Functions
+
+        //- Const access to the details dictionary
+        inline const dictionary& coeffsDict() const
+        {
+            return coeffsDict_;
+        }
+
+        virtual scalar interpolate
+        (
+            const point& pt,
+            const label index
+        ) const = 0;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

applications/utilities/mesh/generation/foamyHexMesh/conformalVoronoiMesh/cellSizeControlSurfaces/surfaceCellSizeFunction/uniformValue/uniformValue.C

@@ -0,0 +1,78 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012-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/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "uniformValue.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(uniformValue, 0);
+    addToRunTimeSelectionTable
+    (
+        surfaceCellSizeFunction,
+        uniformValue,
+        dictionary
+    );
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::uniformValue::uniformValue
+(
+    const dictionary& cellSizeFunctionDict,
+    const searchableSurface& surface,
+    const scalar& defaultCellSize
+)
+:
+    surfaceCellSizeFunction
+    (
+        typeName,
+        cellSizeFunctionDict,
+        surface,
+        defaultCellSize
+    ),
+    surfaceCellSize_
+    (
+        readScalar(coeffsDict().lookup("surfaceCellSizeCoeff"))*defaultCellSize
+    )
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+Foam::scalar Foam::uniformValue::interpolate
+(
+    const point& pt,
+    const label index
+) const
+{
+    return surfaceCellSize_;
+}
+
+
+// ************************************************************************* //

applications/utilities/mesh/generation/foamyHexMesh/conformalVoronoiMesh/cellSizeControlSurfaces/surfaceCellSizeFunction/uniformValue/uniformValue.H

@@ -0,0 +1,100 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2012-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/>.
+
+Class
+    Foam::uniformValue
+
+Description
+
+SourceFiles
+    uniformValue.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef uniformValue_H
+#define uniformValue_H
+
+#include "surfaceCellSizeFunction.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                           Class uniformValue Declaration
+\*---------------------------------------------------------------------------*/
+
+class uniformValue
+:
+    public surfaceCellSizeFunction
+{
+
+private:
+
+    // Private data
+
+        scalar surfaceCellSize_;
+
+
+public:
+
+    //- Runtime type information
+    TypeName("uniformValue");
+
+
+    // Constructors
+
+        //- Construct from components
+        uniformValue
+        (
+            const dictionary& cellSizeFunctionDict,
+            const searchableSurface& surface,
+            const scalar& defaultCellSize
+        );
+
+
+    //- Destructor
+    virtual ~uniformValue()
+    {}
+
+
+    // Member Functions
+
+        virtual scalar interpolate
+        (
+            const point& pt,
+            const label index
+        ) const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //