diff --git a/applications/solvers/multiphase/multiphaseEulerFoam/multiphaseSystem/diameterModels/constantDiameter/constantDiameter.H b/applications/solvers/multiphase/multiphaseEulerFoam/multiphaseSystem/diameterModels/constantDiameter/constantDiameter.H
index 071820c319..738b7ae570 100644
--- a/applications/solvers/multiphase/multiphaseEulerFoam/multiphaseSystem/diameterModels/constantDiameter/constantDiameter.H
+++ b/applications/solvers/multiphase/multiphaseEulerFoam/multiphaseSystem/diameterModels/constantDiameter/constantDiameter.H
@@ -22,13 +22,13 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Class
-    Foam::constant
+    Foam::diameterModels::constant
 
 Description
     Constant dispersed-phase particle diameter model.
 
 SourceFiles
-    constant.C
+    constantDiameter.C
 
 \*---------------------------------------------------------------------------*/
 
diff --git a/applications/solvers/multiphase/reactingEulerFoam/interfacialCompositionModels/surfaceTensionModels/constantSurfaceTensionCoefficient/constantSurfaceTensionCoefficient.H b/applications/solvers/multiphase/reactingEulerFoam/interfacialCompositionModels/surfaceTensionModels/constantSurfaceTensionCoefficient/constantSurfaceTensionCoefficient.H
index 636dc57293..94daf77027 100644
--- a/applications/solvers/multiphase/reactingEulerFoam/interfacialCompositionModels/surfaceTensionModels/constantSurfaceTensionCoefficient/constantSurfaceTensionCoefficient.H
+++ b/applications/solvers/multiphase/reactingEulerFoam/interfacialCompositionModels/surfaceTensionModels/constantSurfaceTensionCoefficient/constantSurfaceTensionCoefficient.H
@@ -22,7 +22,7 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Class
-    Foam::constantSurfaceTensionCoefficient
+    Foam::surfaceTensionModels::constantSurfaceTensionCoefficient
 
 Description
     Constant value surface tension model.
diff --git a/applications/solvers/multiphase/reactingEulerFoam/interfacialModels/aspectRatioModels/constantAspectRatio/constantAspectRatio.H b/applications/solvers/multiphase/reactingEulerFoam/interfacialModels/aspectRatioModels/constantAspectRatio/constantAspectRatio.H
index 4ca36a0a96..c5963a3eff 100644
--- a/applications/solvers/multiphase/reactingEulerFoam/interfacialModels/aspectRatioModels/constantAspectRatio/constantAspectRatio.H
+++ b/applications/solvers/multiphase/reactingEulerFoam/interfacialModels/aspectRatioModels/constantAspectRatio/constantAspectRatio.H
@@ -22,7 +22,7 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Class
-    Foam::constantAspectRatio
+    Foam::aspectRatioModels::constantAspectRatio
 
 Description
     Constant value aspect ratio model.
diff --git a/applications/solvers/multiphase/twoPhaseEulerFoam/interfacialModels/aspectRatioModels/constantAspectRatio/constantAspectRatio.H b/applications/solvers/multiphase/twoPhaseEulerFoam/interfacialModels/aspectRatioModels/constantAspectRatio/constantAspectRatio.H
index 4ca36a0a96..c5963a3eff 100644
--- a/applications/solvers/multiphase/twoPhaseEulerFoam/interfacialModels/aspectRatioModels/constantAspectRatio/constantAspectRatio.H
+++ b/applications/solvers/multiphase/twoPhaseEulerFoam/interfacialModels/aspectRatioModels/constantAspectRatio/constantAspectRatio.H
@@ -22,7 +22,7 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Class
-    Foam::constantAspectRatio
+    Foam::aspectRatioModels::constantAspectRatio
 
 Description
     Constant value aspect ratio model.
diff --git a/applications/test/Hashing/Test-Hashing.C b/applications/test/Hashing/Test-Hashing.C
index 0ab7e9a7cb..4461679d08 100644
--- a/applications/test/Hashing/Test-Hashing.C
+++ b/applications/test/Hashing/Test-Hashing.C
@@ -42,13 +42,44 @@ Description
 
 using namespace Foam;
 
+void infoHashString
+(
+    unsigned modulus,
+    std::initializer_list<std::string> lst
+)
+{
+    if (modulus)
+    {
+        Info<< "basic string hashing (mod " << label(modulus) << ")" << endl;
+
+        for (const auto& str : lst)
+        {
+            Info<<"hash(" << str.c_str() << ")="
+                << (Hash<string>()(str) % modulus) << nl;
+        }
+
+    }
+    else
+    {
+        Info<< "basic string hashing" << nl;
+
+        for (const auto& str : lst)
+        {
+            Info<<"hash(" << str.c_str() << ")="
+                << Hash<string>()(str) << nl;
+        }
+    }
+}
+
+
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 //  Main program:
 
 int main(int argc, char *argv[])
 {
-    IFstream is("hashingTests");
+    infoHashString(8, {"asdathis1", "adsxf", "hij", "klmpq"});
 
+    IFstream is("hashingTests");
 
     while (is.good())
     {
diff --git a/applications/test/NamedEnum/Test-NamedEnum.C b/applications/test/NamedEnum/Test-NamedEnum.C
index 079938b6b7..d0b7f58d79 100644
--- a/applications/test/NamedEnum/Test-NamedEnum.C
+++ b/applications/test/NamedEnum/Test-NamedEnum.C
@@ -26,6 +26,7 @@ Description
 \*---------------------------------------------------------------------------*/
 
 #include "NamedEnum.H"
+#include "Enum.H"
 #include "IOstreams.H"
 
 using namespace Foam;
@@ -34,15 +35,27 @@ class namedEnumTest
 {
 public:
 
-    enum option
+    enum class option
     {
-        a,
-        b,
-        c,
-        d
+        A,
+        B,
+        C,
+        D
     };
 
-    static const Foam::NamedEnum<option, 4> namedEnum;
+    enum class otherOption
+    {
+        A,
+        B,
+        C,
+        D
+    };
+
+    static const Foam::NamedEnum<option, 4> optionNamed;
+
+    static const Foam::Enum<otherOption> optionEnum;
+
+    static const Foam::Enum<option> optionEnum2;
 };
 
 
@@ -52,10 +65,25 @@ const char* Foam::NamedEnum<namedEnumTest::option, 4>::names[] =
     "a",
     "b",
     "c",
-    "d"
+    "d",
 };
 
-const Foam::NamedEnum<namedEnumTest::option, 4> namedEnumTest::namedEnum;
+const Foam::NamedEnum<namedEnumTest::option, 4> namedEnumTest::optionNamed;
+
+const Foam::Enum<namedEnumTest::otherOption> namedEnumTest::optionEnum
+{
+    { namedEnumTest::otherOption::A, "a" },
+    { namedEnumTest::otherOption::B, "b" },
+    { namedEnumTest::otherOption::C, "c" },
+    { namedEnumTest::otherOption::D, "d" },
+};
+
+
+const Foam::Enum<namedEnumTest::option> namedEnumTest::optionEnum2
+(
+    namedEnumTest::option::C,
+    { "c", "d" }
+);
 
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@@ -63,62 +91,66 @@ const Foam::NamedEnum<namedEnumTest::option, 4> namedEnumTest::namedEnum;
 
 int main(int argc, char *argv[])
 {
-    const List<namedEnumTest::option> options
-        = namedEnumTest::namedEnum.enums();
+    Info<<"NamedEnum: " << namedEnumTest::optionNamed << nl;
+    Info<<"Enum: " << namedEnumTest::optionEnum << nl;
+    Info<<"Enum: " << namedEnumTest::optionEnum2 << nl;
 
     dictionary testDict;
     testDict.add("lookup1", "c");
 
-    Info<< "enums: " << options << nl;
-
-    Info<< "loop over enums (as list):" << nl;
-    forAll(options, i)
-    {
-        const namedEnumTest::option& opt = options[i];
-
-        Info<< "option[" << opt
-            << "] = '" << namedEnumTest::namedEnum[opt] << "'" << nl;
-    }
-
-    Info<< "loop over enums (C++11 for range):" << nl;
-    for (const auto& opt : options)
-    {
-        Info<< "option[" << opt
-            << "] = '" << namedEnumTest::namedEnum[opt] << "'" << nl;
-    }
+    Info<< nl
+        << int(namedEnumTest::optionNamed["a"]) << nl
+        << namedEnumTest::optionNamed[namedEnumTest::option::A] << nl;
 
     Info<< nl
-        << namedEnumTest::namedEnum["a"] << nl
-        << namedEnumTest::namedEnum[namedEnumTest::a] << nl;
+        << int(namedEnumTest::optionEnum["a"]) << nl
+        << namedEnumTest::optionEnum[namedEnumTest::otherOption::A] << nl;
 
     Info<< "--- test dictionary lookup ---" << endl;
     {
         Info<< "dict: " << testDict << endl;
 
-        namedEnumTest::option gotOpt =
-            namedEnumTest::namedEnum.lookupOrDefault
-            (
-                "test",
-                testDict,
-                namedEnumTest::option::a
-            );
+        Info<< "got: "
+            <<  int
+                (
+                    namedEnumTest::optionNamed.lookupOrDefault
+                    (
+                        "notFound",
+                        testDict,
+                        namedEnumTest::option::A
+                    )
+                )
+            << nl;
 
-        Info<< "got: " << gotOpt << endl;
+        Info<< "got: "
+            <<  int
+                (
+                    namedEnumTest::optionNamed.lookupOrDefault
+                    (
+                        "lookup1",
+                        testDict,
+                        namedEnumTest::option::A
+                    )
+                )
+            << nl;
 
-        gotOpt = namedEnumTest::namedEnum.lookupOrDefault
-        (
-            "lookup1",
-            testDict,
-            namedEnumTest::option::a
-        );
-
-        Info<< "got: " << gotOpt << endl;
+        Info<< "got: "
+            <<  int
+                (
+                    namedEnumTest::optionEnum2.lookupOrDefault
+                    (
+                        "lookup1",
+                        testDict,
+                        namedEnumTest::option::A
+                    )
+                )
+            << nl;
     }
 
-    Info<< "--- test read construction ---" << endl;
+    Info<< "--- test read ---" << endl;
 
-    namedEnumTest::option dummy(namedEnumTest::namedEnum.read(Sin));
-    Info<< namedEnumTest::namedEnum[dummy] << endl;
+    namedEnumTest::option dummy(namedEnumTest::optionNamed.read(Sin));
+    Info<< namedEnumTest::optionNamed[dummy] << endl;
 
     Info<< "End\n" << endl;
 
diff --git a/applications/test/PackedList2/Test-PackedList2.C b/applications/test/PackedList2/Test-PackedList2.C
index 2926118ff9..26981b484f 100644
--- a/applications/test/PackedList2/Test-PackedList2.C
+++ b/applications/test/PackedList2/Test-PackedList2.C
@@ -84,6 +84,12 @@ int main(int argc, char *argv[])
         packed.resize(n, 1);
     }
     Info<< "resize/shrink/resize:" << timer.cpuTimeIncrement() << " s\n\n";
+    Info<< "packed bool size=" << packed.size() << nl;
+
+    // Neither of these should affect the size
+    packed.unset(2*n-1);
+    packed.set(2*n-1, 0);
+    Info<< "packed bool size=" << packed.size() << nl;
 
     // set every other bit on:
     Info<< "set every other bit on and count\n";
@@ -99,8 +105,8 @@ int main(int argc, char *argv[])
         }
     }
     Info<< "Counting brute-force:" << timer.cpuTimeIncrement()
-        << " s" << endl;
-    Info<< "  sum " << sum << endl;
+        << " s" << nl
+        << "  sum " << sum << endl;
 
 
     // Count packed
@@ -110,8 +116,8 @@ int main(int argc, char *argv[])
         sum += packed.count();
     }
     Info<< "Counting via count():" << timer.cpuTimeIncrement()
-        << " s" << endl;
-    Info<< "  sum " << sum << endl;
+        << " s" << nl
+        << "  sum " << sum << endl;
 
 
     // Dummy addition
@@ -123,8 +129,8 @@ int main(int argc, char *argv[])
             sum += i + 1;
         }
     }
-    Info<< "Dummy loop:" << timer.cpuTimeIncrement() << " s" << endl;
-    Info<< "  sum " << sum << endl;
+    Info<< "Dummy loop:" << timer.cpuTimeIncrement() << " s" << nl
+        << "  sum " << sum << " (sum is meaningless)" << endl;
 
     //
     // Read
@@ -139,8 +145,8 @@ int main(int argc, char *argv[])
             sum += stlVector[i];
         }
     }
-    Info<< "Reading stl:" << timer.cpuTimeIncrement() << " s" << endl;
-    Info<< "  sum " << sum << endl;
+    Info<< "Reading stl:" << timer.cpuTimeIncrement() << " s" << nl
+        << "  sum " << sum << endl;
 
 
     // Read unpacked
@@ -152,8 +158,8 @@ int main(int argc, char *argv[])
             sum += unpacked[i];
         }
     }
-    Info<< "Reading unpacked:" << timer.cpuTimeIncrement() << " s" << endl;
-    Info<< "  sum " << sum << endl;
+    Info<< "Reading unpacked:" << timer.cpuTimeIncrement() << " s" << nl
+        << "  sum " << sum << endl;
 
 
     // Read packed
@@ -166,8 +172,8 @@ int main(int argc, char *argv[])
         }
     }
     Info<< "Reading packed using get:" << timer.cpuTimeIncrement()
-        << " s" << endl;
-    Info<< "  sum " << sum << endl;
+        << " s" << nl
+        << "  sum " << sum << endl;
 
 
     // Read packed
@@ -180,8 +186,8 @@ int main(int argc, char *argv[])
         }
     }
     Info<< "Reading packed using reference:" << timer.cpuTimeIncrement()
-        << " s" << endl;
-    Info<< "  sum " << sum << endl;
+        << " s" << nl
+        << "  sum " << sum << endl;
 
 
     // Read via iterator
@@ -194,8 +200,8 @@ int main(int argc, char *argv[])
         }
     }
     Info<< "Reading packed using iterator:" << timer.cpuTimeIncrement()
-        << " s" << endl;
-    Info<< "  sum " << sum << endl;
+        << " s" << nl
+        << "  sum " << sum << endl;
 
 
     // Read via iterator
@@ -208,8 +214,8 @@ int main(int argc, char *argv[])
         }
     }
     Info<< "Reading packed using const_iterator():" << timer.cpuTimeIncrement()
-        << " s" << endl;
-    Info<< "  sum " << sum << endl;
+        << " s" << nl
+        << "  sum " << sum << endl;
 
 
     // Read empty hash
@@ -222,8 +228,8 @@ int main(int argc, char *argv[])
         }
     }
     Info<< "Reading empty labelHashSet:" << timer.cpuTimeIncrement()
-        << " s" << endl;
-    Info<< "  sum " << sum << endl;
+        << " s" << nl
+        << "  sum " << sum << endl;
 
 
     // Read full hash
@@ -236,8 +242,8 @@ int main(int argc, char *argv[])
         }
     }
     Info<< "Reading full labelHashSet:" << timer.cpuTimeIncrement()
-        << " s" << endl;
-    Info<< "  sum " << sum << endl;
+        << " s" << nl
+        << "  sum " << sum << endl;
 
 
     // Read empty static hash
@@ -250,8 +256,8 @@ int main(int argc, char *argv[])
         }
     }
     Info<< "Reading empty StaticHash:" << timer.cpuTimeIncrement()
-        << " s" << endl;
-    Info<< "  sum " << sum << endl;
+        << " s" << nl
+        << "  sum " << sum << endl;
 
 #if 0
     // we can skip this test - it is usually quite slow
@@ -265,8 +271,8 @@ int main(int argc, char *argv[])
         }
     }
     Info<< "Reading full StaticHash:" << timer.cpuTimeIncrement()
-        << " s" << endl;
-    Info<< "  sum " << sum << endl;
+        << " s" << nl
+        << "  sum " << sum << endl;
 #endif
 
     Info<< "Starting write tests" << endl;
@@ -319,7 +325,6 @@ int main(int argc, char *argv[])
     Info<< "Writing packed using set:" << timer.cpuTimeIncrement()
         << " s" << endl;
 
-
     // Write packed
     for (label iter = 0; iter < nIters; ++iter)
     {
diff --git a/applications/test/surfaceIntersection/Make/files b/applications/test/surfaceIntersection/Make/files
new file mode 100644
index 0000000000..e0516a472c
--- /dev/null
+++ b/applications/test/surfaceIntersection/Make/files
@@ -0,0 +1,3 @@
+Test-surfaceIntersection.C
+
+EXE = $(FOAM_USER_APPBIN)/Test-surfaceIntersection
diff --git a/applications/test/surfaceIntersection/Make/options b/applications/test/surfaceIntersection/Make/options
new file mode 100644
index 0000000000..b7fa8b2326
--- /dev/null
+++ b/applications/test/surfaceIntersection/Make/options
@@ -0,0 +1,7 @@
+EXE_INC = \
+    -I$(LIB_SRC)/meshTools/lnInclude \
+    -I$(LIB_SRC)/surfMesh/lnInclude \
+    -I$(LIB_SRC)/triSurface/lnInclude
+
+EXE_LIBS = \
+    -lmeshTools
diff --git a/applications/test/surfaceIntersection/Test-surfaceIntersection.C b/applications/test/surfaceIntersection/Test-surfaceIntersection.C
new file mode 100644
index 0000000000..ddf122f60a
--- /dev/null
+++ b/applications/test/surfaceIntersection/Test-surfaceIntersection.C
@@ -0,0 +1,221 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2017 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Application
+    Test-surfaceIntersection
+
+Description
+    Test surface-surface intersection
+
+\*---------------------------------------------------------------------------*/
+
+#include "argList.H"
+#include "Time.H"
+#include "triSurface.H"
+#include "triSurfaceMesh.H"
+#include "surfaceIntersection.H"
+#include "OBJstream.H"
+
+using namespace Foam;
+
+autoPtr<triSurface> loadSurface
+(
+    const Foam::Time& runTime,
+    const fileName& surfName
+)
+{
+    Info<< "Reading surface " << surfName << endl;
+
+    const fileName fallback =
+        runTime.constantPath()/triSurfaceMesh::meshSubDir/surfName;
+
+    autoPtr<triSurface> surfPtr;
+    if (isFile(surfName))
+    {
+        surfPtr.set(new triSurface(surfName));
+    }
+    else if (isFile(fallback))
+    {
+        surfPtr.set(new triSurface(fallback));
+    }
+    else
+    {
+        FatalErrorInFunction
+            << "No such file:" << surfName << exit(FatalError);
+    }
+
+    return surfPtr;
+}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+int main(int argc, char *argv[])
+{
+    argList::addNote
+    (
+        "Intersection of two surfaces. Writes obj file"
+    );
+    argList::addBoolOption
+    (
+        "debug2",
+        "set surfaceIntersection debug=2"
+    );
+    argList::addBoolOption
+    (
+        "debug4",
+        "set surfaceIntersection debug=4"
+    );
+    argList::addBoolOption
+    (
+        "print",
+        "print information about cuts, etc"
+    );
+    argList::addBoolOption
+    (
+        "mergeEdges",
+        "merge duplicate edges"
+    );
+    argList::addOption
+    (
+        "mergePoints",
+        "mergeTol",
+        "merge points (and edges) using the specified tolerance"
+    );
+
+    #include "addDictOption.H"
+
+    argList::addNote
+    (
+        "test intersect of two surfaces. Writes obj file"
+    );
+    argList::noParallel();
+    argList::noFunctionObjects();
+    argList::validArgs.append("surface file");
+    argList::validArgs.append("surface file");
+
+    #include "setRootCase.H"
+    #include "createTime.H"
+
+    const word outputFile(args.executable() + ".obj");
+
+    const fileName surf1Name(args[1]);
+    triSurface surf1 = loadSurface(runTime, surf1Name)();
+    Info<< surf1Name << " statistics:" << endl;
+    surf1.writeStats(Info);
+    Info<< endl;
+
+    const fileName surf2Name(args[2]);
+    triSurface surf2 = loadSurface(runTime, surf2Name)();
+    Info<< surf2Name << " statistics:" << endl;
+    surf2.writeStats(Info);
+    Info<< endl;
+
+
+    if (args.optionFound("debug2"))
+    {
+        surfaceIntersection::debug |= 2;
+    }
+    if (args.optionFound("debug4"))
+    {
+        surfaceIntersection::debug |= 4;
+    }
+    const bool optPrint = args.optionFound("print");
+
+    dictionary intersectOptions;
+    if (args.optionFound("dict"))
+    {
+        intersectOptions = IOdictionary
+        (
+            IOobject
+            (
+                args["dict"],
+                runTime,
+                IOobject::MUST_READ_IF_MODIFIED,
+                IOobject::NO_WRITE
+            )
+        );
+    }
+
+    intersectOptions.writeEntry("intersectOptions", Info);
+    Info<< endl;
+
+    triSurfaceSearch query1(surf1);
+    triSurfaceSearch query2(surf2);
+    surfaceIntersection cuts(query1, query2, intersectOptions);
+
+    Info<<"intersection "
+        << cuts.cutPoints().size() << " points "
+        << cuts.cutEdges().size()  << " edges" << nl;
+
+    if (optPrint)
+    {
+        Info<< "surf1-cuts: " << cuts.surf1EdgeCuts() << nl
+            << "surf2-cuts: " << cuts.surf2EdgeCuts() << nl
+            << "face-pairs: " << cuts.facePairToEdgeId() << nl
+            << "edges: " << cuts.cutEdges() << nl;
+    }
+
+    word mergeOp;
+    if (args.optionFound("mergePoints"))
+    {
+        cuts.mergePoints(args.optionRead<scalar>("mergePoints"));
+        mergeOp = "mergePoints";
+    }
+    else if (args.optionFound("mergeEdges"))
+    {
+        cuts.mergeEdges();
+        mergeOp = "mergeEdges";
+    }
+
+    if (!mergeOp.empty())
+    {
+        Info<< mergeOp << ": "
+            << cuts.cutPoints().size() << " points "
+            << cuts.cutEdges().size()  << " edges" << nl;
+
+        if (optPrint)
+        {
+            Info<< "surf1-cuts: " << cuts.surf1EdgeCuts() << nl
+                << "surf2-cuts: " << cuts.surf2EdgeCuts() << nl
+                << "face-pairs: " << cuts.facePairToEdgeId() << nl
+                << "edges: " << cuts.cutEdges() << nl;
+        }
+    }
+
+    const pointField& points = cuts.cutPoints();
+    const edgeList&    edges = cuts.cutEdges();
+
+    if (points.size() || edges.size())
+    {
+        Info<<"write to " << outputFile << nl;
+        OBJstream(outputFile).write(edges, points);
+    }
+
+    Info<< "End\n" << endl;
+
+    return 0;
+}
+
+
+// ************************************************************************* //
diff --git a/applications/test/unitConversion/Make/files b/applications/test/unitConversion/Make/files
new file mode 100644
index 0000000000..0e675c11a2
--- /dev/null
+++ b/applications/test/unitConversion/Make/files
@@ -0,0 +1,3 @@
+Test-unitConversion.C
+
+EXE = $(FOAM_USER_APPBIN)/Test-unitConversion
diff --git a/applications/test/unitConversion/Make/options b/applications/test/unitConversion/Make/options
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/applications/test/unitConversion/Test-unitConversion.C b/applications/test/unitConversion/Test-unitConversion.C
new file mode 100644
index 0000000000..869007ec40
--- /dev/null
+++ b/applications/test/unitConversion/Test-unitConversion.C
@@ -0,0 +1,50 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2017 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Application
+    Test-unitConversion
+
+\*---------------------------------------------------------------------------*/
+
+#include "IOstreams.H"
+#include "unitConversion.H"
+
+using namespace Foam;
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+//  Main program:
+
+int main(int argc, char *argv[])
+{
+    Info<< "30_deg:   " << 30_deg << nl;
+    Info<< "30.0_deg: " << 30.0_deg << nl;
+    Info<< "3e+1_deg: " << 3e+1_deg << nl;
+    Info<< "degToRad(30): " << degToRad(30) << nl;
+
+    Info<< "cos(30_deg): " << ::cos(30_deg) << nl;
+
+    return 0;
+}
+
+
+// ************************************************************************* //
diff --git a/applications/utilities/mesh/conversion/ccm/ccmToFoam/ccmToFoam.C b/applications/utilities/mesh/conversion/ccm/ccmToFoam/ccmToFoam.C
index 13049e8c9e..52377df339 100644
--- a/applications/utilities/mesh/conversion/ccm/ccmToFoam/ccmToFoam.C
+++ b/applications/utilities/mesh/conversion/ccm/ccmToFoam/ccmToFoam.C
@@ -125,12 +125,6 @@ int main(int argc, char *argv[])
         "provide alternative base name when re-exporting (implies -export). "
         "Default is <meshExport>."
     );
-    // This often works, but is not entirely stable
-    //     argList::addBoolOption
-    //     (
-    //         "combine",
-    //         "combine identically named patches"
-    //     );
     argList::addBoolOption
     (
         "noBaffles",
@@ -211,10 +205,6 @@ int main(int argc, char *argv[])
     {
         rOpts.useNumberedNames(true);
     }
-    else if (args.optionFound("combine"))
-    {
-        rOpts.combineBoundaries(true);
-    }
 
     if (args.optionFound("solids"))
     {
@@ -295,7 +285,7 @@ int main(int argc, char *argv[])
         {
             const fileName geomName = exportName + ".ccmg";
             Info<< nl << "Re-exporting geometry as " << geomName << nl;
-            ccm::writer(geomName, mesh).writeGeometry();
+            ccm::writer(geomName, mesh()).writeGeometry();
         }
     }
     else
diff --git a/applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/DelaunayMeshTools/DelaunayMeshToolsTemplates.C b/applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/DelaunayMeshTools/DelaunayMeshToolsTemplates.C
index ed6818dd39..da9f4ce3ed 100644
--- a/applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/DelaunayMeshTools/DelaunayMeshToolsTemplates.C
+++ b/applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/DelaunayMeshTools/DelaunayMeshToolsTemplates.C
@@ -44,22 +44,9 @@ void Foam::DelaunayMeshTools::writeOBJ
     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;
+        << "Writing points of types ("
+        << int(startPointType) << "-" << int(endPointType)
+        << ") to " << str.name() << endl;
 
     for
     (
@@ -265,7 +252,7 @@ void Foam::DelaunayMeshTools::drawDelaunayCell
         << "f " << 1 + offset << " " << 4 + offset << " " << 3 + offset << nl
         << "f " << 1 + offset << " " << 2 + offset << " " << 4 + offset << endl;
 
-//    os  << "# cicumcentre " << endl;
+//    os  << "# circumcentre " << endl;
 
 //    meshTools::writeOBJ(os, c->dual());
 
diff --git a/applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/conformalVoronoiMesh/conformalVoronoiMeshIO.C b/applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/conformalVoronoiMesh/conformalVoronoiMeshIO.C
index 6b6d10d182..ee6a7b3662 100644
--- a/applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/conformalVoronoiMesh/conformalVoronoiMeshIO.C
+++ b/applications/utilities/mesh/generation/foamyMesh/conformalVoronoiMesh/conformalVoronoiMesh/conformalVoronoiMeshIO.C
@@ -900,12 +900,10 @@ void Foam::conformalVoronoiMesh::writeMesh
     mesh.addFvPatches(patches);
 
 
-
     // Add zones to the mesh
     addZones(mesh, cellCentres);
 
 
-
     Info<< indent << "Add pointZones" << endl;
     {
         label sz = mesh.pointZones().size();
@@ -914,6 +912,9 @@ void Foam::conformalVoronoiMesh::writeMesh
 
         forAll(dualMeshPointTypeNames_, typeI)
         {
+            const word& znName =
+                dualMeshPointTypeNames_[dualMeshPointType(typeI)];
+
             forAll(boundaryPts, ptI)
             {
                 const label& bPtType = boundaryPts[ptI];
@@ -928,14 +929,14 @@ void Foam::conformalVoronoiMesh::writeMesh
 
             Info<< incrIndent << indent
                 << "Adding " << bPts.size()
-                << " points of type " << dualMeshPointTypeNames_.words()[typeI]
+                << " points of type " << znName
                 << decrIndent << endl;
 
             mesh.pointZones().append
             (
                 new pointZone
                 (
-                    dualMeshPointTypeNames_.words()[typeI],
+                    znName,
                     bPts,
                     sz + typeI,
                     mesh.pointZones()
diff --git a/applications/utilities/postProcessing/noise/noise.C b/applications/utilities/postProcessing/noise/noise.C
index c872b1557c..089efeefac 100644
--- a/applications/utilities/postProcessing/noise/noise.C
+++ b/applications/utilities/postProcessing/noise/noise.C
@@ -102,6 +102,8 @@ using namespace Foam;
 
 int main(int argc, char *argv[])
 {
+    argList::noCheckProcessorDirectories();
+
     #include "addDictOption.H"
     #include "setRootCase.H"
     #include "createTime.H"
diff --git a/applications/utilities/preProcessing/mapFieldsPar/mapFieldsPar.C b/applications/utilities/preProcessing/mapFieldsPar/mapFieldsPar.C
index 43caab7dcc..d6df8f1a16 100644
--- a/applications/utilities/preProcessing/mapFieldsPar/mapFieldsPar.C
+++ b/applications/utilities/preProcessing/mapFieldsPar/mapFieldsPar.C
@@ -229,7 +229,7 @@ int main(int argc, char *argv[])
 
 
     word patchMapMethod;
-    if (meshToMesh::interpolationMethodNames_.found(mapMethod))
+    if (meshToMesh::interpolationMethodNames_.hasEnum(mapMethod))
     {
         // Lookup corresponding AMI method
         meshToMesh::interpolationMethod method =
diff --git a/applications/utilities/surface/surfaceBooleanFeatures/surfaceBooleanFeatures.C b/applications/utilities/surface/surfaceBooleanFeatures/surfaceBooleanFeatures.C
index 02d0b0c8e6..52c5d9c089 100644
--- a/applications/utilities/surface/surfaceBooleanFeatures/surfaceBooleanFeatures.C
+++ b/applications/utilities/surface/surfaceBooleanFeatures/surfaceBooleanFeatures.C
@@ -83,7 +83,7 @@ Description
 #include "edgeIntersections.H"
 #include "meshTools.H"
 #include "DynamicField.H"
-
+#include "Enum.H"
 
 #ifndef NO_CGAL
 
@@ -99,7 +99,7 @@ typedef CGAL::AABB_face_graph_triangle_primitive
 typedef CGAL::AABB_traits<K, Primitive> Traits;
 typedef CGAL::AABB_tree<Traits> Tree;
 
-typedef boost::optional<Tree::Intersection_and_primitive_id<Segment>::Type >
+typedef boost::optional<Tree::Intersection_and_primitive_id<Segment>::Type>
 Segment_intersection;
 
 #endif // NO_CGAL
@@ -477,7 +477,6 @@ label dupNonManifoldPoints(triSurface& s, labelList& pointMap)
     List<labelledTri> newFaces(s);
     label nNonManifold = 0;
 
-
     forAll(pf, pointI)
     {
         const labelList& pFaces = pf[pointI];
@@ -1257,10 +1256,10 @@ autoPtr<extendedFeatureEdgeMesh> createEdgeMesh
     const triSurface& s1 = surf1;
     const triSurface& s2 = surf2;
 
-    forAllConstIter(labelPairLookup, inter.facePairToEdge(), iter)
+    forAllConstIters(inter.facePairToEdgeId(), iter)
     {
-        const label& cutEdgeI = iter();
         const labelPair& facePair = iter.key();
+        const label cutEdgeI = iter.object();
 
         const edge& fE = inter.cutEdges()[cutEdgeI];
 
@@ -1515,8 +1514,8 @@ int main(int argc, char *argv[])
 {
     argList::noParallel();
     argList::validArgs.append("action");
-    argList::validArgs.append("surface file");
-    argList::validArgs.append("surface file");
+    argList::validArgs.append("surfaceFile1");
+    argList::validArgs.append("surfaceFile2");
 
     argList::addBoolOption
     (
@@ -1554,24 +1553,30 @@ int main(int argc, char *argv[])
         " 'mixed' (keep all)"
     );
 
+    argList::addNote
+    (
+        "Valid actions: \"intersection\", \"union\", \"difference\""
+    );
+
 
     #include "setRootCase.H"
     #include "createTime.H"
 
     const word action(args[1]);
 
-    const HashTable<booleanSurface::booleanOpType> validActions
+    const Enum<booleanSurface::booleanOpType> validActions
     {
-        {"intersection", booleanSurface::INTERSECTION},
-        {"union", booleanSurface::UNION},
-        {"difference", booleanSurface::DIFFERENCE}
+        { booleanSurface::INTERSECTION, "intersection" },
+        { booleanSurface::UNION, "union" },
+        { booleanSurface::DIFFERENCE, "difference" }
     };
 
-    if (!validActions.found(action))
+    if (!validActions.hasEnum(action))
     {
         FatalErrorInFunction
             << "Unsupported action " << action << endl
-            << "Supported actions:" << validActions.toc() << abort(FatalError);
+            << "Supported actions:" << validActions << nl
+            << abort(FatalError);
     }
 
 
diff --git a/applications/utilities/surface/surfaceFeatureExtract/Allwclean b/applications/utilities/surface/surfaceFeatureExtract/Allwclean
new file mode 100755
index 0000000000..421b6686c4
--- /dev/null
+++ b/applications/utilities/surface/surfaceFeatureExtract/Allwclean
@@ -0,0 +1,7 @@
+#!/bin/sh
+cd ${0%/*} || exit 1    # Run from this directory
+
+wclean libso extractionMethod
+wclean .
+
+#------------------------------------------------------------------------------
diff --git a/applications/utilities/surface/surfaceFeatureExtract/Allwmake b/applications/utilities/surface/surfaceFeatureExtract/Allwmake
new file mode 100755
index 0000000000..ee26d27fc3
--- /dev/null
+++ b/applications/utilities/surface/surfaceFeatureExtract/Allwmake
@@ -0,0 +1,9 @@
+#!/bin/sh
+cd ${0%/*} || exit 1    # Run from this directory
+
+# Parse arguments for library compilation
+. $WM_PROJECT_DIR/wmake/scripts/AllwmakeParseArguments
+
+(wmake libso extractionMethod && wmake)
+
+#------------------------------------------------------------------------------
diff --git a/applications/utilities/surface/surfaceFeatureExtract/Make/options b/applications/utilities/surface/surfaceFeatureExtract/Make/options
index e57de43f22..b79e3e27c5 100644
--- a/applications/utilities/surface/surfaceFeatureExtract/Make/options
+++ b/applications/utilities/surface/surfaceFeatureExtract/Make/options
@@ -1,9 +1,11 @@
 EXE_INC = \
+    -IextractionMethod/lnInclude \
     -I$(LIB_SRC)/finiteVolume/lnInclude \
     -I$(LIB_SRC)/surfMesh/lnInclude \
     -I$(LIB_SRC)/meshTools/lnInclude \
     -I$(LIB_SRC)/sampling/lnInclude
 
 EXE_LIBS = \
+    -lsurfaceFeatureExtract \
     -lmeshTools \
     -lsampling
diff --git a/applications/utilities/surface/surfaceFeatureExtract/extractionMethod/Make/files b/applications/utilities/surface/surfaceFeatureExtract/extractionMethod/Make/files
new file mode 100644
index 0000000000..8c9bb27660
--- /dev/null
+++ b/applications/utilities/surface/surfaceFeatureExtract/extractionMethod/Make/files
@@ -0,0 +1,7 @@
+method = .
+$(method)/surfaceFeaturesExtraction.C
+$(method)/extractFromFile.C
+$(method)/extractFromNone.C
+$(method)/extractFromSurface.C
+
+LIB = $(FOAM_LIBBIN)/libsurfaceFeatureExtract
diff --git a/applications/utilities/surface/surfaceFeatureExtract/extractionMethod/Make/options b/applications/utilities/surface/surfaceFeatureExtract/extractionMethod/Make/options
new file mode 100644
index 0000000000..a5976d53f8
--- /dev/null
+++ b/applications/utilities/surface/surfaceFeatureExtract/extractionMethod/Make/options
@@ -0,0 +1,7 @@
+EXE_INC = \
+    -I$(LIB_SRC)/finiteVolume/lnInclude \
+    -I$(LIB_SRC)/surfMesh/lnInclude \
+    -I$(LIB_SRC)/meshTools/lnInclude
+
+LIB_LIBS = \
+    -lmeshTools
diff --git a/applications/utilities/surface/surfaceFeatureExtract/extractionMethod/extractFromFile.C b/applications/utilities/surface/surfaceFeatureExtract/extractionMethod/extractFromFile.C
new file mode 100644
index 0000000000..7b2b0c8ad0
--- /dev/null
+++ b/applications/utilities/surface/surfaceFeatureExtract/extractionMethod/extractFromFile.C
@@ -0,0 +1,103 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           |  Copyright (C) 2017 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "extractFromFile.H"
+#include "edgeMesh.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace surfaceFeaturesExtraction
+{
+    addNamedToRunTimeSelectionTable
+    (
+        method,
+        extractFromFile,
+        dictionary,
+        extractFromFile
+    );
+}
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::surfaceFeaturesExtraction::extractFromFile::extractFromFile
+(
+    const dictionary& dict
+)
+:
+    method()
+{
+    const dictionary& coeffDict =
+        dict.optionalSubDict("extractFromFileCoeffs");
+
+    coeffDict.lookup("featureEdgeFile") >> featureEdgeFile_;
+    coeffDict.readIfPresent("geometricTestOnly", geometricTestOnly_);
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
+
+Foam::surfaceFeaturesExtraction::extractFromFile::~extractFromFile()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+
+Foam::autoPtr<Foam::surfaceFeatures>
+Foam::surfaceFeaturesExtraction::extractFromFile::features
+(
+    const triSurface& surf
+) const
+{
+    edgeMesh eMesh(featureEdgeFile_);
+
+    // Sometimes duplicate edges are present. Remove them.
+    eMesh.mergeEdges();
+
+    Info<< nl << "Reading existing feature edges from file "
+        << featureEdgeFile_ << nl
+        << "Selecting edges based purely on geometric tests: "
+        << geometricTestOnly().asText() << endl;
+
+    return autoPtr<surfaceFeatures>
+    (
+        new surfaceFeatures
+        (
+            surf,
+            eMesh.points(),
+            eMesh.edges(),
+            1e-6,  // mergeTol
+            geometricTestOnly()
+        )
+    );
+}
+
+
+// ************************************************************************* //
diff --git a/applications/utilities/surface/surfaceFeatureExtract/extractionMethod/extractFromFile.H b/applications/utilities/surface/surfaceFeatureExtract/extractionMethod/extractFromFile.H
new file mode 100644
index 0000000000..8cd5cf4a97
--- /dev/null
+++ b/applications/utilities/surface/surfaceFeatureExtract/extractionMethod/extractFromFile.H
@@ -0,0 +1,88 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2017 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::surfaceFeaturesExtraction::extractFromFile
+
+Description
+    Run-time selectable surface feature extraction.
+
+    Selectable as "extractFromFile".
+    Mandatory dictionary entries: "featureEdgeFile".
+    Optional dictionary entries: "geometricTestOnly".
+
+SourceFiles
+    extractFromFile.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef surfaceFeaturesExtraction_extractFromFile_H
+#define surfaceFeaturesExtraction_extractFromFile_H
+
+#include "surfaceFeaturesExtraction.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace surfaceFeaturesExtraction
+{
+
+/*---------------------------------------------------------------------------*\
+         Class surfaceFeaturesExtraction::extractFromFile Declaration
+\*---------------------------------------------------------------------------*/
+
+class extractFromFile
+:
+    public method
+{
+    fileName featureEdgeFile_;
+
+
+public:
+
+    //- Construct from dictionary
+    extractFromFile(const dictionary& dict);
+
+    //- Destructor
+    virtual ~extractFromFile();
+
+    //- Features loaded (extracted) from featureEdgeFile
+    virtual autoPtr<surfaceFeatures> features
+    (
+        const triSurface& surf
+    ) const override;
+
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace surfaceFeaturesExtraction
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/applications/utilities/surface/surfaceFeatureExtract/extractionMethod/extractFromNone.C b/applications/utilities/surface/surfaceFeatureExtract/extractionMethod/extractFromNone.C
new file mode 100644
index 0000000000..45061472c4
--- /dev/null
+++ b/applications/utilities/surface/surfaceFeatureExtract/extractionMethod/extractFromNone.C
@@ -0,0 +1,80 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           |  Copyright (C) 2017 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "extractFromNone.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace surfaceFeaturesExtraction
+{
+    addNamedToRunTimeSelectionTable
+    (
+        method,
+        extractFromNone,
+        dictionary,
+        none
+    );
+}
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::surfaceFeaturesExtraction::extractFromNone::extractFromNone
+(
+    const dictionary& dict
+)
+:
+    method()
+{
+    // A "noneCoeffs" sub-dictionary doesn't make much sense.
+
+    dict.readIfPresent("includedAngle", includedAngle_);
+    dict.readIfPresent("geometricTestOnly", geometricTestOnly_);
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
+
+Foam::surfaceFeaturesExtraction::extractFromNone::~extractFromNone()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+Foam::autoPtr<Foam::surfaceFeatures>
+Foam::surfaceFeaturesExtraction::extractFromNone::features
+(
+    const triSurface& surf
+) const
+{
+    return autoPtr<surfaceFeatures>(new surfaceFeatures(surf));
+}
+
+
+// ************************************************************************* //
diff --git a/src/conversion/ccm/misc/mergePoints1.H b/applications/utilities/surface/surfaceFeatureExtract/extractionMethod/extractFromNone.H
similarity index 61%
rename from src/conversion/ccm/misc/mergePoints1.H
rename to applications/utilities/surface/surfaceFeatureExtract/extractionMethod/extractFromNone.H
index 85fc56210a..9cc9ebae60 100644
--- a/src/conversion/ccm/misc/mergePoints1.H
+++ b/applications/utilities/surface/surfaceFeatureExtract/extractionMethod/extractFromNone.H
@@ -2,8 +2,8 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
-     \\/     M anipulation  | Copyright (C) 2016 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2017 OpenCFD Ltd.
+     \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -21,50 +21,64 @@ License
     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::surfaceFeaturesExtraction::extractFromNone
+
 Description
-    Merge points. See below.
+    Run-time selectable surface feature extraction - no extraction.
+    Primarily useful with self-intersection methods.
+
+    Selectable as "none".
+    Optional dictionary entries: "includedAngle", "geometricTestOnly".
 
 SourceFiles
-    mergePoints.C
+    extractFromNone.C
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef mergePoints1_H
-#define mergePoints1_H
+#ifndef surfaceFeaturesExtraction_extractFromNone_H
+#define surfaceFeaturesExtraction_extractFromNone_H
 
-#include "scalar.H"
-#include "labelList.H"
+#include "surfaceFeaturesExtraction.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 namespace Foam
 {
+namespace surfaceFeaturesExtraction
+{
 
 /*---------------------------------------------------------------------------*\
-                           Function mergePoints Declaration
+         Class surfaceFeaturesExtraction::extractFromNone Declaration
 \*---------------------------------------------------------------------------*/
 
-//- Sorts and merges points. All points closer than/equal mergeTol get merged.
-//  Returns the number of unique points and a map from old to new.
-//template<class Type, template<class> class ListType=UList>
-template<class Type>
-label mergePoints
-(
-    const bool dummy,
-    const UIndirectList<Type>& points,
-    const scalar mergeTol,
-    const bool verbose,
-    labelList& pointMap,
-    const Type& origin = Type::zero
-);
+class extractFromNone
+:
+    public method
+{
+
+public:
+
+    //- Construct from dictionary
+    extractFromNone(const dictionary& dict);
+
+    //- Destructor
+    virtual ~extractFromNone();
+
+    //- Extracted features from surface (no-op)
+    virtual autoPtr<surfaceFeatures> features
+    (
+        const triSurface& surf
+    ) const override;
+
+
+};
 
-} // End namespace Foam
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-#ifdef NoRepository
-    #include "mergePoints1.C"
-#endif
+} // End namespace surfaceFeaturesExtraction
+} // End namespace Foam
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
diff --git a/applications/utilities/surface/surfaceFeatureExtract/extractionMethod/extractFromSurface.C b/applications/utilities/surface/surfaceFeatureExtract/extractionMethod/extractFromSurface.C
new file mode 100644
index 0000000000..35b5dc0e3f
--- /dev/null
+++ b/applications/utilities/surface/surfaceFeatureExtract/extractionMethod/extractFromSurface.C
@@ -0,0 +1,97 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           |  Copyright (C) 2017 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "extractFromSurface.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace surfaceFeaturesExtraction
+{
+    addNamedToRunTimeSelectionTable
+    (
+        method,
+        extractFromSurface,
+        dictionary,
+        extractFromSurface
+    );
+}
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::surfaceFeaturesExtraction::extractFromSurface::extractFromSurface
+(
+    const dictionary& dict
+)
+:
+    method()
+{
+    const dictionary& coeffDict =
+        dict.optionalSubDict("extractFromSurfaceCoeffs");
+
+    coeffDict.lookup("includedAngle") >> includedAngle_;
+    coeffDict.readIfPresent("geometricTestOnly", geometricTestOnly_);
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
+
+Foam::surfaceFeaturesExtraction::extractFromSurface::~extractFromSurface()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+
+Foam::autoPtr<Foam::surfaceFeatures>
+Foam::surfaceFeaturesExtraction::extractFromSurface::features
+(
+    const triSurface& surf
+) const
+{
+    Info<< nl << "Constructing feature set from included angle "
+        << includedAngle() << nl
+        << "Selecting edges based purely on geometric tests: "
+        << geometricTestOnly().asText() << endl;
+
+    return autoPtr<surfaceFeatures>
+    (
+        new surfaceFeatures
+        (
+            surf,
+            includedAngle(),
+            0,  // minLen
+            0,  // minElems
+            geometricTestOnly()
+        )
+    );
+}
+
+
+// ************************************************************************* //
diff --git a/src/conversion/ccm/misc/ListOps1.H b/applications/utilities/surface/surfaceFeatureExtract/extractionMethod/extractFromSurface.H
similarity index 54%
rename from src/conversion/ccm/misc/ListOps1.H
rename to applications/utilities/surface/surfaceFeatureExtract/extractionMethod/extractFromSurface.H
index 7e8490240c..83c2888d02 100644
--- a/src/conversion/ccm/misc/ListOps1.H
+++ b/applications/utilities/surface/surfaceFeatureExtract/extractionMethod/extractFromSurface.H
@@ -2,8 +2,8 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
-     \\/     M anipulation  | Copyright (C) 2016 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2017 OpenCFD Ltd.
+     \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -21,64 +21,66 @@ License
     You should have received a copy of the GNU General Public License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
-InNamspace
-    Foam
+Class
+    Foam::surfaceFeaturesExtraction::extractFromSurface
 
 Description
-    Various functions to operate on Lists.
+    Run-time selectable surface feature extraction - extract from surface.
+
+    Selectable as "extractFromSurface".
+
+    Mandatory dictionary entries: "includedAngle".
+    Optional dictionary entries: "geometricTestOnly".
 
 SourceFiles
-    ListOps.C
-    ListOpsTemplates.C
+    extractFromSurface.C
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef ListOps1_H
-#define ListOps1_H
+#ifndef surfaceFeaturesExtraction_extractFromSurface_H
+#define surfaceFeaturesExtraction_extractFromSurface_H
 
-#include "ListOps.H"
+#include "surfaceFeaturesExtraction.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 namespace Foam
 {
+namespace surfaceFeaturesExtraction
+{
 
-//- Reorder the elements (indices, not values) of a list.
-//  Negative ListType elements are untouched, unless pruning has been selected.
-//  With pruning, these elements are skipped and the list shrinks accordingly.
-template<class ListType>
-ListType reorder
-(
-    const labelUList& oldToNew,
-    const ListType&,
-    const bool prune
-);
+/*---------------------------------------------------------------------------*\
+         Class surfaceFeaturesExtraction::extractFromSurface Declaration
+\*---------------------------------------------------------------------------*/
 
-//- Inplace reorder the elements of a list.
-//  Negative ListType elements are untouched, unless pruning has been selected.
-//  With pruning, these elements are skipped and the list shrinks accordingly.
-template<class ListType>
-void inplaceReorder
-(
-    const labelUList& oldToNew,
-    ListType&,
-    const bool prune
-);
+class extractFromSurface
+:
+    public method
+{
+public:
+
+    //- Construct from dictionary
+    extractFromSurface(const dictionary& dict);
+
+    //- Destructor
+    virtual ~extractFromSurface();
+
+    //- Features extracted from surface
+    virtual autoPtr<surfaceFeatures> features
+    (
+        const triSurface& surf
+    ) const override;
+
+};
 
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
+} // End namespace surfaceFeaturesExtraction
 } // End namespace Foam
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-#ifdef NoRepository
-    #include "ListOps1Templates.C"
-#endif
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
 #endif
 
 // ************************************************************************* //
-
diff --git a/applications/utilities/surface/surfaceFeatureExtract/extractionMethod/surfaceFeaturesExtraction.C b/applications/utilities/surface/surfaceFeatureExtract/extractionMethod/surfaceFeaturesExtraction.C
new file mode 100644
index 0000000000..2108e73a9d
--- /dev/null
+++ b/applications/utilities/surface/surfaceFeatureExtract/extractionMethod/surfaceFeaturesExtraction.C
@@ -0,0 +1,90 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2017 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "surfaceFeaturesExtraction.H"
+#include "dictionary.H"
+#include "ListOps.H"
+#include "error.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace surfaceFeaturesExtraction
+{
+    defineTypeName(method);
+    defineRunTimeSelectionTable
+    (
+        method,
+        dictionary
+    );
+}
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::surfaceFeaturesExtraction::method::method()
+:
+    includedAngle_(0),
+    geometricTestOnly_(Switch::NO)
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
+
+Foam::surfaceFeaturesExtraction::method::~method()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+Foam::autoPtr<Foam::surfaceFeaturesExtraction::method>
+Foam::surfaceFeaturesExtraction::method::New
+(
+    const dictionary& dict
+)
+{
+    const word methodName = dict.lookup("extractionMethod");
+
+    auto cstrIter = dictionaryConstructorTablePtr_->cfind(methodName);
+
+    if (!cstrIter.found())
+    {
+        FatalIOErrorInFunction
+        (
+            dict
+        )   << "Unknown extractionMethod " << methodName << nl << nl
+            << "Valid extraction methods:" << nl
+            << flatOutput(dictionaryConstructorTablePtr_->sortedToc())
+            << exit(FatalIOError);
+    }
+
+    return autoPtr<method>(cstrIter.object()(dict));
+}
+
+
+// ************************************************************************* //
diff --git a/applications/utilities/surface/surfaceFeatureExtract/extractionMethod/surfaceFeaturesExtraction.H b/applications/utilities/surface/surfaceFeatureExtract/extractionMethod/surfaceFeaturesExtraction.H
new file mode 100644
index 0000000000..71c5ba5bc5
--- /dev/null
+++ b/applications/utilities/surface/surfaceFeatureExtract/extractionMethod/surfaceFeaturesExtraction.H
@@ -0,0 +1,141 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2017 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Namespace
+    Foam::surfaceFeaturesExtraction
+
+Description
+    Namespace for run-time selectable surface feature extraction methods.
+
+Class
+    Foam::surfaceFeaturesExtraction::method
+
+Description
+    Abstract base for run-time selectable surface feature extraction methods.
+
+SourceFiles
+    surfaceFeaturesExtraction.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef surfaceFeaturesExtraction_method_H
+#define surfaceFeaturesExtraction_method_H
+
+#include "surfaceFeatures.H"
+#include "dictionary.H"
+#include "Switch.H"
+#include "runTimeSelectionTables.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace surfaceFeaturesExtraction
+{
+
+/*---------------------------------------------------------------------------*\
+              Class surfaceFeaturesExtraction::method Declaration
+\*---------------------------------------------------------------------------*/
+
+class method
+{
+protected:
+
+    scalar includedAngle_;
+    Switch geometricTestOnly_;
+
+    //- Construct null
+    method();
+
+
+public:
+
+    //- Runtime type information
+    ClassNameNoDebug("method");
+
+
+    // Constructors
+
+        //- Construct from dictionary
+        method(const dictionary& dict);
+
+
+    // Declare run-time constructor selection table
+    declareRunTimeSelectionTable
+    (
+        autoPtr,
+        method,
+        dictionary,
+        (
+            const dictionary& dict
+        ),
+        (dict)
+    );
+
+
+    // Selectors
+
+        //- Select constructed from dictionary
+        static autoPtr<method> New
+        (
+            const dictionary& dict
+        );
+
+
+    //- Destructor
+    virtual ~method();
+
+
+    // Member Functions
+
+        //- The included angle, if set
+        inline scalar includedAngle() const
+        {
+            return includedAngle_;
+        }
+
+        //- Use geometric test only
+        inline Switch geometricTestOnly() const
+        {
+            return geometricTestOnly_;
+        }
+
+        //- Extracted features
+        virtual autoPtr<surfaceFeatures> features
+        (
+            const triSurface& surf
+        ) const = 0;
+
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace surfaceFeaturesExtraction
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/applications/utilities/surface/surfaceFeatureExtract/surfaceFeatureExtract.C b/applications/utilities/surface/surfaceFeatureExtract/surfaceFeatureExtract.C
index a91ed5140a..7c530d79e2 100644
--- a/applications/utilities/surface/surfaceFeatureExtract/surfaceFeatureExtract.C
+++ b/applications/utilities/surface/surfaceFeatureExtract/surfaceFeatureExtract.C
@@ -3,7 +3,7 @@
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
     \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
-     \\/     M anipulation  | Copyright (C) 2015-2016 OpenCFD Ltd.
+     \\/     M anipulation  | Copyright (C) 2015-2017 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -29,866 +29,219 @@ Group
 
 Description
     Extracts and writes surface features to file. All but the basic feature
-    extraction is WIP.
+    extraction is a work-in-progress.
 
-    Curvature calculation is an implementation of the algorithm from:
+    The extraction process is driven by the \a system/surfaceFeatureExtractDict
+    dictionary, but the \a -dict option can be used to define an alternative
+    location.
 
-      "Estimating Curvatures and their Derivatives on Triangle Meshes"
-      by S. Rusinkiewicz
+    The \a system/surfaceFeatureExtractDict dictionary contains entries
+    for each extraction process.
+    The name of the individual dictionary is used to load the input surface
+    (found under \a constant/triSurface) and also as the basename for the
+    output.
 
+    If the \c surfaces entry is present in a sub-dictionary, it has absolute
+    precedence over a surface name deduced from the dictionary name.
+    If the dictionary name itself does not have an extension, the \c surfaces
+    entry becomes mandatory since in this case the dictionary name cannot
+    represent an input surface file (ie, there is no file extension).
+    The \c surfaces entry is a wordRe list, which allows loading and
+    combining of multiple surfaces. Any exactly specified surface names must
+    exist, but surfaces selected via regular expressions need not exist.
+    The selection mechanism preserves order and is without duplicates.
+    For example,
+    \verbatim
+    dictName
+    {
+        surfaces    (surface1.stl "other.*" othersurf.obj);
+        ...
+    }
+    \endverbatim
+
+    When loading surfaces, the points/faces/regions of each surface are
+    normally offset to create an aggregated surface. No merging of points
+    or faces is done. The optional entry \c loadingOption can be used to
+    adjust the treatment of the regions when loading single or multiple files,
+    with selections according to the Foam::triSurfaceLoader::loadingOption
+    enumeration.
+    \verbatim
+    dictName
+    {
+        // Optional treatment of surface regions when loading
+        // (single, file, offset, merge)
+        loadingOption   file;
+        ...
+    }
+    \endverbatim
+    The \c loadingOption is primarily used in combination with the
+    \c intersectionMethod (specifically its \c region option).
+    The default \c loadingOption is normally \c offset,
+    but this changes to \c file if the \c intersectionMethod
+    \c region is being used.
+
+    Once surfaces have been loaded, the first stage is to extract
+    features according to the specified \c extractionMethod with values
+    as per the following table:
+    \table
+        extractionMethod   | Description
+        none               | No feature extraction
+        extractFromFile    | Load features from the file named in featureEdgeFile
+        extractFromSurface | Extract features from surface geometry
+    \endtable
+
+    There are a few entries that influence the extraction behaviour:
+    \verbatim
+        // File to use for extractFromFile input
+        featureEdgeFile     "FileName"
+
+        // Mark edges whose adjacent surface normals are at an angle less
+        // than includedAngle as features
+        // - 0  : selects no edges
+        // - 180: selects all edges
+        includedAngle       120;
+
+        // Do not mark region edges
+        geometricTestOnly   yes;
+    \endverbatim
+
+    This initial set of edges can be trimmed:
+    \verbatim
+        trimFeatures
+        {
+            // Remove features with fewer than the specified number of edges
+            minElem         0;
+
+            // Remove features shorter than the specified cumulative length
+            minLen          0.0;
+        }
+    \endverbatim
+
+    and subsetted
+    \verbatim
+    subsetFeatures
+    {
+        // Use a plane to select feature edges (normal)(basePoint)
+        // Only keep edges that intersect the plane
+        plane           (1 0 0)(0 0 0);
+
+        // Select feature edges using a box // (minPt)(maxPt)
+        // Only keep edges inside the box:
+        insideBox       (0 0 0)(1 1 1);
+
+        // Only keep edges outside the box:
+        outsideBox      (0 0 0)(1 1 1);
+
+        // Keep nonManifold edges (edges with >2 connected faces where
+        // the faces form more than two different normal planes)
+        nonManifoldEdges yes;
+
+        // Keep open edges (edges with 1 connected face)
+        openEdges       yes;
+    }
+    \endverbatim
+
+    Subsequently, additional features can be added from another file:
+    \verbatim
+        addFeatures
+        {
+            // Add (without merging) another extendedFeatureEdgeMesh
+            name        axZ.extendedFeatureEdgeMesh;
+        }
+    \endverbatim
+
+    The intersectionMethod provides a final means of adding additional
+    features. These are loosely termed "self-intersection", since it
+    detects the face/face intersections of the loaded surface or surfaces.
+
+    \table
+        intersectionMethod | Description
+        none    | Do nothing
+        self    | All face/face intersections
+        region  | Limit face/face intersections to those between different regions.
+    \endtable
+    The optional \c tolerance tuning parameter is available for handling
+    the face/face intersections, but should normally not be touched.
+
+    As well as the normal extendedFeatureEdgeMesh written,
+    other items can be selected with boolean switches:
+
+    \table
+        Output option | Description
+        closeness | Output the closeness of surface elements to other surface elements.
+        curvature | Output surface curvature
+        featureProximity | Output the proximity of feature points and edges to another
+        writeObj  | Write features to OBJ format for postprocessing
+        writeVTK  | Write closeness/curvature/proximity fields as VTK for postprocessing
+    \endtable
+
+Note
+   Although surfaceFeatureExtract can do many things, there are still a fair
+   number of corner cases where it may not produce the desired result.
 \*---------------------------------------------------------------------------*/
 
 #include "argList.H"
 #include "Time.H"
 #include "triSurface.H"
-#include "surfaceFeatures.H"
+#include "triSurfaceTools.H"
+#include "edgeMeshTools.H"
+#include "surfaceFeaturesExtraction.H"
+#include "surfaceIntersection.H"
 #include "featureEdgeMesh.H"
 #include "extendedFeatureEdgeMesh.H"
 #include "treeBoundBox.H"
 #include "meshTools.H"
-#include "OFstream.H"
+#include "OBJstream.H"
 #include "triSurfaceMesh.H"
 #include "vtkSurfaceWriter.H"
-#include "triSurfaceFields.H"
-#include "indexedOctree.H"
-#include "treeDataEdge.H"
 #include "unitConversion.H"
 #include "plane.H"
-#include "tensor2D.H"
-#include "symmTensor2D.H"
 #include "point.H"
-#include "triadField.H"
-#include "transform.H"
+#include "triSurfaceLoader.H"
 
 using namespace Foam;
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-scalar calcVertexNormalWeight
-(
-    const triFace& f,
-    const label pI,
-    const vector& fN,
-    const pointField& points
-)
-{
-    label index = findIndex(f, pI);
-
-    if (index == -1)
-    {
-        FatalErrorInFunction
-            << "Point not in face" << abort(FatalError);
-    }
-
-    const vector e1 = points[f[index]] - points[f[f.fcIndex(index)]];
-    const vector e2 = points[f[index]] - points[f[f.rcIndex(index)]];
-
-    return mag(fN)/(magSqr(e1)*magSqr(e2) + VSMALL);
-}
-
-
-triadField calcVertexCoordSys
-(
-    const triSurface& surf,
-    const vectorField& pointNormals
-)
-{
-    const pointField& points = surf.points();
-    const Map<label>& meshPointMap = surf.meshPointMap();
-
-    triadField pointCoordSys(points.size());
-
-    forAll(points, pI)
-    {
-        const point& pt = points[pI];
-        const vector& normal = pointNormals[meshPointMap[pI]];
-
-        if (mag(normal) < SMALL)
-        {
-            pointCoordSys[meshPointMap[pI]] = triad::unset;
-            continue;
-        }
-
-        plane p(pt, normal);
-
-        // Pick arbitrary point in plane
-        vector dir1 = pt - p.somePointInPlane(1e-3);
-        dir1 /= mag(dir1);
-
-        vector dir2 = dir1 ^ normal;
-        dir2 /= mag(dir2);
-
-        pointCoordSys[meshPointMap[pI]] = triad(dir1, dir2, normal);
-    }
-
-    return pointCoordSys;
-}
-
-
-vectorField calcVertexNormals(const triSurface& surf)
-{
-    // Weighted average of normals of faces attached to the vertex
-    // Weight = fA / (mag(e0)^2 * mag(e1)^2);
-
-    Info<< "Calculating vertex normals" << endl;
-
-    vectorField pointNormals(surf.nPoints(), Zero);
-
-    const pointField& points = surf.points();
-    const labelListList& pointFaces = surf.pointFaces();
-    const labelList& meshPoints = surf.meshPoints();
-
-    forAll(pointFaces, pI)
-    {
-        const labelList& pFaces = pointFaces[pI];
-
-        forAll(pFaces, fI)
-        {
-            const label facei = pFaces[fI];
-            const triFace& f = surf[facei];
-
-            vector fN = f.normal(points);
-
-            scalar weight = calcVertexNormalWeight
-            (
-                f,
-                meshPoints[pI],
-                fN,
-                points
-            );
-
-            pointNormals[pI] += weight*fN;
-        }
-
-        pointNormals[pI] /= mag(pointNormals[pI]) + VSMALL;
-    }
-
-    return pointNormals;
-}
-
-
-triSurfacePointScalarField calcCurvature
-(
-    const word& name,
-    const Time& runTime,
-    const triSurface& surf,
-    const vectorField& pointNormals,
-    const triadField& pointCoordSys
-)
-{
-    Info<< "Calculating face curvature" << endl;
-
-    const pointField& points = surf.points();
-    const labelList& meshPoints = surf.meshPoints();
-    const Map<label>& meshPointMap = surf.meshPointMap();
-
-    triSurfacePointScalarField curvaturePointField
-    (
-        IOobject
-        (
-            name + ".curvature",
-            runTime.constant(),
-            "triSurface",
-            runTime,
-            IOobject::NO_READ,
-            IOobject::NO_WRITE
-        ),
-        surf,
-        dimLength,
-        scalarField(points.size(), 0.0)
-    );
-
-    List<symmTensor2D> pointFundamentalTensors
-    (
-        points.size(),
-        symmTensor2D::zero
-    );
-
-    scalarList accumulatedWeights(points.size(), 0.0);
-
-    forAll(surf, fI)
-    {
-        const triFace& f = surf[fI];
-        const edgeList fEdges = f.edges();
-
-        // Calculate the edge vectors and the normal differences
-        vectorField edgeVectors(f.size(), Zero);
-        vectorField normalDifferences(f.size(), Zero);
-
-        forAll(fEdges, feI)
-        {
-            const edge& e = fEdges[feI];
-
-            edgeVectors[feI] = e.vec(points);
-            normalDifferences[feI] =
-               pointNormals[meshPointMap[e[0]]]
-             - pointNormals[meshPointMap[e[1]]];
-        }
-
-        // Set up a local coordinate system for the face
-        const vector& e0 = edgeVectors[0];
-        const vector eN = f.normal(points);
-        const vector e1 = (e0 ^ eN);
-
-        if (magSqr(eN) < ROOTVSMALL)
-        {
-            continue;
-        }
-
-        triad faceCoordSys(e0, e1, eN);
-        faceCoordSys.normalize();
-
-        // Construct the matrix to solve
-        scalarSymmetricSquareMatrix T(3, 0);
-        scalarDiagonalMatrix Z(3, 0);
-
-        // Least Squares
-        for (label i = 0; i < 3; ++i)
-        {
-            scalar x = edgeVectors[i] & faceCoordSys[0];
-            scalar y = edgeVectors[i] & faceCoordSys[1];
-
-            T(0, 0) += sqr(x);
-            T(1, 0) += x*y;
-            T(1, 1) += sqr(x) + sqr(y);
-            T(2, 1) += x*y;
-            T(2, 2) += sqr(y);
-
-            scalar dndx = normalDifferences[i] & faceCoordSys[0];
-            scalar dndy = normalDifferences[i] & faceCoordSys[1];
-
-            Z[0] += dndx*x;
-            Z[1] += dndx*y + dndy*x;
-            Z[2] += dndy*y;
-        }
-
-        // Perform Cholesky decomposition and back substitution.
-        // Decomposed matrix is in T and solution is in Z.
-        LUsolve(T, Z);
-        symmTensor2D secondFundamentalTensor(Z[0], Z[1], Z[2]);
-
-        // Loop over the face points adding the contribution of the face
-        // curvature to the points.
-        forAll(f, fpI)
-        {
-            const label patchPointIndex = meshPointMap[f[fpI]];
-
-            const triad& ptCoordSys = pointCoordSys[patchPointIndex];
-
-            if (!ptCoordSys.set())
-            {
-                continue;
-            }
-
-            // Rotate faceCoordSys to ptCoordSys
-            tensor rotTensor = rotationTensor(ptCoordSys[2], faceCoordSys[2]);
-            triad rotatedFaceCoordSys = rotTensor & tensor(faceCoordSys);
-
-            // Project the face curvature onto the point plane
-
-            vector2D cmp1
-            (
-                ptCoordSys[0] & rotatedFaceCoordSys[0],
-                ptCoordSys[0] & rotatedFaceCoordSys[1]
-            );
-            vector2D cmp2
-            (
-                ptCoordSys[1] & rotatedFaceCoordSys[0],
-                ptCoordSys[1] & rotatedFaceCoordSys[1]
-            );
-
-            tensor2D projTensor
-            (
-                cmp1,
-                cmp2
-            );
-
-            symmTensor2D projectedFundamentalTensor
-            (
-                projTensor.x() & (secondFundamentalTensor & projTensor.x()),
-                projTensor.x() & (secondFundamentalTensor & projTensor.y()),
-                projTensor.y() & (secondFundamentalTensor & projTensor.y())
-            );
-
-            // Calculate weight
-            // TODO: Voronoi area weighting
-            scalar weight = calcVertexNormalWeight
-            (
-                f,
-                meshPoints[patchPointIndex],
-                f.normal(points),
-                points
-            );
-
-            // Sum contribution of face to this point
-            pointFundamentalTensors[patchPointIndex] +=
-                weight*projectedFundamentalTensor;
-
-            accumulatedWeights[patchPointIndex] += weight;
-        }
-
-        if (false)
-        {
-            Info<< "Points = " << points[f[0]] << " "
-                << points[f[1]] << " "
-                << points[f[2]] << endl;
-            Info<< "edgeVecs = " << edgeVectors[0] << " "
-                << edgeVectors[1] << " "
-                << edgeVectors[2] << endl;
-            Info<< "normDiff = " << normalDifferences[0] << " "
-                << normalDifferences[1] << " "
-                << normalDifferences[2] << endl;
-            Info<< "faceCoordSys = " << faceCoordSys << endl;
-            Info<< "T = " << T << endl;
-            Info<< "Z = " << Z << endl;
-        }
-    }
-
-    forAll(curvaturePointField, pI)
-    {
-        pointFundamentalTensors[pI] /= (accumulatedWeights[pI] + SMALL);
-
-        vector2D principalCurvatures = eigenValues(pointFundamentalTensors[pI]);
-
-        //scalar curvature =
-        //    (principalCurvatures[0] + principalCurvatures[1])/2;
-        scalar curvature = max
-        (
-            mag(principalCurvatures[0]),
-            mag(principalCurvatures[1])
-        );
-        //scalar curvature = principalCurvatures[0]*principalCurvatures[1];
-
-        curvaturePointField[meshPoints[pI]] = curvature;
-    }
-
-    return curvaturePointField;
-}
-
-
-bool edgesConnected(const edge& e1, const edge& e2)
-{
-    if
-    (
-        e1.start() == e2.start()
-     || e1.start() == e2.end()
-     || e1.end() == e2.start()
-     || e1.end() == e2.end()
-    )
-    {
-        return true;
-    }
-
-    return false;
-}
-
-
-scalar calcProximityOfFeaturePoints
-(
-    const List<pointIndexHit>& hitList,
-    const scalar defaultCellSize
-)
-{
-    scalar minDist = defaultCellSize;
-
-    for
-    (
-        label hI1 = 0;
-        hI1 < hitList.size() - 1;
-        ++hI1
-    )
-    {
-        const pointIndexHit& pHit1 = hitList[hI1];
-
-        if (pHit1.hit())
-        {
-            for
-            (
-                label hI2 = hI1 + 1;
-                hI2 < hitList.size();
-                ++hI2
-            )
-            {
-                const pointIndexHit& pHit2 = hitList[hI2];
-
-                if (pHit2.hit())
-                {
-                    scalar curDist = mag(pHit1.hitPoint() - pHit2.hitPoint());
-
-                    minDist = min(curDist, minDist);
-                }
-            }
-        }
-    }
-
-    return minDist;
-}
-
-
-scalar calcProximityOfFeatureEdges
-(
-    const extendedFeatureEdgeMesh& efem,
-    const List<pointIndexHit>& hitList,
-    const scalar defaultCellSize
-)
-{
-    scalar minDist = defaultCellSize;
-
-    for
-    (
-        label hI1 = 0;
-        hI1 < hitList.size() - 1;
-        ++hI1
-    )
-    {
-        const pointIndexHit& pHit1 = hitList[hI1];
-
-        if (pHit1.hit())
-        {
-            const edge& e1 = efem.edges()[pHit1.index()];
-
-            for
-            (
-                label hI2 = hI1 + 1;
-                hI2 < hitList.size();
-                ++hI2
-            )
-            {
-                const pointIndexHit& pHit2 = hitList[hI2];
-
-                if (pHit2.hit())
-                {
-                    const edge& e2 = efem.edges()[pHit2.index()];
-
-                    // Don't refine if the edges are connected to each other
-                    if (!edgesConnected(e1, e2))
-                    {
-                        scalar curDist =
-                            mag(pHit1.hitPoint() - pHit2.hitPoint());
-
-                        minDist = min(curDist, minDist);
-                    }
-                }
-            }
-        }
-    }
-
-    return minDist;
-}
-
-
-void dumpBox(const treeBoundBox& bb, const fileName& fName)
-{
-    OFstream str(fName);
-
-    Info<< "Dumping bounding box " << bb << " as lines to obj file "
-        << str.name() << endl;
-
-
-    pointField boxPoints(bb.points());
-
-    forAll(boxPoints, i)
-    {
-        meshTools::writeOBJ(str, boxPoints[i]);
-    }
-
-    forAll(treeBoundBox::edges, i)
-    {
-        const edge& e = treeBoundBox::edges[i];
-
-        str<< "l " << e[0]+1 <<  ' ' << e[1]+1 << nl;
-    }
-}
-
-
-// Deletes all edges inside/outside bounding box from set.
-void deleteBox
-(
-    const triSurface& surf,
-    const treeBoundBox& bb,
-    const bool removeInside,
-    List<surfaceFeatures::edgeStatus>& edgeStat
-)
-{
-    forAll(edgeStat, edgeI)
-    {
-        const point eMid = surf.edges()[edgeI].centre(surf.localPoints());
-
-        if (removeInside ? bb.contains(eMid) : !bb.contains(eMid))
-        {
-            edgeStat[edgeI] = surfaceFeatures::NONE;
-        }
-    }
-}
-
-
-bool onLine(const point& p, const linePointRef& line)
-{
-    const point& a = line.start();
-    const point& b = line.end();
-
-    if
-    (
-        ( p.x() < min(a.x(), b.x()) || p.x() > max(a.x(), b.x()) )
-     || ( p.y() < min(a.y(), b.y()) || p.y() > max(a.y(), b.y()) )
-     || ( p.z() < min(a.z(), b.z()) || p.z() > max(a.z(), b.z()) )
-    )
-    {
-        return false;
-    }
-
-    return true;
-}
-
-
-// Deletes all edges inside/outside bounding box from set.
-void deleteEdges
-(
-    const triSurface& surf,
-    const plane& cutPlane,
-    List<surfaceFeatures::edgeStatus>& edgeStat
-)
-{
-    const pointField& points = surf.points();
-    const labelList& meshPoints = surf.meshPoints();
-
-    forAll(edgeStat, edgeI)
-    {
-        const edge& e = surf.edges()[edgeI];
-        const point& p0 = points[meshPoints[e.start()]];
-        const point& p1 = points[meshPoints[e.end()]];
-        const linePointRef line(p0, p1);
-
-        // If edge does not intersect the plane, delete.
-        scalar intersect = cutPlane.lineIntersect(line);
-
-        point featPoint = intersect * (p1 - p0) + p0;
-
-        if (!onLine(featPoint, line))
-        {
-            edgeStat[edgeI] = surfaceFeatures::NONE;
-        }
-    }
-}
-
-
-void drawHitProblem
-(
-    label fI,
-    const triSurface& surf,
-    const pointField& start,
-    const pointField& faceCentres,
-    const pointField& end,
-    const List<pointIndexHit>& hitInfo
-)
-{
-    Info<< nl << "# findLineAll did not hit its own face."
-        << nl << "# fI " << fI
-        << nl << "# start " << start[fI]
-        << nl << "# f centre " << faceCentres[fI]
-        << nl << "# end " << end[fI]
-        << nl << "# hitInfo " << hitInfo
-        << endl;
-
-    meshTools::writeOBJ(Info, start[fI]);
-    meshTools::writeOBJ(Info, faceCentres[fI]);
-    meshTools::writeOBJ(Info, end[fI]);
-
-    Info<< "l 1 2 3" << endl;
-
-    meshTools::writeOBJ(Info, surf.points()[surf[fI][0]]);
-    meshTools::writeOBJ(Info, surf.points()[surf[fI][1]]);
-    meshTools::writeOBJ(Info, surf.points()[surf[fI][2]]);
-
-    Info<< "f 4 5 6" << endl;
-
-    forAll(hitInfo, hI)
-    {
-        label hFI = hitInfo[hI].index();
-
-        meshTools::writeOBJ(Info, surf.points()[surf[hFI][0]]);
-        meshTools::writeOBJ(Info, surf.points()[surf[hFI][1]]);
-        meshTools::writeOBJ(Info, surf.points()[surf[hFI][2]]);
-
-        Info<< "f "
-            << 3*hI + 7 << " "
-            << 3*hI + 8 << " "
-            << 3*hI + 9
-            << endl;
-    }
-}
-
-
-// Unmark non-manifold edges if individual triangles are not features
-void unmarkBaffles
-(
-    const triSurface& surf,
-    const scalar includedAngle,
-    List<surfaceFeatures::edgeStatus>& edgeStat
-)
-{
-    scalar minCos = Foam::cos(degToRad(180.0 - includedAngle));
-
-    const labelListList& edgeFaces = surf.edgeFaces();
-
-    forAll(edgeFaces, edgeI)
-    {
-        const labelList& eFaces = edgeFaces[edgeI];
-
-        if (eFaces.size() > 2)
-        {
-            label i0 = eFaces[0];
-            //const labelledTri& f0 = surf[i0];
-            const Foam::vector& n0 = surf.faceNormals()[i0];
-
-            //Pout<< "edge:" << edgeI << " n0:" << n0 << endl;
-
-            bool same = true;
-
-            for (label i = 1; i < eFaces.size(); i++)
-            {
-                //const labelledTri& f = surf[i];
-                const Foam::vector& n = surf.faceNormals()[eFaces[i]];
-
-                //Pout<< "    mag(n&n0): " << mag(n&n0) << endl;
-
-                if (mag(n&n0) < minCos)
-                {
-                    same = false;
-                    break;
-                }
-            }
-
-            if (same)
-            {
-                edgeStat[edgeI] = surfaceFeatures::NONE;
-            }
-        }
-    }
-}
-
-
-//- Divide into multiple normal bins
-//  - return REGION if != 2 normals
-//  - return REGION if 2 normals that make feature angle
-//  - otherwise return NONE and set normals,bins
-surfaceFeatures::edgeStatus checkFlatRegionEdge
-(
-    const triSurface& surf,
-    const scalar tol,
-    const scalar includedAngle,
-    const label edgeI
-)
-{
-    const edge& e = surf.edges()[edgeI];
-    const labelList& eFaces = surf.edgeFaces()[edgeI];
-
-    // Bin according to normal
-
-    DynamicList<Foam::vector> normals(2);
-    DynamicList<labelList> bins(2);
-
-    forAll(eFaces, eFacei)
-    {
-        const Foam::vector& n = surf.faceNormals()[eFaces[eFacei]];
-
-        // Find the normal in normals
-        label index = -1;
-        forAll(normals, normalI)
-        {
-            if (mag(n&normals[normalI]) > (1-tol))
-            {
-                index = normalI;
-                break;
-            }
-        }
-
-        if (index != -1)
-        {
-            bins[index].append(eFacei);
-        }
-        else if (normals.size() >= 2)
-        {
-            // Would be third normal. Mark as feature.
-            //Pout<< "** at edge:" << surf.localPoints()[e[0]]
-            //    << surf.localPoints()[e[1]]
-            //    << " have normals:" << normals
-            //    << " and " << n << endl;
-            return surfaceFeatures::REGION;
-        }
-        else
-        {
-            normals.append(n);
-            bins.append(labelList(1, eFacei));
-        }
-    }
-
-
-    // Check resulting number of bins
-    if (bins.size() == 1)
-    {
-        // Note: should check here whether they are two sets of faces
-        // that are planar or indeed 4 faces al coming together at an edge.
-        //Pout<< "** at edge:"
-        //    << surf.localPoints()[e[0]]
-        //    << surf.localPoints()[e[1]]
-        //    << " have single normal:" << normals[0]
-        //    << endl;
-        return surfaceFeatures::NONE;
-    }
-    else
-    {
-        // Two bins. Check if normals make an angle
-
-        //Pout<< "** at edge:"
-        //    << surf.localPoints()[e[0]]
-        //    << surf.localPoints()[e[1]] << nl
-        //    << "    normals:" << normals << nl
-        //    << "    bins   :" << bins << nl
-        //    << endl;
-
-        if (includedAngle >= 0)
-        {
-            scalar minCos = Foam::cos(degToRad(180.0 - includedAngle));
-
-            forAll(eFaces, i)
-            {
-                const Foam::vector& ni = surf.faceNormals()[eFaces[i]];
-                for (label j=i+1; j<eFaces.size(); j++)
-                {
-                    const Foam::vector& nj = surf.faceNormals()[eFaces[j]];
-                    if (mag(ni & nj) < minCos)
-                    {
-                        //Pout<< "have sharp feature between normal:" << ni
-                        //    << " and " << nj << endl;
-
-                        // Is feature. Keep as region or convert to
-                        // feature angle? For now keep as region.
-                        return surfaceFeatures::REGION;
-                    }
-                }
-            }
-        }
-
-
-        // So now we have two normals bins but need to make sure both
-        // bins have the same regions in it.
-
-         // 1. store + or - region number depending
-        //    on orientation of triangle in bins[0]
-        const labelList& bin0 = bins[0];
-        labelList regionAndNormal(bin0.size());
-        forAll(bin0, i)
-        {
-            const labelledTri& t = surf.localFaces()[eFaces[bin0[i]]];
-            int dir = t.edgeDirection(e);
-
-            if (dir > 0)
-            {
-                regionAndNormal[i] = t.region()+1;
-            }
-            else if (dir == 0)
-            {
-                FatalErrorInFunction
-                    << exit(FatalError);
-            }
-            else
-            {
-                regionAndNormal[i] = -(t.region()+1);
-            }
-        }
-
-        // 2. check against bin1
-        const labelList& bin1 = bins[1];
-        labelList regionAndNormal1(bin1.size());
-        forAll(bin1, i)
-        {
-            const labelledTri& t = surf.localFaces()[eFaces[bin1[i]]];
-            int dir = t.edgeDirection(e);
-
-            label myRegionAndNormal;
-            if (dir > 0)
-            {
-                myRegionAndNormal = t.region()+1;
-            }
-            else
-            {
-                myRegionAndNormal = -(t.region()+1);
-            }
-
-            regionAndNormal1[i] = myRegionAndNormal;
-
-            label index = findIndex(regionAndNormal, -myRegionAndNormal);
-            if (index == -1)
-            {
-                // Not found.
-                //Pout<< "cannot find region " << myRegionAndNormal
-                //    << " in regions " << regionAndNormal << endl;
-
-                return surfaceFeatures::REGION;
-            }
-        }
-
-        // Passed all checks, two normal bins with the same contents.
-        //Pout<< "regionAndNormal:" << regionAndNormal << endl;
-        //Pout<< "myRegionAndNormal:" << regionAndNormal1 << endl;
-
-        return surfaceFeatures::NONE;
-    }
-}
-
-
-void writeStats(const extendedFeatureEdgeMesh& fem, Ostream& os)
-{
-    os  << "    points : " << fem.points().size() << nl
-        << "    of which" << nl
-        << "        convex             : "
-        << fem.concaveStart() << nl
-        << "        concave            : "
-        << (fem.mixedStart()-fem.concaveStart()) << nl
-        << "        mixed              : "
-        << (fem.nonFeatureStart()-fem.mixedStart()) << nl
-        << "        non-feature        : "
-        << (fem.points().size()-fem.nonFeatureStart()) << nl
-        << "    edges  : " << fem.edges().size() << nl
-        << "    of which" << nl
-        << "        external edges     : "
-        << fem.internalStart() << nl
-        << "        internal edges     : "
-        << (fem.flatStart()- fem.internalStart()) << nl
-        << "        flat edges         : "
-        << (fem.openStart()- fem.flatStart()) << nl
-        << "        open edges         : "
-        << (fem.multipleStart()- fem.openStart()) << nl
-        << "        multiply connected : "
-        << (fem.edges().size()- fem.multipleStart()) << endl;
-}
-
-
-
 int main(int argc, char *argv[])
 {
     argList::addNote
     (
-        "extract and write surface features to file"
+        "Extract and write surface features to file"
     );
     argList::noParallel();
+    argList::noFunctionObjects();
 
-    #include "addDictOption.H"
+    argList::addOption
+    (
+        "dict",
+        "file",
+        "read surfaceFeatureExtractDict from specified location"
+    );
 
     #include "setRootCase.H"
     #include "createTime.H"
 
+    Info<< nl
+        << "Note: "
+        << "Feature line extraction only valid on closed manifold surfaces"
+        << nl << nl;
+
     const word dictName("surfaceFeatureExtractDict");
     #include "setSystemRunTimeDictionaryIO.H"
 
     Info<< "Reading " << dictName << nl << endl;
-
     const IOdictionary dict(dictIO);
 
-    forAllConstIter(dictionary, dict, iter)
+    // Loader for available triSurface surface files
+    triSurfaceLoader loader(runTime);
+
+    // Where to write VTK output files
+    const fileName vtkOutputDir = runTime.constantPath()/"triSurface";
+
+    forAllConstIters(dict, iter)
     {
-        if (!iter().isDict())
+        if (!iter().isDict() || iter().keyword().isPattern())
         {
             continue;
         }
@@ -897,167 +250,167 @@ int main(int argc, char *argv[])
 
         if (!surfaceDict.found("extractionMethod"))
         {
+            // Insist on an extractionMethod
             continue;
         }
 
-        const word extractionMethod = surfaceDict.lookup("extractionMethod");
+        // The output name based in dictionary name (without extensions)
+        const word& dictName = iter().keyword();
+        const word outputName = dictName.lessExt();
 
-        const fileName surfFileName = iter().keyword();
-        const fileName sFeatFileName = surfFileName.lessExt().name();
-
-        Info<< "Surface            : " << surfFileName << nl << endl;
-
-        const Switch writeVTK =
-            surfaceDict.lookupOrDefault<Switch>("writeVTK", "off");
-        const Switch writeObj =
-            surfaceDict.lookupOrDefault<Switch>("writeObj", "off");
-
-        const Switch curvature =
-            surfaceDict.lookupOrDefault<Switch>("curvature", "off");
-        const Switch featureProximity =
-            surfaceDict.lookupOrDefault<Switch>("featureProximity", "off");
-        const Switch closeness =
-            surfaceDict.lookupOrDefault<Switch>("closeness", "off");
-
-
-        Info<< nl << "Feature line extraction is only valid on closed manifold "
-            << "surfaces." << endl;
-
-        // Read
-        // ~~~~
-
-        triSurface surf(runTime.constantPath()/"triSurface"/surfFileName);
-
-        Info<< "Statistics:" << endl;
-        surf.writeStats(Info);
-        Info<< endl;
-
-        faceList faces(surf.size());
-
-        forAll(surf, fI)
-        {
-            faces[fI] = surf[fI].triFaceFace();
-        }
-
-
-        // Either construct features from surface & featureAngle or read set.
-        // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-
-        autoPtr<surfaceFeatures> set;
-
-        scalar includedAngle = 0.0;
-
-        if (extractionMethod == "extractFromFile")
-        {
-            const dictionary& extractFromFileDict =
-                surfaceDict.subDict("extractFromFileCoeffs");
-
-            const fileName featureEdgeFile =
-                extractFromFileDict.lookup("featureEdgeFile");
-
-            const Switch geometricTestOnly =
-                extractFromFileDict.lookupOrDefault<Switch>
-                (
-                    "geometricTestOnly",
-                    "no"
-                );
-
-            edgeMesh eMesh(featureEdgeFile);
-
-            // Sometimes duplicate edges are present. Remove them.
-            eMesh.mergeEdges();
-
-            Info<< nl << "Reading existing feature edges from file "
-                << featureEdgeFile << nl
-                << "Selecting edges purely based on geometric tests: "
-                << geometricTestOnly.asText() << endl;
-
-            set.set
+        autoPtr<surfaceFeaturesExtraction::method> extractor =
+            surfaceFeaturesExtraction::method::New
             (
-                new surfaceFeatures
-                (
-                    surf,
-                    eMesh.points(),
-                    eMesh.edges(),
-                    1e-6,
-                    geometricTestOnly
-                )
+                surfaceDict
             );
-        }
-        else if (extractionMethod == "extractFromSurface")
-        {
-            const dictionary& extractFromSurfaceDict =
-                surfaceDict.subDict("extractFromSurfaceCoeffs");
 
-            includedAngle =
-                readScalar(extractFromSurfaceDict.lookup("includedAngle"));
-
-            const Switch geometricTestOnly =
-                extractFromSurfaceDict.lookupOrDefault<Switch>
-                (
-                    "geometricTestOnly",
-                    "no"
-                );
-
-            Info<< nl
-                << "Constructing feature set from included angle "
-                << includedAngle << nl
-                << "Selecting edges purely based on geometric tests: "
-                << geometricTestOnly.asText() << endl;
-
-            set.set
+        // We don't needs the intersectionMethod yet, but can use it
+        // for setting a reasonable loading option
+        const surfaceIntersection::intersectionType selfIntersect =
+            surfaceIntersection::selfIntersectionNames.lookupOrDefault
             (
-                new surfaceFeatures
-                (
-                    surf,
-                    includedAngle,
-                    0,
-                    0,
-                    geometricTestOnly
-                )
+                "intersectionMethod",
+                surfaceDict,
+                surfaceIntersection::NONE
             );
+
+        const Switch writeObj = surfaceDict.lookupOrDefault<Switch>
+        (
+            "writeObj",
+            Switch::OFF
+        );
+        const Switch writeVTK = surfaceDict.lookupOrDefault<Switch>
+        (
+            "writeVTK",
+            Switch::OFF
+        );
+
+        // The "surfaces" entry is normally optional, but make it mandatory
+        // if the dictionary name doesn't have an extension
+        // (ie, probably not a surface filename at all).
+        // If it is missing, this will fail nicely with an appropriate error
+        // message.
+        if (surfaceDict.found("surfaces") || !dictName.hasExt())
+        {
+            loader.select(wordReList(surfaceDict.lookup("surfaces")));
         }
         else
         {
-            FatalErrorInFunction
-                << "No initial feature set. Provide either one"
-                << " of extractFromFile (to read existing set)" << nl
-                << " or extractFromSurface (to construct new set from angle)"
-                << exit(FatalError);
+            loader.select(dictName);
         }
 
+        // DebugVar(loader.available());
+        // DebugVar(outputName);
+
+        if (loader.selected().empty())
+        {
+            FatalErrorInFunction
+                << "No surfaces specified/found for entry: "
+                << dictName << exit(FatalError);
+        }
+
+        Info<< "Surfaces     : ";
+        if (loader.selected().size() == 1)
+        {
+            Info<< loader.selected().first() << nl;
+        }
+        else
+        {
+            Info<< flatOutput(loader.selected()) << nl;
+        }
+        Info<< "Output       : " << outputName << nl;
+
+        // Loading option - default depends on context
+        triSurfaceLoader::loadingOption loadingOption =
+            triSurfaceLoader::loadingOptionNames.lookupOrDefault
+            (
+                "loadingOption",
+                surfaceDict,
+                (
+                    selfIntersect == surfaceIntersection::SELF_REGION
+                  ? triSurfaceLoader::FILE_REGION
+                  : triSurfaceLoader::OFFSET_REGION
+                )
+            );
+
+        Info<<"Load options : "
+            << triSurfaceLoader::loadingOptionNames[loadingOption] << nl
+            << "Write options:"
+            << " writeObj=" << writeObj
+            << " writeVTK=" << writeVTK << nl;
+
+        // Load a single file, or load and combine multiple selected files
+        autoPtr<triSurface> surfPtr = loader.load(loadingOption);
+        if (!surfPtr.valid() || surfPtr().empty())
+        {
+            FatalErrorInFunction
+                << "Problem loading surface(s) for entry: "
+                << dictName << exit(FatalError);
+        }
+
+        triSurface surf = surfPtr();
+
+        Info<< nl
+            << "Statistics:" << nl;
+        surf.writeStats(Info);
+
+        // Need a copy as plain faces if outputting VTK format
+        faceList faces;
+        if (writeVTK)
+        {
+            faces.setSize(surf.size());
+            forAll(surf, fi)
+            {
+                faces[fi] = surf[fi].triFaceFace();
+            }
+        }
+
+        //
+        // Extract features using the preferred extraction method
+        //
+        autoPtr<surfaceFeatures> features = extractor().features(surf);
 
         // Trim set
         // ~~~~~~~~
 
+        // Option: "trimFeatures" (dictionary)
         if (surfaceDict.isDict("trimFeatures"))
         {
-            dictionary trimDict = surfaceDict.subDict("trimFeatures");
+            const dictionary& trimDict = surfaceDict.subDict("trimFeatures");
 
-            scalar minLen =
-                trimDict.lookupOrAddDefault<scalar>("minLen", -GREAT);
-
-            label minElem = trimDict.lookupOrAddDefault<label>("minElem", 0);
+            const scalar minLen =
+                trimDict.lookupOrDefault<scalar>("minLen", 0);
+            const label minElem =
+                trimDict.lookupOrDefault<label>("minElem", 0);
 
             // Trim away small groups of features
-            if (minElem > 0 || minLen > 0)
+            if (minLen > 0 || minElem > 0)
             {
-                Info<< "Removing features of length < "
-                    << minLen << endl;
-                Info<< "Removing features with number of edges < "
-                    << minElem << endl;
+                if (minLen > 0)
+                {
+                    Info<< "Removing features of length < "
+                        << minLen << endl;
+                }
+                if (minElem > 0)
+                {
+                    Info<< "Removing features with number of edges < "
+                        << minElem << endl;
+                }
 
-                set().trimFeatures(minLen, minElem, includedAngle);
+                features().trimFeatures
+                (
+                    minLen, minElem, extractor().includedAngle()
+                );
             }
         }
 
-
         // Subset
         // ~~~~~~
 
         // Convert to marked edges, points
-        List<surfaceFeatures::edgeStatus> edgeStat(set().toStatus());
+        List<surfaceFeatures::edgeStatus> edgeStat(features().toStatus());
 
+        // Option: "subsetFeatures" (dictionary)
         if (surfaceDict.isDict("subsetFeatures"))
         {
             const dictionary& subsetDict = surfaceDict.subDict
@@ -1065,118 +418,115 @@ int main(int argc, char *argv[])
                 "subsetFeatures"
             );
 
+            // Suboption: "insideBox"
             if (subsetDict.found("insideBox"))
             {
                 treeBoundBox bb(subsetDict.lookup("insideBox")());
 
-                Info<< "Removing all edges outside bb " << bb << endl;
-                dumpBox(bb, "subsetBox.obj");
+                Info<< "Subset edges inside box " << bb << endl;
+                features().subsetBox(edgeStat, bb);
 
-                deleteBox(surf, bb, false, edgeStat);
+                {
+                    OBJstream os("subsetBox.obj");
+
+                    Info<< "Dumping bounding box " << bb
+                        << " as lines to obj file "
+                        << os.name() << endl;
+
+                    os.write(bb);
+                }
             }
+            // Suboption: "outsideBox"
             else if (subsetDict.found("outsideBox"))
             {
                 treeBoundBox bb(subsetDict.lookup("outsideBox")());
 
-                Info<< "Removing all edges inside bb " << bb << endl;
-                dumpBox(bb, "deleteBox.obj");
+                Info<< "Exclude edges outside box " << bb << endl;
+                features().excludeBox(edgeStat, bb);
 
-                deleteBox(surf, bb, true, edgeStat);
+                {
+                    OBJstream os("deleteBox.obj");
+
+                    Info<< "Dumping bounding box " << bb
+                        << " as lines to obj file "
+                        << os.name() << endl;
+
+                    os.write(bb);
+                }
             }
 
-            const Switch nonManifoldEdges =
-                subsetDict.lookupOrDefault<Switch>("nonManifoldEdges", "yes");
-
-            if (!nonManifoldEdges)
+            // Suboption: "nonManifoldEdges" (false: remove non-manifold edges)
+            if (!subsetDict.lookupOrDefault<bool>("nonManifoldEdges", true))
             {
                 Info<< "Removing all non-manifold edges"
                     << " (edges with > 2 connected faces) unless they"
                     << " cross multiple regions" << endl;
 
-                forAll(edgeStat, edgeI)
-                {
-                    const labelList& eFaces = surf.edgeFaces()[edgeI];
-
-                    if
-                    (
-                        eFaces.size() > 2
-                     && edgeStat[edgeI] == surfaceFeatures::REGION
-                     && (eFaces.size() % 2) == 0
-                    )
-                    {
-                        edgeStat[edgeI] = checkFlatRegionEdge
-                        (
-                            surf,
-                            1e-5,   //tol,
-                            includedAngle,
-                            edgeI
-                        );
-                    }
-                }
+                features().checkFlatRegionEdge
+                (
+                    edgeStat,
+                    1e-5,   // tol
+                    extractor().includedAngle()
+                );
             }
 
-            const Switch openEdges =
-                subsetDict.lookupOrDefault<Switch>("openEdges", "yes");
-
-            if (!openEdges)
+            // Suboption: "openEdges" (false: remove open edges)
+            if (!subsetDict.lookupOrDefault<bool>("openEdges", true))
             {
                 Info<< "Removing all open edges"
                     << " (edges with 1 connected face)" << endl;
 
-                forAll(edgeStat, edgeI)
-                {
-                    if (surf.edgeFaces()[edgeI].size() == 1)
-                    {
-                        edgeStat[edgeI] = surfaceFeatures::NONE;
-                    }
-                }
+                features().excludeOpen(edgeStat);
             }
 
+            // Suboption: "plane"
             if (subsetDict.found("plane"))
             {
                 plane cutPlane(subsetDict.lookup("plane")());
 
-                deleteEdges(surf, cutPlane, edgeStat);
+                Info<< "Only include feature edges that intersect the plane"
+                    << " with normal " << cutPlane.normal()
+                    << " and base point " << cutPlane.refPoint() << endl;
 
-                Info<< "Only edges that intersect the plane with normal "
-                    << cutPlane.normal()
-                    << " and base point " << cutPlane.refPoint()
-                    << " will be included as feature edges."<< endl;
+                features().subsetPlane(edgeStat, cutPlane);
             }
         }
 
-
         surfaceFeatures newSet(surf);
-        newSet.setFromStatus(edgeStat, includedAngle);
+        newSet.setFromStatus(edgeStat, extractor().includedAngle());
 
-        Info<< nl
-            << "Initial feature set:" << nl
-            << "    feature points : " << newSet.featurePoints().size() << nl
-            << "    feature edges  : " << newSet.featureEdges().size() << nl
-            << "    of which" << nl
-            << "        region edges   : " << newSet.nRegionEdges() << nl
-            << "        external edges : " << newSet.nExternalEdges() << nl
-            << "        internal edges : " << newSet.nInternalEdges() << nl
-            << endl;
-
-        //if (writeObj)
-        //{
-        //    newSet.writeObj("final");
-        //}
+        Info<< nl << "Initial ";
+        newSet.writeStats(Info);
 
         boolList surfBaffleRegions(surf.patches().size(), false);
-
-        wordList surfBaffleNames;
-        surfaceDict.readIfPresent("baffles", surfBaffleNames);
-
-        forAll(surf.patches(), pI)
+        if (surfaceDict.found("baffles"))
         {
-            const word& name = surf.patches()[pI].name();
+            wordReList baffleSelect(surfaceDict.lookup("baffles"));
 
-            if (findIndex(surfBaffleNames, name) != -1)
+            wordList patchNames(surf.patches().size());
+            forAll(surf.patches(), patchi)
             {
-                Info<< "Adding baffle region " << name << endl;
-                surfBaffleRegions[pI] = true;
+                patchNames[patchi] = surf.patches()[patchi].name();
+            }
+
+            labelList indices = findStrings(baffleSelect, patchNames);
+            forAll(indices, patchi)
+            {
+                surfBaffleRegions[patchi] = true;
+            }
+
+            if (indices.size())
+            {
+                Info<< "Adding " << indices.size() << " baffle regions: (";
+
+                forAll(surfBaffleRegions, patchi)
+                {
+                    if (surfBaffleRegions[patchi])
+                    {
+                        Info<< ' ' << patchNames[patchi];
+                    }
+                }
+                Info<< " )" << nl << nl;
             }
         }
 
@@ -1185,7 +535,7 @@ int main(int argc, char *argv[])
         (
             newSet,
             runTime,
-            sFeatFileName + ".extendedFeatureEdgeMesh",
+            outputName + ".extendedFeatureEdgeMesh",
             surfBaffleRegions
         );
 
@@ -1209,15 +559,50 @@ int main(int argc, char *argv[])
                 )
             );
             Info<< "Read " << addFeMesh.name() << nl;
-            writeStats(addFeMesh, Info);
+            edgeMeshTools::writeStats(Info, addFeMesh);
 
             feMesh.add(addFeMesh);
         }
 
+        if (selfIntersect != surfaceIntersection::NONE)
+        {
+            triSurfaceSearch query(surf);
+            surfaceIntersection intersect(query, surfaceDict);
 
-        Info<< nl
-            << "Final feature set:" << nl;
-        writeStats(feMesh, Info);
+            // Remove rounding noise. For consistency could use 1e-6,
+            // as per extractFromFile implementation
+
+            intersect.mergePoints(10*SMALL);
+
+            labelPair sizeInfo
+            (
+                intersect.cutPoints().size(),
+                intersect.cutEdges().size()
+            );
+
+            if (intersect.cutEdges().size())
+            {
+                extendedEdgeMesh addMesh
+                (
+                    intersect.cutPoints(),
+                    intersect.cutEdges()
+                );
+
+                feMesh.add(addMesh);
+
+                sizeInfo[0] = addMesh.points().size();
+                sizeInfo[1] = addMesh.edges().size();
+            }
+            Info<< nl
+                << "intersection: "
+                << surfaceIntersection::selfIntersectionNames[selfIntersect]
+                << nl
+                << "    points : " << sizeInfo[0] << nl
+                << "    edges  : " << sizeInfo[1] << nl;
+        }
+
+        Info<< nl << "Final ";
+        edgeMeshTools::writeStats(Info, feMesh);
 
         Info<< nl << "Writing extendedFeatureEdgeMesh to "
             << feMesh.objectPath() << endl;
@@ -1226,498 +611,140 @@ int main(int argc, char *argv[])
 
         if (writeObj)
         {
-            feMesh.writeObj(feMesh.path()/surfFileName.lessExt().name());
+            feMesh.writeObj(feMesh.path()/outputName);
         }
 
         feMesh.write();
 
-        // Write a featureEdgeMesh for backwards compatibility
-        featureEdgeMesh bfeMesh
-        (
-            IOobject
-            (
-                surfFileName.lessExt().name() + ".eMesh",   // name
-                runTime.constant(),                         // instance
-                "triSurface",
-                runTime,                                    // registry
-                IOobject::NO_READ,
-                IOobject::AUTO_WRITE,
-                false
-            ),
-            feMesh.points(),
-            feMesh.edges()
-        );
-
-        Info<< nl << "Writing featureEdgeMesh to "
-            << bfeMesh.objectPath() << endl;
-
-        bfeMesh.regIOobject::write();
-
-    // Find close features
-
-    // // Dummy trim operation to mark features
-    // labelList featureEdgeIndexing = newSet.trimFeatures(-GREAT, 0);
-
-    // scalarField surfacePtFeatureIndex(surf.points().size(), -1);
-
-    // forAll(newSet.featureEdges(), eI)
-    // {
-    //     const edge& e = surf.edges()[newSet.featureEdges()[eI]];
-
-    //     surfacePtFeatureIndex[surf.meshPoints()[e.start()]] =
-    //     featureEdgeIndexing[newSet.featureEdges()[eI]];
-
-    //     surfacePtFeatureIndex[surf.meshPoints()[e.end()]] =
-    //     featureEdgeIndexing[newSet.featureEdges()[eI]];
-    // }
-
-    // if (writeVTK)
-    // {
-    //     vtkSurfaceWriter().write
-    //     (
-    //         runTime.constant()/"triSurface",    // outputDir
-    //         sFeatFileName,                      // surfaceName
-    //         surf.points(),
-    //         faces,
-    //         "surfacePtFeatureIndex",            // fieldName
-    //         surfacePtFeatureIndex,
-    //         true,                               // isNodeValues
-    //         true                                // verbose
-    //     );
-    // }
-
-    // Random rndGen(343267);
-
-    // treeBoundBox surfBB
-    // (
-    //     treeBoundBox(searchSurf.bounds()).extend(rndGen, 1e-4)
-    // );
-
-    // surfBB.min() -= Foam::point(ROOTVSMALL, ROOTVSMALL, ROOTVSMALL);
-    // surfBB.max() += Foam::point(ROOTVSMALL, ROOTVSMALL, ROOTVSMALL);
-
-    // indexedOctree<treeDataEdge> ftEdTree
-    // (
-    //     treeDataEdge
-    //     (
-    //         false,
-    //         surf.edges(),
-    //         surf.localPoints(),
-    //         newSet.featureEdges()
-    //     ),
-    //     surfBB,
-    //     8,      // maxLevel
-    //     10,     // leafsize
-    //     3.0     // duplicity
-    // );
-
-    // labelList nearPoints = ftEdTree.findBox
-    // (
-    //     treeBoundBox
-    //     (
-    //         sPt - featureSearchSpan*Foam::vector::one,
-    //         sPt + featureSearchSpan*Foam::vector::one
-    //     )
-    // );
-
-        if (closeness)
+        // Write a featureEdgeMesh (.eMesh) for backwards compatibility
+        // Used by snappyHexMesh (JUN-2017)
+        if (true)
         {
-            Info<< nl << "Extracting internal and external closeness of "
-                << "surface." << endl;
-
-
-            triSurfaceMesh searchSurf
+            featureEdgeMesh bfeMesh
             (
                 IOobject
                 (
-                    sFeatFileName + ".closeness",
-                    runTime.constant(),
+                    outputName + ".eMesh",      // name
+                    runTime.constant(),         // instance
                     "triSurface",
-                    runTime,
+                    runTime,                    // registry
                     IOobject::NO_READ,
-                    IOobject::NO_WRITE
+                    IOobject::AUTO_WRITE,
+                    false
                 ),
-                surf
+                feMesh.points(),
+                feMesh.edges()
             );
 
+            Info<< nl << "Writing featureEdgeMesh to "
+                << bfeMesh.objectPath() << endl;
 
-            // Internal and external closeness
+            bfeMesh.regIOobject::write();
+        }
 
-            // Prepare start and end points for intersection tests
-
-            const vectorField& normals = searchSurf.faceNormals();
-
-            scalar span = searchSurf.bounds().mag();
-
-            scalar externalAngleTolerance = 10;
-            scalar externalToleranceCosAngle =
-                Foam::cos
+        // Option: "closeness"
+        if (surfaceDict.lookupOrDefault<bool>("closeness", false))
+        {
+            Pair<tmp<scalarField>> tcloseness =
+                triSurfaceTools::writeCloseness
                 (
-                    degToRad(180 - externalAngleTolerance)
+                    runTime,
+                    outputName,
+                    surf,
+                    45,  // internalAngleTolerance
+                    10   // externalAngleTolerance
                 );
 
-            scalar internalAngleTolerance = 45;
-            scalar internalToleranceCosAngle =
-                Foam::cos
-                (
-                    degToRad(180 - internalAngleTolerance)
-                );
-
-            Info<< "externalToleranceCosAngle: " << externalToleranceCosAngle
-                << nl
-                << "internalToleranceCosAngle: " << internalToleranceCosAngle
-                << endl;
-
-            // Info<< "span " << span << endl;
-
-            pointField start(searchSurf.faceCentres() - span*normals);
-            pointField end(searchSurf.faceCentres() + span*normals);
-            const pointField& faceCentres = searchSurf.faceCentres();
-
-            List<List<pointIndexHit>> allHitInfo;
-
-            // Find all intersections (in order)
-            searchSurf.findLineAll(start, end, allHitInfo);
-
-            scalarField internalCloseness(start.size(), GREAT);
-            scalarField externalCloseness(start.size(), GREAT);
-
-            forAll(allHitInfo, fI)
-            {
-                const List<pointIndexHit>& hitInfo = allHitInfo[fI];
-
-                if (hitInfo.size() < 1)
-                {
-                    drawHitProblem(fI, surf, start, faceCentres, end, hitInfo);
-
-                    // FatalErrorInFunction
-                    //     << "findLineAll did not hit its own face."
-                    //     << exit(FatalError);
-                }
-                else if (hitInfo.size() == 1)
-                {
-                    if (!hitInfo[0].hit())
-                    {
-                        // FatalErrorInFunction
-                        //     << "findLineAll did not hit any face."
-                        //     << exit(FatalError);
-                    }
-                    else if (hitInfo[0].index() != fI)
-                    {
-                        drawHitProblem
-                        (
-                            fI,
-                            surf,
-                            start,
-                            faceCentres,
-                            end,
-                            hitInfo
-                        );
-
-                        // FatalErrorInFunction
-                        //     << "findLineAll did not hit its own face."
-                        //     << exit(FatalError);
-                    }
-                }
-                else
-                {
-                    label ownHitI = -1;
-
-                    forAll(hitInfo, hI)
-                    {
-                        // Find the hit on the triangle that launched the ray
-
-                        if (hitInfo[hI].index() == fI)
-                        {
-                            ownHitI = hI;
-
-                            break;
-                        }
-                    }
-
-                    if (ownHitI < 0)
-                    {
-                        drawHitProblem
-                        (
-                            fI,
-                            surf,
-                            start,
-                            faceCentres,
-                            end,
-                            hitInfo
-                        );
-
-                        // FatalErrorInFunction
-                        //     << "findLineAll did not hit its own face."
-                        //     << exit(FatalError);
-                    }
-                    else if (ownHitI == 0)
-                    {
-                        // There are no internal hits, the first hit is the
-                        // closest external hit
-
-                        if
-                        (
-                            (
-                                normals[fI]
-                              & normals[hitInfo[ownHitI + 1].index()]
-                            )
-                          < externalToleranceCosAngle
-                        )
-                        {
-                            externalCloseness[fI] =
-                                mag
-                                (
-                                    faceCentres[fI]
-                                  - hitInfo[ownHitI + 1].hitPoint()
-                                );
-                        }
-                    }
-                    else if (ownHitI == hitInfo.size() - 1)
-                    {
-                        // There are no external hits, the last but one hit is
-                        // the closest internal hit
-
-                        if
-                        (
-                            (
-                                normals[fI]
-                              & normals[hitInfo[ownHitI - 1].index()]
-                            )
-                          < internalToleranceCosAngle
-                        )
-                        {
-                            internalCloseness[fI] =
-                                mag
-                                (
-                                    faceCentres[fI]
-                                  - hitInfo[ownHitI - 1].hitPoint()
-                                );
-                        }
-                    }
-                    else
-                    {
-                        if
-                        (
-                            (
-                                normals[fI]
-                              & normals[hitInfo[ownHitI + 1].index()]
-                            )
-                          < externalToleranceCosAngle
-                        )
-                        {
-                            externalCloseness[fI] =
-                                mag
-                                (
-                                    faceCentres[fI]
-                                  - hitInfo[ownHitI + 1].hitPoint()
-                                );
-                        }
-
-                        if
-                        (
-                            (
-                                normals[fI]
-                              & normals[hitInfo[ownHitI - 1].index()]
-                            )
-                          < internalToleranceCosAngle
-                        )
-                        {
-                            internalCloseness[fI] =
-                                mag
-                                (
-                                    faceCentres[fI]
-                                  - hitInfo[ownHitI - 1].hitPoint()
-                                );
-                        }
-                    }
-                }
-            }
-
-            triSurfaceScalarField internalClosenessField
-            (
-                IOobject
-                (
-                    sFeatFileName + ".internalCloseness",
-                    runTime.constant(),
-                    "triSurface",
-                    runTime,
-                    IOobject::NO_READ,
-                    IOobject::NO_WRITE
-                ),
-                surf,
-                dimLength,
-                internalCloseness
-            );
-
-            internalClosenessField.write();
-
-            triSurfaceScalarField externalClosenessField
-            (
-                IOobject
-                (
-                    sFeatFileName + ".externalCloseness",
-                    runTime.constant(),
-                    "triSurface",
-                    runTime,
-                    IOobject::NO_READ,
-                    IOobject::NO_WRITE
-                ),
-                surf,
-                dimLength,
-                externalCloseness
-            );
-
-            externalClosenessField.write();
-
             if (writeVTK)
             {
                 vtkSurfaceWriter().write
                 (
-                    runTime.constantPath()/"triSurface",// outputDir
-                    sFeatFileName,                      // surfaceName
+                    vtkOutputDir,
+                    outputName,
                     meshedSurfRef
                     (
                         surf.points(),
                         faces
                     ),
                     "internalCloseness",                // fieldName
-                    internalCloseness,
+                    tcloseness[0](),
                     false,                              // isNodeValues
                     true                                // verbose
                 );
 
                 vtkSurfaceWriter().write
                 (
-                    runTime.constantPath()/"triSurface",// outputDir
-                    sFeatFileName,                      // surfaceName
+                    vtkOutputDir,
+                    outputName,
                     meshedSurfRef
                     (
                         surf.points(),
                         faces
                     ),
                     "externalCloseness",                // fieldName
-                    externalCloseness,
+                    tcloseness[1](),
                     false,                              // isNodeValues
                     true                                // verbose
                 );
             }
         }
 
-
-        if (curvature)
+        // Option: "curvature"
+        if (surfaceDict.lookupOrDefault<bool>("curvature", false))
         {
-            Info<< nl << "Extracting curvature of surface at the points."
-                << endl;
-
-            vectorField pointNormals = calcVertexNormals(surf);
-            triadField pointCoordSys = calcVertexCoordSys(surf, pointNormals);
-
-            triSurfacePointScalarField k = calcCurvature
-            (
-                sFeatFileName,
-                runTime,
-                surf,
-                pointNormals,
-                pointCoordSys
-            );
-
-            k.write();
+            tmp<scalarField> tcurvatureField =
+                triSurfaceTools::writeCurvature
+                (
+                    runTime,
+                    outputName,
+                    surf
+                );
 
             if (writeVTK)
             {
                 vtkSurfaceWriter().write
                 (
-                    runTime.constantPath()/"triSurface",// outputDir
-                    sFeatFileName,                      // surfaceName
+                    vtkOutputDir,
+                    outputName,
                     meshedSurfRef
                     (
                         surf.points(),
                         faces
                     ),
                     "curvature",                        // fieldName
-                    k,
+                    tcurvatureField(),
                     true,                               // isNodeValues
                     true                                // verbose
                 );
             }
         }
 
-
-        if (featureProximity)
+        // Option: "featureProximity"
+        if (surfaceDict.lookupOrDefault<bool>("featureProximity", false))
         {
-            Info<< nl << "Extracting proximity of close feature points and "
-                << "edges to the surface" << endl;
-
-            const scalar searchDistance =
-                readScalar(surfaceDict.lookup("maxFeatureProximity"));
-
-            scalarField featureProximity(surf.size(), searchDistance);
-
-            forAll(surf, fI)
-            {
-                const triPointRef& tri = surf[fI].tri(surf.points());
-                const point& triCentre = tri.circumCentre();
-
-                const scalar radiusSqr = min
+            tmp<scalarField> tproximity =
+                edgeMeshTools::writeFeatureProximity
                 (
-                    sqr(4*tri.circumRadius()),
-                    sqr(searchDistance)
-                );
-
-                List<pointIndexHit> hitList;
-
-                feMesh.allNearestFeatureEdges(triCentre, radiusSqr, hitList);
-
-                featureProximity[fI] =
-                    calcProximityOfFeatureEdges
-                    (
-                        feMesh,
-                        hitList,
-                        featureProximity[fI]
-                    );
-
-                feMesh.allNearestFeaturePoints(triCentre, radiusSqr, hitList);
-
-                featureProximity[fI] =
-                    calcProximityOfFeaturePoints
-                    (
-                        hitList,
-                        featureProximity[fI]
-                    );
-            }
-
-            triSurfaceScalarField featureProximityField
-            (
-                IOobject
-                (
-                    sFeatFileName + ".featureProximity",
-                    runTime.constant(),
-                    "triSurface",
                     runTime,
-                    IOobject::NO_READ,
-                    IOobject::NO_WRITE
-                ),
-                surf,
-                dimLength,
-                featureProximity
-            );
-
-            featureProximityField.write();
+                    outputName,
+                    feMesh,
+                    surf,
+                    readScalar(surfaceDict.lookup("maxFeatureProximity"))
+                );
 
             if (writeVTK)
             {
                 vtkSurfaceWriter().write
                 (
-                    runTime.constantPath()/"triSurface",// outputDir
-                    sFeatFileName,                      // surfaceName
+                    vtkOutputDir,
+                    outputName,
                     meshedSurfRef
                     (
                         surf.points(),
                         faces
                     ),
                     "featureProximity",                 // fieldName
-                    featureProximity,
+                    tproximity(),
                     false,                              // isNodeValues
                     true                                // verbose
                 );
diff --git a/applications/utilities/surface/surfaceFeatureExtract/surfaceFeatureExtractDict b/applications/utilities/surface/surfaceFeatureExtract/surfaceFeatureExtractDict
index d7565d5c32..176a0e1938 100644
--- a/applications/utilities/surface/surfaceFeatureExtract/surfaceFeatureExtractDict
+++ b/applications/utilities/surface/surfaceFeatureExtract/surfaceFeatureExtractDict
@@ -16,38 +16,60 @@ FoamFile
 
 surface1.stl
 {
-    // How to obtain raw features (extractFromFile || extractFromSurface)
+    // Extract raw features (none | extractFromFile | extractFromSurface)
     extractionMethod    extractFromSurface;
 
-    extractFromSurfaceCoeffs
-    {
-        // Mark edges whose adjacent surface normals are at an angle less
-        // than includedAngle as features
-        // - 0  : selects no edges
-        // - 180: selects all edges
-        includedAngle   120;
+    // Mark edges whose adjacent surface normals are at an angle less
+    // than includedAngle as features
+    // - 0  : selects no edges
+    // - 180: selects all edges
+    includedAngle       120;
 
-        // Do not mark region edges
-        geometricTestOnly       yes;
-    }
+    // Do not mark region edges
+    geometricTestOnly   yes;
 
-    // Write options
+    // Generate additional intersection features (none | self | region)
+    intersectionMethod  none;
 
-        // Write features to obj format for postprocessing
-        writeObj                yes;
+    // Tolerance for surface intersections
+    // tolerance           1e-3;
+
+  // Output options:
+
+    // Write features to obj format for postprocessing
+    writeObj            yes;
+}
+
+
+// Self intersection (single or multiple surfaces).
+// - Use 'surfaces' entry (a wordRe list) if it exists.
+// - If the dictionary name does not have an extension, 'surfaces' is mandatory.
+outputName1
+{
+    extractionMethod    none;
+
+    surfaces            (surface1.stl surface2.nas);
+
+    // Generate additional intersection features (none | self | region)
+    intersectionMethod  self;
+
+    // Tolerance for surface intersections
+    // tolerance           1e-3;
+
+  // Output options:
+
+    // Write features to OBJ format for postprocessing
+    writeObj            yes;
 }
 
 
 surface2.nas
 {
-    // How to obtain raw features (extractFromFile || extractFromSurface)
+    // Extract raw features (none | extractFromFile | extractFromSurface)
     extractionMethod    extractFromFile;
 
-    extractFromFileCoeffs
-    {
-        // Load from an existing feature edge file
-        featureEdgeFile "constant/triSurface/featureEdges.nas";
-    }
+    // Load from an existing feature edge file
+    featureEdgeFile     "constant/triSurface/featureEdges.nas";
 
     trimFeatures
     {
@@ -60,57 +82,57 @@ surface2.nas
 
     subsetFeatures
     {
-        // Use a plane to select feature edges
-        // (normal)(basePoint)
-        // Keep only edges that intersect the plane will be included
-        plane               (1 0 0)(0 0 0);
+        // Use a plane to select feature edges (normal)(basePoint)
+        // Only keep edges that intersect the plane
+        plane           (1 0 0)(0 0 0);
 
-        // Select feature edges using a box
-        // (minPt)(maxPt)
-        // Keep edges inside the box:
-        insideBox           (0 0 0)(1 1 1);
-        // Keep edges outside the box:
-        outsideBox          (0 0 0)(1 1 1);
+        // Select feature edges using a box // (minPt)(maxPt)
+        // Only keep edges inside the box:
+        insideBox       (0 0 0)(1 1 1);
+
+        // Only keep edges outside the box:
+        outsideBox      (0 0 0)(1 1 1);
 
         // Keep nonManifold edges (edges with >2 connected faces where
         // the faces form more than two different normal planes)
-        nonManifoldEdges    yes;
+        nonManifoldEdges yes;
 
         // Keep open edges (edges with 1 connected face)
-        openEdges           yes;
+        openEdges       yes;
     }
 
     addFeatures
     {
         // Add (without merging) another extendedFeatureEdgeMesh
-        name                axZ.extendedFeatureEdgeMesh;
-
-        // Optionally flip features (invert all normals, making
-        // convex<->concave etc)
-        //flip                false;
+        name            axZ.extendedFeatureEdgeMesh;
     }
 
-    // Output the curvature of the surface
-    curvature               no;
 
-    // Output the proximity of feature points and edges to each other
-    featureProximity        no;
+    // Generate additional intersection features (none | self | region)
+    intersectionMethod  none;
 
-    // The maximum search distance to use when looking for other feature
-    // points and edges
-    maxFeatureProximity     1;
+    // Tolerance for surface intersections
+    // tolerance           1e-3;
 
-    // Out put the closeness of surface elements to other surface elements.
-    closeness               no;
+  // Output options:
 
-    // Write options
+    // Output the closeness of surface elements to other surface elements.
+    closeness           no;
 
-        // Write features to obj format for postprocessing
-        writeObj                yes;
+    // Output surface curvature
+    curvature           no;
 
-        // Write surface proximity and curvature fields to vtk format
-        // for postprocessing
-        writeVTK                no;
+    // Output the proximity of feature points and edges to another
+    featureProximity    no;
+
+    // The maximum search distance when checking feature proximity
+    maxFeatureProximity 1;
+
+    // Write features to OBJ format for postprocessing
+    writeObj            no;
+
+    // Write closeness/curvature/proximity fields as VTK for postprocessing
+    writeVTK            no;
 }
 
 
diff --git a/applications/utilities/surface/surfaceSplitNonManifolds/surfaceSplitNonManifolds.C b/applications/utilities/surface/surfaceSplitNonManifolds/surfaceSplitNonManifolds.C
index 65dd086cd3..47a83a09f2 100644
--- a/applications/utilities/surface/surfaceSplitNonManifolds/surfaceSplitNonManifolds.C
+++ b/applications/utilities/surface/surfaceSplitNonManifolds/surfaceSplitNonManifolds.C
@@ -129,8 +129,7 @@ void dumpFaces
     const Map<label>& connectedFaces
 )
 {
-    Info<< "Dumping connectedFaces as Lightwave .obj file to " << fName
-        << "\nThis can be visualized with e.g. javaview (www.javaview.de)\n\n";
+    Info<< "Dumping connectedFaces as .obj file to " << fName << nl;
 
     OFstream os(fName);
 
diff --git a/etc/config.csh/CGAL b/etc/config.csh/CGAL
index aab320bcab..4f4a5f3c95 100644
--- a/etc/config.csh/CGAL
+++ b/etc/config.csh/CGAL
@@ -51,8 +51,8 @@
 #------------------------------------------------------------------------------
 # USER EDITABLE PART: Changes made here may be lost with the next upgrade
 
-set boost_version=boost_1_62_0
-set cgal_version=CGAL-4.9
+set boost_version=boost_1_64_0
+set cgal_version=CGAL-4.9.1
 
 setenv BOOST_ARCH_PATH $WM_THIRD_PARTY_DIR/platforms/$WM_ARCH$WM_COMPILER/$boost_version
 setenv CGAL_ARCH_PATH $WM_THIRD_PARTY_DIR/platforms/$WM_ARCH$WM_COMPILER/$cgal_version
diff --git a/etc/config.csh/compiler b/etc/config.csh/compiler
index 2f1f7f0480..bdf2013490 100644
--- a/etc/config.csh/compiler
+++ b/etc/config.csh/compiler
@@ -66,6 +66,9 @@ case ThirdParty:
     case Gcc63:
         set gcc_version=gcc-6.3.0
         breaksw
+    case Gcc71:
+        set gcc_version=gcc-7.1.0
+        breaksw
     case Clang:
         set clang_version=llvm-3.7.1
         breaksw
diff --git a/etc/config.sh/CGAL b/etc/config.sh/CGAL
index dc97d66a11..e3acd42cbe 100644
--- a/etc/config.sh/CGAL
+++ b/etc/config.sh/CGAL
@@ -50,8 +50,8 @@
 #------------------------------------------------------------------------------
 # USER EDITABLE PART: Changes made here may be lost with the next upgrade
 
-boost_version=boost_1_62_0
-cgal_version=CGAL-4.9
+boost_version=boost_1_64_0
+cgal_version=CGAL-4.9.1
 
 export BOOST_ARCH_PATH=$WM_THIRD_PARTY_DIR/platforms/$WM_ARCH$WM_COMPILER/$boost_version
 export CGAL_ARCH_PATH=$WM_THIRD_PARTY_DIR/platforms/$WM_ARCH$WM_COMPILER/$cgal_version
diff --git a/etc/config.sh/compiler b/etc/config.sh/compiler
index 2235619f77..2dfd7eaf1f 100644
--- a/etc/config.sh/compiler
+++ b/etc/config.sh/compiler
@@ -65,6 +65,9 @@ ThirdParty)
     Gcc63)
         gcc_version=gcc-6.3.0
         ;;
+    Gcc71)
+        gcc_version=gcc-7.1.0
+        ;;
     Clang)
         clang_version=llvm-3.7.1
         ;;
diff --git a/src/OSspecific/POSIX/POSIX.C b/src/OSspecific/POSIX/POSIX.C
index f4cad0fccb..8f6c26fbbe 100644
--- a/src/OSspecific/POSIX/POSIX.C
+++ b/src/OSspecific/POSIX/POSIX.C
@@ -943,7 +943,7 @@ bool Foam::mvBak(const fileName& src, const std::string& ext)
         }
     }
 
-    // fall-through: nothing to do
+    // fallthrough: nothing to do
     return false;
 }
 
diff --git a/src/OpenFOAM/containers/HashTables/HashPtrTable/HashPtrTableIO.C b/src/OpenFOAM/containers/HashTables/HashPtrTable/HashPtrTableIO.C
index 7a679ef149..55004189fe 100644
--- a/src/OpenFOAM/containers/HashTables/HashPtrTable/HashPtrTableIO.C
+++ b/src/OpenFOAM/containers/HashTables/HashPtrTable/HashPtrTableIO.C
@@ -54,7 +54,7 @@ void Foam::HashPtrTable<T, Key, Hash>::read(Istream& is, const INew& inewt)
 
         if (s)
         {
-            if (2*s > this->tableSize_)
+            if (2*s > this->capacity())
             {
                 this->resize(2*s);
             }
diff --git a/src/OpenFOAM/containers/HashTables/HashTable/HashTable.C b/src/OpenFOAM/containers/HashTables/HashTable/HashTable.C
index 9bf799d6b3..bc887b7d3b 100644
--- a/src/OpenFOAM/containers/HashTables/HashTable/HashTable.C
+++ b/src/OpenFOAM/containers/HashTables/HashTable/HashTable.C
@@ -29,7 +29,6 @@ License
 #include "HashTable.H"
 #include "List.H"
 #include "FixedList.H"
-#include "Tuple2.H"
 
 // * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
 
@@ -112,14 +111,14 @@ Foam::HashTable<T, Key, Hash>::HashTable
 template<class T, class Key, class Hash>
 Foam::HashTable<T, Key, Hash>::HashTable
 (
-    std::initializer_list<Tuple2<Key, T>> lst
+    std::initializer_list<std::pair<Key, T>> lst
 )
 :
     HashTable<T, Key, Hash>(2*lst.size())
 {
-    for (const Tuple2<Key, T>& pair : lst)
+    for (const auto& pair : lst)
     {
-        insert(pair.first(), pair.second());
+        insert(pair.first, pair.second);
     }
 }
 
@@ -889,7 +888,7 @@ void Foam::HashTable<T, Key, Hash>::operator=
 template<class T, class Key, class Hash>
 void Foam::HashTable<T, Key, Hash>::operator=
 (
-    std::initializer_list<Tuple2<Key, T>> lst
+    std::initializer_list<std::pair<Key, T>> lst
 )
 {
     // Could be zero-sized from a previous transfer()
@@ -904,7 +903,7 @@ void Foam::HashTable<T, Key, Hash>::operator=
 
     for (const auto& pair : lst)
     {
-        insert(pair.first(), pair.second());
+        insert(pair.first, pair.second);
     }
 }
 
diff --git a/src/OpenFOAM/containers/HashTables/HashTable/HashTable.H b/src/OpenFOAM/containers/HashTables/HashTable/HashTable.H
index 3f9a2df85f..cd50551d5d 100644
--- a/src/OpenFOAM/containers/HashTables/HashTable/HashTable.H
+++ b/src/OpenFOAM/containers/HashTables/HashTable/HashTable.H
@@ -57,11 +57,13 @@ SourceFiles
 #include "uLabel.H"
 #include "word.H"
 #include "Xfer.H"
+#include "Hash.H"
 #include "className.H"
 #include "nullObject.H"
 
 #include <initializer_list>
 #include <iterator>
+#include <utility>
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -73,7 +75,6 @@ namespace Foam
 template<class T> class List;
 template<class T> class UList;
 template<class T, unsigned Size> class FixedList;
-template<class T1, class T2> class Tuple2;
 template<class T, class Key, class Hash> class HashTable;
 
 template<class T, class Key, class Hash>
@@ -212,7 +213,7 @@ private:
 
     // Private data type for table entries
 
-        //- Structure to hold a hashed entry, with a SLList for collisions
+        //- Structure to hold a hashed entry, with a linked-list for collisions
         struct hashedEntry
         {
             //- The lookup key
@@ -224,7 +225,7 @@ private:
             //- Pointer to next hashedEntry in sub-list
             hashedEntry* next_;
 
-            //- Construct from key, next pointer and object
+            //- Construct from key, object, next pointer
             inline hashedEntry(const Key& key, const T& obj, hashedEntry* next);
 
         private:
@@ -296,7 +297,7 @@ public:
         HashTable(const Xfer<HashTable<T, Key, Hash>>& ht);
 
         //- Construct from an initializer list
-        HashTable(std::initializer_list<Tuple2<Key, T>> lst);
+        HashTable(std::initializer_list<std::pair<Key, T>> lst);
 
 
     //- Destructor
@@ -558,7 +559,7 @@ public:
         void operator=(const HashTable<T, Key, Hash>& rhs);
 
         //- Assignment from an initializer list
-        void operator=(std::initializer_list<Tuple2<Key, T>> lst);
+        void operator=(std::initializer_list<std::pair<Key, T>> lst);
 
         //- Equality. Hash tables are equal if the keys and values are equal.
         //  Independent of table storage size and table order.
diff --git a/src/OpenFOAM/containers/HashTables/Map/Map.H b/src/OpenFOAM/containers/HashTables/Map/Map.H
index 4ac6e90e60..56f59128dd 100644
--- a/src/OpenFOAM/containers/HashTables/Map/Map.H
+++ b/src/OpenFOAM/containers/HashTables/Map/Map.H
@@ -96,7 +96,7 @@ public:
         {}
 
         //- Construct from an initializer list
-        Map(std::initializer_list<Tuple2<label, T>> map)
+        Map(std::initializer_list<std::pair<label, T>> map)
         :
             parent_type(map)
         {}
diff --git a/src/OpenFOAM/containers/Lists/ListOps/ListOps.H b/src/OpenFOAM/containers/Lists/ListOps/ListOps.H
index 46f3784a16..d7c93bef02 100644
--- a/src/OpenFOAM/containers/Lists/ListOps/ListOps.H
+++ b/src/OpenFOAM/containers/Lists/ListOps/ListOps.H
@@ -57,25 +57,41 @@ static const List<Type>& emptyList()
 
 
 //- Renumber the values (not the indices) of a list.
-//  Negative ListType elements are left as is.
+//  Negative ListType elements are left untouched.
 template<class ListType>
 ListType renumber(const labelUList& oldToNew, const ListType& lst);
 
-//- Inplace renumber the values of a list.
-//  Negative ListType elements are left as is.
+//- Inplace renumber the values (not the indices) of a list.
+//  Negative ListType elements are left untouched.
 template<class ListType>
 void inplaceRenumber(const labelUList& oldToNew, ListType& lst);
 
 
-//- Reorder the elements (indices, not values) of a list.
-//  Negative ListType elements are left as is.
+//- Reorder the elements of a list.
+//  Locations with negative oldToNew values are left as is (copy-through).
+//  However, if pruning is activated, these negative oldToNew values are
+//  instead skipped over and the resulting list shrunk to the max index
+//  actually used.
 template<class ListType>
-ListType reorder(const labelUList& oldToNew, const ListType& lst);
+ListType reorder
+(
+    const labelUList& oldToNew,
+    const ListType& lst,
+    const bool prune = false
+);
 
 //- Inplace reorder the elements of a list.
-//  Negative ListType elements are left as is.
+//  Locations with negative oldToNew values are left as is (copy-through).
+//  However, if pruning is activated, these negative oldToNew values are
+//  instead skipped over and the resulting list shrunk to the max index
+//  actually used.
 template<class ListType>
-void inplaceReorder(const labelUList& oldToNew, ListType& lst);
+void inplaceReorder
+(
+    const labelUList& oldToNew,
+    ListType& lst,
+    const bool prune = false
+);
 
 
 // Variants to work with iterators and sparse tables.
@@ -156,12 +172,20 @@ void inplaceSubset(const BoolListType& select, ListType& lst);
 //- Copy a subset of the input list when predicate is true.
 //  Do not use FixedList for the input list, since it doesn't resize.
 template<class ListType, class UnaryPredicate>
-ListType subsetList(const ListType& input, UnaryPredicate pred);
+ListType subsetList
+(
+    const ListType& input,
+    const UnaryPredicate& pred
+);
 
 //- Inplace subset of the list when predicate is true.
 //  Do not use FixedList for the input list, since it doesn't resize.
 template<class ListType, class UnaryPredicate>
-void inplaceSubsetList(ListType& input, UnaryPredicate pred);
+void inplaceSubsetList
+(
+    ListType& input,
+    const UnaryPredicate& pred
+);
 
 
 //- Invert one-to-one map. Unmapped elements will be -1.
diff --git a/src/OpenFOAM/containers/Lists/ListOps/ListOpsTemplates.C b/src/OpenFOAM/containers/Lists/ListOps/ListOpsTemplates.C
index 48e8b73897..bf5af3080d 100644
--- a/src/OpenFOAM/containers/Lists/ListOps/ListOpsTemplates.C
+++ b/src/OpenFOAM/containers/Lists/ListOps/ListOpsTemplates.C
@@ -70,23 +70,42 @@ template<class ListType>
 ListType Foam::reorder
 (
     const labelUList& oldToNew,
-    const ListType& lst
+    const ListType& lst,
+    const bool prune
 )
 {
-    ListType newLst(lst.size());
-    newLst.setSize(lst.size()); // Consistent sizes (eg, DynamicList)
+    const label sz = lst.size();
 
-    forAll(lst, elemI)
+    ListType newLst(sz);
+    newLst.setSize(sz);     // Consistent sizing (eg, DynamicList)
+
+    label maxIdx = -1;      // For pruning: newSize = maxIdx+1
+    forAll(lst, i)
     {
-        if (oldToNew[elemI] >= 0)
+        const label newIdx = oldToNew[i];
+        if (newIdx >= 0)
         {
-            newLst[oldToNew[elemI]] = lst[elemI];
+            // Could additionally enforce (newIdx < lst.size())
+            // ... or just rely on FULLDEBUG from UList
+
+            newLst[newIdx] = lst[i];
+
+            if (maxIdx < newIdx)
+            {
+                maxIdx = newIdx;
+            }
         }
-        else
+        else if (!prune)
         {
-            newLst[elemI] = lst[elemI];
+            newLst[i] = lst[i];
         }
     }
+
+    if (prune)
+    {
+        newLst.setSize(maxIdx+1);
+    }
+
     return newLst;
 }
 
@@ -95,24 +114,42 @@ template<class ListType>
 void Foam::inplaceReorder
 (
     const labelUList& oldToNew,
-    ListType& lst
+    ListType& lst,
+    const bool prune
 )
 {
-    ListType newLst(lst.size());
-    newLst.setSize(lst.size()); // Consistent sizing (eg, DynamicList)
+    const label sz = lst.size();
 
-    forAll(lst, elemI)
+    ListType newLst(sz);
+    newLst.setSize(sz);     // Consistent sizing (eg, DynamicList)
+
+    label maxIdx = -1;      // For pruning: newSize = maxIdx+1
+    forAll(lst, i)
     {
-        if (oldToNew[elemI] >= 0)
+        const label newIdx = oldToNew[i];
+        if (newIdx >= 0)
         {
-            newLst[oldToNew[elemI]] = lst[elemI];
+            // Could additionally enforce (newIdx < lst.size())
+            // ... or just rely on FULLDEBUG from UList
+
+            newLst[newIdx] = lst[i];
+
+            if (maxIdx < newIdx)
+            {
+                maxIdx = newIdx;
+            }
         }
-        else
+        else if (!prune)
         {
-            newLst[elemI] = lst[elemI];
+            newLst[i] = lst[i];
         }
     }
 
+    if (prune)
+    {
+        newLst.setSize(maxIdx+1);
+    }
+
     lst.transfer(newLst);
 }
 
@@ -126,9 +163,13 @@ void Foam::inplaceMapValue
 {
     for (auto iter = lst.begin(); iter != lst.end(); ++iter)
     {
-        if (iter.object() >= 0)
+        const label oldIdx = iter.object();
+        if (oldIdx >= 0)
         {
-            iter.object() = oldToNew[iter.object()];
+            // Could additionally enforce (oldIdx < oldToNew.size())
+            // ... or just rely on FULLDEBUG from UList
+
+            iter.object() = oldToNew[oldIdx];
         }
     }
 }
@@ -145,9 +186,13 @@ void Foam::inplaceMapKey
 
     for (auto iter = lst.begin(); iter != lst.end(); ++iter)
     {
-        if (iter.key() >= 0)
+        const label oldIdx = iter.key();
+        if (oldIdx >= 0)
         {
-            newLst.insert(oldToNew[iter.key()], iter.object());
+            // Could additionally enforce (oldIdx < oldToNew.size())
+            // ... or just rely on FULLDEBUG from UList
+
+            newLst.insert(oldToNew[oldIdx], iter.object());
         }
     }
 
@@ -423,7 +468,7 @@ template<class ListType, class UnaryPredicate>
 ListType Foam::subsetList
 (
     const ListType& lst,
-    UnaryPredicate pred
+    const UnaryPredicate& pred
 )
 {
     ListType newLst(lst.size());
@@ -447,7 +492,7 @@ template<class ListType, class UnaryPredicate>
 void Foam::inplaceSubsetList
 (
     ListType& lst,
-    UnaryPredicate pred
+    const UnaryPredicate& pred
 )
 {
     label nElem = 0;
diff --git a/src/OpenFOAM/containers/Lists/PackedList/PackedBoolList.C b/src/OpenFOAM/containers/Lists/PackedList/PackedBoolList.C
index 791d53cc59..4b01a43dd6 100644
--- a/src/OpenFOAM/containers/Lists/PackedList/PackedBoolList.C
+++ b/src/OpenFOAM/containers/Lists/PackedList/PackedBoolList.C
@@ -286,7 +286,7 @@ Foam::Xfer<Foam::labelList> Foam::PackedBoolList::used() const
 
 // * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * * //
 
-void Foam::PackedBoolList::operator=(const Foam::UList<bool>& lst)
+void Foam::PackedBoolList::operator=(const UList<bool>& lst)
 {
     this->setSize(lst.size());
 
diff --git a/src/OpenFOAM/containers/Lists/PackedList/PackedBoolList.H b/src/OpenFOAM/containers/Lists/PackedList/PackedBoolList.H
index b2ca0037f8..f98545a9bd 100644
--- a/src/OpenFOAM/containers/Lists/PackedList/PackedBoolList.H
+++ b/src/OpenFOAM/containers/Lists/PackedList/PackedBoolList.H
@@ -94,7 +94,7 @@ public:
         inline PackedBoolList();
 
         //- Construct from Istream
-        PackedBoolList(Istream&);
+        PackedBoolList(Istream& is);
 
         //- Construct with given size, initializes list to 0
         explicit inline PackedBoolList(const label size);
@@ -103,19 +103,19 @@ public:
         inline PackedBoolList(const label size, const bool val);
 
         //- Copy constructor
-        inline PackedBoolList(const PackedBoolList&);
+        inline PackedBoolList(const PackedBoolList& lst);
 
         //- Copy constructor
-        explicit inline PackedBoolList(const PackedList<1>&);
+        explicit inline PackedBoolList(const PackedList<1>& lst);
 
         //- Construct by transferring the parameter contents
-        inline PackedBoolList(const Xfer<PackedBoolList>&);
+        inline PackedBoolList(const Xfer<PackedBoolList>& lst);
 
         //- Construct by transferring the parameter contents
-        inline PackedBoolList(const Xfer<PackedList<1>>&);
+        inline PackedBoolList(const Xfer<PackedList<1>>& lst);
 
         //- Construct from a list of bools
-        explicit inline PackedBoolList(const Foam::UList<bool>&);
+        explicit inline PackedBoolList(const UList<bool>& lst);
 
         //- Construct from a list of labels
         //  using the labels as indices to indicate which bits are set
@@ -131,132 +131,132 @@ public:
 
     // Member Functions
 
-        // Access
+      // Access
 
-            using PackedList<1>::set;
-            using PackedList<1>::unset;
+        using PackedList<1>::set;
+        using PackedList<1>::unset;
 
-            //- Set specified bits.
-            void set(const PackedList<1>&);
+        //- Set specified bits.
+        void set(const PackedList<1>& lst);
 
-            //- Set the listed indices. Return number of elements changed.
-            //  Does auto-vivify for non-existent entries.
-            label set(const labelUList& indices);
+        //- Set the listed indices. Return number of elements changed.
+        //  Does auto-vivify for non-existent entries.
+        label set(const labelUList& indices);
 
-            //- Set the listed indices. Return number of elements changed.
-            //  Does auto-vivify for non-existent entries.
-            label set(const UIndirectList<label>& indices);
+        //- Set the listed indices. Return number of elements changed.
+        //  Does auto-vivify for non-existent entries.
+        label set(const UIndirectList<label>& indices);
 
-            //- Unset specified bits.
-            void unset(const PackedList<1>&);
+        //- Unset specified bits.
+        void unset(const PackedList<1>& lst);
 
-            //- Unset the listed indices. Return number of elements changed.
-            //  Never auto-vivify entries.
-            label unset(const labelUList& indices);
+        //- Unset the listed indices. Return number of elements changed.
+        //  Never auto-vivify entries.
+        label unset(const labelUList& indices);
 
-            //- Unset the listed indices. Return number of elements changed.
-            //  Never auto-vivify entries.
-            label unset(const UIndirectList<label>& indices);
+        //- Unset the listed indices. Return number of elements changed.
+        //  Never auto-vivify entries.
+        label unset(const UIndirectList<label>& indices);
 
-            //- Subset with the specified list.
-            void subset(const PackedList<1>&);
+        //- Subset with the specified list.
+        void subset(const PackedList<1>& lst);
 
-            //- Subset with the listed indices.
-            //  Return number of elements subsetted.
-            label subset(const labelUList& indices);
+        //- Subset with the listed indices.
+        //  Return number of elements subsetted.
+        label subset(const labelUList& indices);
 
-            //- Subset with the listed indices.
-            //  Return number of elements subsetted.
-            label subset(const UIndirectList<label>& indices);
+        //- Subset with the listed indices.
+        //  Return number of elements subsetted.
+        label subset(const UIndirectList<label>& indices);
 
 
-            //- Return indices of the used (true) elements as a list of labels
-            Xfer<labelList> used() const;
+        //- Return indices of the used (true) elements as a list of labels
+        Xfer<labelList> used() const;
 
 
-        // Edit
+      // Edit
 
-            //- Transfer the contents of the argument list into this list
-            //  and annul the argument list.
-            inline void transfer(PackedBoolList&);
+        //- Transfer the contents of the argument list into this list
+        //  and annul the argument list.
+        inline void transfer(PackedBoolList& lst);
 
-            //- Transfer the contents of the argument list into this list
-            //  and annul the argument list.
-            inline void transfer(PackedList<1>&);
+        //- Transfer the contents of the argument list into this list
+        //  and annul the argument list.
+        inline void transfer(PackedList<1>& lst);
 
-            //- Transfer contents to the Xfer container
-            inline Xfer<PackedBoolList> xfer();
+        //- Transfer contents to the Xfer container
+        inline Xfer<PackedBoolList> xfer();
 
 
     // Member Operators
 
-            //- Assignment of all entries to the given value.
-            inline void operator=(const bool val);
+        //- Assignment of all entries to the given value.
+        inline void operator=(const bool val);
 
-            //- Assignment operator.
-            inline void operator=(const PackedBoolList&);
+        //- Assignment operator.
+        inline void operator=(const PackedBoolList& lst);
 
-            //- Assignment operator.
-            inline void operator=(const PackedList<1>&);
+        //- Assignment operator.
+        inline void operator=(const PackedList<1>& lst);
 
-            //- Assignment operator.
-            void operator=(const Foam::UList<bool>&);
+        //- Assignment operator.
+        void operator=(const UList<bool>& lst);
 
-            //- Assignment operator,
-            //  using the labels as indices to indicate which bits are set
-            inline void operator=(const labelUList& indices);
+        //- Assignment operator,
+        //  using the labels as indices to indicate which bits are set
+        inline void operator=(const labelUList& indices);
 
-            //- Assignment operator,
-            //  using the labels as indices to indicate which bits are set
-            inline void operator=(const UIndirectList<label>&);
+        //- Assignment operator,
+        //  using the labels as indices to indicate which bits are set
+        inline void operator=(const UIndirectList<label>& indices);
 
-            //- Complement operator
-            inline PackedBoolList operator~() const;
+        //- Complement operator
+        inline PackedBoolList operator~() const;
 
-            //- And operator (lists may be dissimilar sizes)
-            inline PackedBoolList& operator&=(const PackedList<1>&);
+        //- And operator (lists may be dissimilar sizes)
+        inline PackedBoolList& operator&=(const PackedList<1>& lst);
 
-            //- And operator (lists may be dissimilar sizes)
-            //  using the labels as indices to indicate which bits are set
-            inline PackedBoolList& operator&=(const labelUList& indices);
+        //- And operator (lists may be dissimilar sizes)
+        //  using the labels as indices to indicate which bits are set
+        inline PackedBoolList& operator&=(const labelUList& indices);
 
-            //- And operator (lists may be dissimilar sizes)
-            //  using the labels as indices to indicate which bits are set
-            inline PackedBoolList& operator&=(const UIndirectList<label>&);
+        //- And operator (lists may be dissimilar sizes)
+        //  using the labels as indices to indicate which bits are set
+        inline PackedBoolList& operator&=(const UIndirectList<label>& indices);
 
-            //- Xor operator (lists may be dissimilar sizes)
-            //  Retains unique entries
-            PackedBoolList& operator^=(const PackedList<1>&);
+        //- Xor operator (lists may be dissimilar sizes)
+        //  Retains unique entries
+        PackedBoolList& operator^=(const PackedList<1>& lst);
 
-            //- Or operator (lists may be dissimilar sizes)
-            inline PackedBoolList& operator|=(const PackedList<1>&);
+        //- Or operator (lists may be dissimilar sizes)
+        inline PackedBoolList& operator|=(const PackedList<1>& lst);
 
-            //- Or operator (lists may be dissimilar sizes),
-            //  using the labels as indices to indicate which bits are set
-            inline PackedBoolList& operator|=(const labelUList& indices);
+        //- Or operator (lists may be dissimilar sizes),
+        //  using the labels as indices to indicate which bits are set
+        inline PackedBoolList& operator|=(const labelUList& indices);
 
-            //- Or operator (lists may be dissimilar sizes),
-            //  using the labels as indices to indicate which bits are set
-            inline PackedBoolList& operator|=(const UIndirectList<label>&);
+        //- Or operator (lists may be dissimilar sizes),
+        //  using the labels as indices to indicate which bits are set
+        inline PackedBoolList& operator|=(const UIndirectList<label>& indices);
 
 
-            //- Add entries to this list, synonymous with the or operator
-            inline PackedBoolList& operator+=(const PackedList<1>&);
+        //- Add entries to this list, synonymous with the or operator
+        inline PackedBoolList& operator+=(const PackedList<1>& lst);
 
-            //- Add entries to this list, synonymous with the or operator
-            inline PackedBoolList& operator+=(const labelUList& indices);
+        //- Add entries to this list, synonymous with the or operator
+        inline PackedBoolList& operator+=(const labelUList& indices);
 
-            //- Add entries to this list, synonymous with the or operator
-            inline PackedBoolList& operator+=(const UIndirectList<label>&);
+        //- Add entries to this list, synonymous with the or operator
+        inline PackedBoolList& operator+=(const UIndirectList<label>& indices);
 
-            //- Remove entries from this list - unset the specified bits
-            inline PackedBoolList& operator-=(const PackedList<1>&);
+        //- Remove entries from this list - unset the specified bits
+        inline PackedBoolList& operator-=(const PackedList<1>& lst);
 
-            //- Remove entries from this list - unset the specified bits
-            inline PackedBoolList& operator-=(const labelUList& indices);
+        //- Remove entries from this list - unset the specified bits
+        inline PackedBoolList& operator-=(const labelUList& indices);
 
-            //- Remove entries from this list - unset the specified bits
-            inline PackedBoolList& operator-=(const UIndirectList<label>&);
+        //- Remove entries from this list - unset the specified bits
+        inline PackedBoolList& operator-=(const UIndirectList<label>& indices);
 };
 
 
diff --git a/src/OpenFOAM/containers/Lists/PackedList/PackedBoolListI.H b/src/OpenFOAM/containers/Lists/PackedList/PackedBoolListI.H
index d5561cfc28..a0702f9a30 100644
--- a/src/OpenFOAM/containers/Lists/PackedList/PackedBoolListI.H
+++ b/src/OpenFOAM/containers/Lists/PackedList/PackedBoolListI.H
@@ -73,7 +73,7 @@ inline Foam::PackedBoolList::PackedBoolList(const Xfer<PackedList<1>>& lst)
 {}
 
 
-inline Foam::PackedBoolList::PackedBoolList(const Foam::UList<bool>& lst)
+inline Foam::PackedBoolList::PackedBoolList(const UList<bool>& lst)
 :
     PackedList<1>()
 {
diff --git a/src/OpenFOAM/containers/Lists/PackedList/PackedList.H b/src/OpenFOAM/containers/Lists/PackedList/PackedList.H
index c07bb1eab1..18720fc2ae 100644
--- a/src/OpenFOAM/containers/Lists/PackedList/PackedList.H
+++ b/src/OpenFOAM/containers/Lists/PackedList/PackedList.H
@@ -118,9 +118,9 @@ class Ostream;
 template<unsigned nBits> class PackedList;
 
 template<unsigned nBits>
-Istream& operator>>(Istream&, PackedList<nBits>&);
+Istream& operator>>(Istream& is, PackedList<nBits>& lst);
 template<unsigned nBits>
-Ostream& operator<<(Ostream&, const PackedList<nBits>&);
+Ostream& operator<<(Ostream& os, const PackedList<nBits>& lst);
 
 
 /*---------------------------------------------------------------------------*\
@@ -160,11 +160,11 @@ protected:
         inline static label packedLength(const label);
 
         //- Read a list entry (allows for specialization)
-        inline static unsigned int readValue(Istream&);
+        inline static unsigned int readValue(Istream& is);
 
         //- Read an index/value pair and set accordingly.
         //  For bool specialization, read a single index value
-        inline void setPair(Istream&);
+        inline void setPair(Istream& is);
 
 
 private:
@@ -252,167 +252,167 @@ public:
 
     // Member Functions
 
-        // Access
+      // Access
 
-            //- The number of elements that can be stored before reallocating
-            inline label capacity() const;
+        //- The number of elements that can be stored before reallocating
+        inline label capacity() const;
 
-            //- Number of entries.
-            inline label size() const;
+        //- Number of entries.
+        inline label size() const;
 
-            //- Return true if the list is empty (ie, size() is zero).
-            inline bool empty() const;
+        //- Return true if the list is empty (ie, size() is zero).
+        inline bool empty() const;
 
-            //- Get value at index I.
-            //  Never auto-vivify entries.
-            inline unsigned int get(const label i) const;
+        //- Get value at index I.
+        //  Never auto-vivify entries.
+        inline unsigned int get(const label i) const;
 
-            //- Set value at index I. Return true if value changed.
-            //  Does auto-vivify for non-existent entries.
-            //  Default value set is the max_value.
-            inline bool set(const label i, const unsigned int val = ~0u);
+        //- Set value at index I. Return true if value changed.
+        //  Does auto-vivify for non-existent, non-zero entries.
+        //  Default value set is the max_value.
+        inline bool set(const label i, const unsigned int val = ~0u);
 
-            //- Unset the entry at index I. Return true if value changed.
-            //  Never auto-vivify entries.
-            inline bool unset(const label i);
+        //- Unset the entry at index I. Return true if value changed.
+        //  Never auto-vivify entries.
+        inline bool unset(const label i);
 
-            //- Return the underlying packed storage
-            //  Manipulate with utmost caution
-            inline List<unsigned int>& storage();
+        //- Return the underlying packed storage
+        //  Manipulate with utmost caution
+        inline List<unsigned int>& storage();
 
-            //- Return the underlying packed storage
-            inline const List<unsigned int>& storage() const;
+        //- Return the underlying packed storage
+        inline const List<unsigned int>& storage() const;
 
-            //- The list length when packed
-            inline label packedLength() const;
+        //- The list length when packed
+        inline label packedLength() const;
 
-            //- Return the binary size in number of characters
-            //  used in the underlying storage
-            inline std::streamsize byteSize() const;
+        //- Return the binary size in number of characters
+        //  used in the underlying storage
+        inline std::streamsize byteSize() const;
 
-            //- Count number of bits set, O(log(n))
-            //  Uses the Hamming weight (population count) method
-            //  http://en.wikipedia.org/wiki/Hamming_weight
-            unsigned int count() const;
+        //- Count number of bits set, O(log(n))
+        //  Uses the Hamming weight (population count) method
+        //  http://en.wikipedia.org/wiki/Hamming_weight
+        unsigned int count() const;
 
-            //- Return the values as a list of labels
-            Xfer<labelList> values() const;
+        //- Return the values as a list of labels
+        Xfer<labelList> values() const;
 
-            //- Print bit patterns, optionally output unused elements
-            //
-            // addressable bits:
-            //   on: '1', off: '-'
-            //
-            // non-addressable bits:
-            //   on: '!', off: '.'
-            //
-            Ostream& printBits(Ostream&, const bool fullOutput=false) const;
+        //- Print bit patterns, optionally output unused elements
+        //
+        // addressable bits:
+        //   on: '1', off: '-'
+        //
+        // non-addressable bits:
+        //   on: '!', off: '.'
+        //
+        Ostream& printBits(Ostream& os, const bool fullOutput=false) const;
 
-            //- Print information and bit patterns (with printBits)
-            Ostream& printInfo(Ostream&, const bool fullOutput=false) const;
+        //- Print information and bit patterns (with printBits)
+        Ostream& printInfo(Ostream& os, const bool fullOutput=false) const;
 
 
-        // Edit
+      // Edit
 
-            //- Trim any trailing zero elements
-            bool trim();
+        //- Trim any trailing zero elements
+        bool trim();
 
-            //- Invert the bits in the addressable region
-            void flip();
+        //- Invert the bits in the addressable region
+        void flip();
 
-            //- Clear all bits
-            inline void reset();
+        //- Clear all bits
+        inline void reset();
 
-            //- Alter the size of the underlying storage.
-            //  The addressed size will be truncated if needed to fit, but will
-            //  remain otherwise untouched.
-            inline void setCapacity(const label);
+        //- Alter the size of the underlying storage.
+        //  The addressed size will be truncated if needed to fit, but will
+        //  remain otherwise untouched.
+        inline void setCapacity(const label nElem);
 
-            //- Reset addressable list size, does not shrink the allocated size.
-            //  Optionally specify a value for new elements.
-            inline void resize(const label, const unsigned int val = 0u);
+        //- Reset addressable list size, does not shrink the allocated size.
+        //  Optionally specify a value for new elements.
+        inline void resize(const label nElem, const unsigned int val = 0u);
 
-            //- Alias for resize()
-            inline void setSize(const label, const unsigned int val = 0u);
+        //- Alias for resize()
+        inline void setSize(const label nElem, const unsigned int val = 0u);
 
-            //- Reserve allocation space for at least this size.
-            //  Never shrinks the allocated size.
-            //  The list size is adjusted as per DynamicList with
-            //  SizeInc=0, SizeMult=2, SizeDiv=1
-            inline void reserve(const label);
+        //- Reserve allocation space for at least this size.
+        //  Never shrinks the allocated size.
+        //  The list size is adjusted as per DynamicList with
+        //  SizeInc=0, SizeMult=2, SizeDiv=1
+        inline void reserve(const label nElem);
 
-            //- Clear the list, i.e. set addressable size to zero.
-            //  Does not adjust the underlying storage
-            inline void clear();
+        //- Clear the list, i.e. set addressable size to zero.
+        //  Does not adjust the underlying storage
+        inline void clear();
 
-            //- Clear the list and delete storage.
-            inline void clearStorage();
+        //- Clear the list and delete storage.
+        inline void clearStorage();
 
-            //- Shrink the allocated space to what is actually used.
-            inline void shrink();
+        //- Shrink the allocated space to what is actually used.
+        inline void shrink();
 
-            //- Transfer the contents of the argument list into this list
-            //  and annul the argument list.
-            inline void transfer(PackedList<nBits>&);
+        //- Transfer the contents of the argument list into this list
+        //  and annul the argument list.
+        inline void transfer(PackedList<nBits>& lst);
 
-            //- Transfer contents to the Xfer container
-            inline Xfer<PackedList<nBits>> xfer();
+        //- Transfer contents to the Xfer container
+        inline Xfer<PackedList<nBits>> xfer();
 
 
-        // IO
+      // IO
 
-            //- Clear list and read from stream
-            Istream& read(Istream& is);
+        //- Clear list and read from stream
+        Istream& read(Istream& is);
 
-            //- Write the List, with line-breaks in ASCII if the list length
-            //  exceeds shortListLen. Using '0' suppresses line-breaks entirely.
-            //  A special indexed output (ASCII only) is triggered by specifying
-            //  a negative value for shortListLen.
-            //
-            // The indexed output may be convenient in some situations.
-            // The general format is a group of index/value pairs:
-            //  \verbatim
-            //      { (index1 value1) (index2 value2) (index3 value3) }
-            // \endverbatim
-            // The bool specialization just uses the indices corresponding to
-            // non-zero entries instead of a index/value pair:
-            // \verbatim
-            //     { index1 index2 index3 }
-            // \endverbatim
-            Ostream& writeList(Ostream& os, const label shortListLen=0) const;
+        //- Write the List, with line-breaks in ASCII if the list length
+        //  exceeds shortListLen. Using '0' suppresses line-breaks entirely.
+        //  A special indexed output (ASCII only) is triggered by specifying
+        //  a negative value for shortListLen.
+        //
+        // The indexed output may be convenient in some situations.
+        // The general format is a group of index/value pairs:
+        //  \verbatim
+        //      { (index1 value1) (index2 value2) (index3 value3) }
+        // \endverbatim
+        // The bool specialization just uses the indices corresponding to
+        // non-zero entries instead of a index/value pair:
+        // \verbatim
+        //     { index1 index2 index3 }
+        // \endverbatim
+        Ostream& writeList(Ostream& os, const label shortListLen=0) const;
 
-            //- Write as a dictionary entry with keyword
-            void writeEntry(const word& keyword, Ostream& os) const;
+        //- Write as a dictionary entry with keyword
+        void writeEntry(const word& keyword, Ostream& os) const;
 
 
-    // Member operators
+      // Member operators
 
-            //- Append a value at the end of the list
-            inline PackedList<nBits>& append(const unsigned int val);
+        //- Append a value at the end of the list
+        inline PackedList<nBits>& append(const unsigned int val);
 
-            //- Remove and return the last element
-            inline unsigned int remove();
+        //- Remove and return the last element
+        inline unsigned int remove();
 
-            //- Get value at index I
-            //  Never auto-vivify entries.
-            inline unsigned int operator[](const label i) const;
+        //- Get value at index I
+        //  Never auto-vivify entries.
+        inline unsigned int operator[](const label i) const;
 
-            //- Set value at index I.
-            //  Returns iterator to perform the actual operation.
-            //  Does not auto-vivify entries, but will when assigned to.
-            inline iteratorBase operator[](const label i);
+        //- Set value at index I.
+        //  Returns iterator to perform the actual operation.
+        //  Does not auto-vivify entries, but will when assigned to.
+        inline iteratorBase operator[](const label i);
 
-            //- Assignment of all entries to the given value. Takes linear time.
-            inline void operator=(const unsigned int val);
+        //- Assignment of all entries to the given value. Takes linear time.
+        inline void operator=(const unsigned int val);
 
-            //- Assignment operator.
-            void operator=(const PackedList<nBits>& lst);
+        //- Assignment operator.
+        void operator=(const PackedList<nBits>& lst);
 
-            //- Assignment operator.
-            void operator=(const labelUList& lst);
+        //- Assignment operator.
+        void operator=(const labelUList& lst);
 
-            //- Assignment operator.
-            void operator=(const UIndirectList<label>& lst);
+        //- Assignment operator.
+        void operator=(const UIndirectList<label>& lst);
 
 
     // Iterators and helpers
@@ -442,7 +442,7 @@ public:
                 inline unsigned int get() const;
 
                 //- Set value, returning true if changed, no range-checking
-                inline bool set(unsigned int);
+                inline bool set(unsigned int val);
 
 
             // Constructors
@@ -451,7 +451,7 @@ public:
                 inline iteratorBase();
 
                 //- Construct from base list and position index
-                inline iteratorBase(const PackedList*, const label);
+                inline iteratorBase(const PackedList* lst, const label i);
 
 
         public:
@@ -463,17 +463,17 @@ public:
 
                 //- Write index/value for a non-zero entry
                 //  The bool specialization writes the index only
-                inline bool writeIfSet(Ostream&) const;
+                inline bool writeIfSet(Ostream& os) const;
 
             // Member Operators
 
                 //- Compare values (not positions)
-                inline bool operator==(const iteratorBase&) const;
-                inline bool operator!=(const iteratorBase&) const;
+                inline bool operator==(const iteratorBase& iter) const;
+                inline bool operator!=(const iteratorBase& iter) const;
 
                 //- Assign value, not position.
                 //  This allows packed[0] = packed[3] for assigning values
-                inline void operator=(const iteratorBase&);
+                inline void operator=(const iteratorBase& iter);
 
                 //- Assign value.
                 //  A non-existent entry will be auto-vivified.
@@ -484,7 +484,7 @@ public:
                 inline operator unsigned int () const;
 
             //- Print information and values
-            Ostream& printInfo(Ostream&) const;
+            Ostream& printInfo(Ostream& os) const;
         };
 
 
@@ -496,11 +496,11 @@ public:
 
             //- Disallow copy constructor from const_iterator
             //  This would violate const-ness!
-            iterator(const const_iterator&);
+            iterator(const const_iterator& iter);
 
             //- Disallow assignment from const_iterator
             //  This would violate const-ness!
-            void operator=(const const_iterator&);
+            void operator=(const const_iterator& iter);
 
 
         public:
@@ -513,21 +513,21 @@ public:
                 //- Construct from iterator base, eg iter(packedlist[i])
                 //  but also  "iterator iter = packedlist[i];"
                 //  An out-of-range iterator is assigned end()
-                inline iterator(const iteratorBase&);
+                inline iterator(const iteratorBase& iter);
 
                 //- Construct from base list and position index
-                inline iterator(const PackedList*, const label);
+                inline iterator(const PackedList* lst, const label i);
 
 
             // Member Operators
 
                 //- Compare positions (not values)
-                inline bool operator==(const iteratorBase&) const;
-                inline bool operator!=(const iteratorBase&) const;
+                inline bool operator==(const iteratorBase& iter) const;
+                inline bool operator!=(const iteratorBase& iter) const;
 
                 //- Assign from iteratorBase, eg iter = packedlist[i]
                 //  An out-of-range iterator is assigned end()
-                inline void operator=(const iteratorBase&);
+                inline void operator=(const iteratorBase& iter);
 
                 //- Return value
                 inline unsigned int operator*() const;
@@ -571,24 +571,24 @@ public:
                 //- Construct from iterator base, eg iter(packedlist[i])
                 //  but also  "const_iterator iter = packedlist[i];"
                 //  An out-of-range iterator is assigned cend()
-                inline const_iterator(const iteratorBase&);
+                inline const_iterator(const iteratorBase& iter);
 
                 //- Construct from base list and position index
-                inline const_iterator(const PackedList*, const label);
+                inline const_iterator(const PackedList* lst, const label i);
 
                 //- Construct from iterator
-                inline const_iterator(const iterator&);
+                inline const_iterator(const iterator& iter);
 
 
             // Member operators
 
                 //- Compare positions (not values)
-                inline bool operator==(const iteratorBase&) const;
-                inline bool operator!=(const iteratorBase&) const;
+                inline bool operator==(const iteratorBase& iter) const;
+                inline bool operator!=(const iteratorBase& iter) const;
 
                 //- Assign from iteratorBase or derived
                 //  eg, iter = packedlist[i] or even iter = list.begin()
-                inline void operator=(const iteratorBase&);
+                inline void operator=(const iteratorBase& iter);
 
                 //- Return referenced value directly
                 inline unsigned int operator*() const;
@@ -621,14 +621,14 @@ public:
 
         friend Istream& operator>> <nBits>
         (
-            Istream&,
-            PackedList<nBits>&
+            Istream& is,
+            PackedList<nBits>& lst
         );
 
         friend Ostream& operator<< <nBits>
         (
-            Ostream&,
-            const PackedList<nBits>&
+            Ostream& os,
+            const PackedList<nBits>& lst
         );
 };
 
diff --git a/src/OpenFOAM/containers/Lists/PackedList/PackedListI.H b/src/OpenFOAM/containers/Lists/PackedList/PackedListI.H
index 7849d5a792..ad136b903f 100644
--- a/src/OpenFOAM/containers/Lists/PackedList/PackedListI.H
+++ b/src/OpenFOAM/containers/Lists/PackedList/PackedListI.H
@@ -267,7 +267,7 @@ Foam::PackedList<nBits>::clone() const
 template<unsigned nBits>
 inline Foam::PackedList<nBits>::iteratorBase::iteratorBase()
 :
-    list_(0),
+    list_(nullptr),
     index_(0)
 {}
 
@@ -1002,6 +1002,12 @@ inline bool Foam::PackedList<nBits>::set
     }
     else if (i >= size_)
     {
+        if (!val)
+        {
+            // Same as unset out-of-bounds = noop
+            return false;
+        }
+
         // Lazy evaluation - increase size on assigment
         resize(i + 1);
     }
@@ -1013,7 +1019,7 @@ inline bool Foam::PackedList<nBits>::set
 template<unsigned nBits>
 inline bool Foam::PackedList<nBits>::unset(const label i)
 {
-    // lazy evaluation - ignore out-of-bounds
+    // Unset out-of-bounds = noop
     if (i < 0 || i >= size_)
     {
         return false;
diff --git a/src/OpenFOAM/global/argList/argList.C b/src/OpenFOAM/global/argList/argList.C
index 01b68a32de..72215bc0a0 100644
--- a/src/OpenFOAM/global/argList/argList.C
+++ b/src/OpenFOAM/global/argList/argList.C
@@ -43,6 +43,7 @@ License
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
 bool Foam::argList::bannerEnabled_ = true;
+bool Foam::argList::checkProcessorDirectories_ = true;
 Foam::SLList<Foam::string>    Foam::argList::validArgs;
 Foam::HashTable<Foam::string> Foam::argList::validOptions;
 Foam::HashTable<Foam::string> Foam::argList::validParOptions;
@@ -194,6 +195,12 @@ void Foam::argList::noParallel()
 }
 
 
+void Foam::argList::noCheckProcessorDirectories()
+{
+    checkProcessorDirectories_ = false;
+}
+
+
 void Foam::argList::printOptionUsage
 (
     const label location,
@@ -759,7 +766,7 @@ void Foam::argList::parse
             // - normal running : nProcs = dictNProcs = nProcDirs
             // - decomposition to more  processors : nProcs = dictNProcs
             // - decomposition to fewer processors : nProcs = nProcDirs
-            if (dictNProcs > Pstream::nProcs())
+            if (checkProcessorDirectories_ && dictNProcs > Pstream::nProcs())
             {
                 FatalError
                     << source
@@ -814,7 +821,11 @@ void Foam::argList::parse
             {
                 // Possibly going to fewer processors.
                 // Check if all procDirs are there.
-                if (dictNProcs < Pstream::nProcs())
+                if
+                (
+                    checkProcessorDirectories_
+                 && dictNProcs < Pstream::nProcs()
+                )
                 {
                     label nProcDirs = 0;
                     while
@@ -1337,15 +1348,30 @@ bool Foam::argList::checkRootCase() const
         return false;
     }
 
-    if (Pstream::master() && !isDir(path()))
+    if (Pstream::parRun())
     {
-        // Allow slaves on non-existing processor directories, created later
-        FatalError
-            << executable_
-            << ": cannot open case directory " << path()
-            << endl;
+        if (Pstream::master() && (checkProcessorDirectories_ && !isDir(path())))
+        {
+            // Allow slaves on non-existing processor directories created later
+            FatalError
+                << executable_
+                << ": cannot open case directory " << path()
+                << endl;
 
-        return false;
+            return false;
+        }
+    }
+    else
+    {
+        if (!isDir(path()))
+        {
+            FatalError
+                << executable_
+                << ": cannot open case directory " << path()
+                << endl;
+
+            return false;
+        }
     }
 
     return true;
diff --git a/src/OpenFOAM/global/argList/argList.H b/src/OpenFOAM/global/argList/argList.H
index 09c6777261..569125c7da 100644
--- a/src/OpenFOAM/global/argList/argList.H
+++ b/src/OpenFOAM/global/argList/argList.H
@@ -119,6 +119,9 @@ class argList
         //- Track enabled/disabled banner state
         static bool bannerEnabled_;
 
+        //- Track enabled/disabled checking of processor directories state
+        static bool checkProcessorDirectories_;
+
         //- Switch on/off parallel mode. Has to be first to be constructed
         //  so destructor is done last.
         ParRunControl parRunControl_;
@@ -387,6 +390,9 @@ public:
             //- Remove the parallel options
             static void noParallel();
 
+            //- Remove checking of processor directories
+            static void noCheckProcessorDirectories();
+
             //- Return true if the post-processing option is specified
             static bool postProcess(int argc, char *argv[]);
 
diff --git a/src/OpenFOAM/global/constants/mathematical/mathematicalConstants.H b/src/OpenFOAM/global/constants/mathematical/mathematicalConstants.H
index fa4850fb5a..c7faae1bd2 100644
--- a/src/OpenFOAM/global/constants/mathematical/mathematicalConstants.H
+++ b/src/OpenFOAM/global/constants/mathematical/mathematicalConstants.H
@@ -47,13 +47,13 @@ namespace mathematical
 
     static const char* const group = "mathematical";
 
-    const scalar e(M_E);
-    const scalar pi(M_PI);
-    const scalar twoPi(2*pi);
-    const scalar piByTwo(0.5*pi);
+    constexpr scalar e(M_E);
+    constexpr scalar pi(M_PI);
+    constexpr scalar twoPi(2*M_PI);
+    constexpr scalar piByTwo(0.5*M_PI);
 
     //- Euler's constant
-    const scalar Eu(0.57721566490153286060651209);
+    constexpr scalar Eu(0.57721566490153286060651209);
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
diff --git a/src/OpenFOAM/global/profiling/profiling.H b/src/OpenFOAM/global/profiling/profiling.H
index 03a014f48b..26337bcc4e 100644
--- a/src/OpenFOAM/global/profiling/profiling.H
+++ b/src/OpenFOAM/global/profiling/profiling.H
@@ -54,6 +54,7 @@ SourceFiles
 
 #include "profilingTrigger.H"
 #include "HashPtrTable.H"
+#include "Tuple2.H"
 #include "LIFOStack.H"
 #include "Map.H"
 #include "Time.H"
diff --git a/src/OpenFOAM/global/unitConversion/unitConversion.H b/src/OpenFOAM/global/unitConversion/unitConversion.H
index 6582d07ffe..499ecd6aab 100644
--- a/src/OpenFOAM/global/unitConversion/unitConversion.H
+++ b/src/OpenFOAM/global/unitConversion/unitConversion.H
@@ -42,29 +42,43 @@ namespace Foam
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 //- Conversion from degrees to radians
-inline scalar degToRad(const scalar deg)
+inline constexpr scalar degToRad(const scalar deg) noexcept
 {
-    return (deg*constant::mathematical::pi/180.0);
+    return (deg*M_PI/180.0);
 }
 
 //- Conversion from radians to degrees
-inline scalar radToDeg(const scalar rad)
+inline constexpr scalar radToDeg(const scalar rad) noexcept
 {
-    return (rad*180.0/constant::mathematical::pi);
+    return (rad*180.0/M_PI);
 }
 
 //- Conversion from atm to Pa
-inline scalar atmToPa(const scalar atm)
+inline constexpr scalar atmToPa(const scalar atm) noexcept
 {
     return (atm*101325.0);
 }
 
 //- Conversion from atm to Pa
-inline scalar paToAtm(const scalar pa)
+inline constexpr scalar paToAtm(const scalar pa) noexcept
 {
     return (pa/101325.0);
 }
 
+
+//- User literal for degrees to radians conversion (integers)
+inline constexpr scalar operator "" _deg(unsigned long long int deg) noexcept
+{
+    return (deg*M_PI/180.0);
+}
+
+//- User literal for degrees to radians conversion (floats)
+inline constexpr scalar operator "" _deg(long double deg) noexcept
+{
+    return (deg*M_PI/180.0);
+}
+
+
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 } // End namespace Foam
diff --git a/src/OpenFOAM/interpolations/interpolation2DTable/interpolation2DTable.C b/src/OpenFOAM/interpolations/interpolation2DTable/interpolation2DTable.C
index 73ca0d9ec4..01c0aaa959 100644
--- a/src/OpenFOAM/interpolations/interpolation2DTable/interpolation2DTable.C
+++ b/src/OpenFOAM/interpolations/interpolation2DTable/interpolation2DTable.C
@@ -123,10 +123,10 @@ Type Foam::interpolation2DTable<Type>::interpolateValue
     const scalar lookupValue
 ) const
 {
-    label n = data.size();
+    const label n = data.size();
 
-    scalar minLimit = data.first().first();
-    scalar maxLimit = data.last().first();
+    const scalar minLimit = data.first().first();
+    const scalar maxLimit = data.last().first();
 
     if (lookupValue < minLimit)
     {
@@ -147,7 +147,9 @@ Type Foam::interpolation2DTable<Type>::interpolateValue
                     << "bound (" << minLimit << ")" << nl
                     << "    Continuing with the first entry"
                     << endl;
-                // fall-through to 'CLAMP'
+                // Behaviour as per 'CLAMP'
+                return data.first().second();
+                break;
             }
             case interpolation2DTable::CLAMP:
             {
@@ -175,7 +177,9 @@ Type Foam::interpolation2DTable<Type>::interpolateValue
                     << "bound (" << maxLimit << ")" << nl
                     << "    Continuing with the last entry"
                     << endl;
-                // fall-through to 'CLAMP'
+                // Behaviour as per 'CLAMP'
+                return data.last().second();
+                break;
             }
             case interpolation2DTable::CLAMP:
             {
@@ -251,16 +255,19 @@ Foam::label Foam::interpolation2DTable<Type>::Xi
                 WarningInFunction
                     << "value (" << valueX << ") out of bounds"
                     << endl;
-                // fall-through to 'CLAMP'
+                // Behaviour as per 'CLAMP'
+                return limitI;
+                break;
             }
             case interpolation2DTable::CLAMP:
             {
                 return limitI;
+                break;
             }
             default:
             {
                 FatalErrorInFunction
-                    << "Un-handled enumeration " << boundsHandling_
+                    << "Unhandled enumeration " << boundsHandling_
                     << abort(FatalError);
             }
         }
@@ -299,7 +306,7 @@ Type Foam::interpolation2DTable<Type>::operator()
 ) const
 {
     // Considers all of the list in Y being equal
-    label nX = this->size();
+    const label nX = this->size();
 
     const table& t = *this;
 
@@ -320,8 +327,8 @@ Type Foam::interpolation2DTable<Type>::operator()
         // have 2-D data, interpolate
 
         // find low and high indices in the X range that bound valueX
-        label x0i = Xi(lessOp<scalar>(), valueX, false);
-        label x1i = Xi(greaterOp<scalar>(), valueX, true);
+        const label x0i = Xi(lessOp<scalar>(), valueX, false);
+        const label x1i = Xi(greaterOp<scalar>(), valueX, true);
 
         if (x0i == x1i)
         {
@@ -333,8 +340,8 @@ Type Foam::interpolation2DTable<Type>::operator()
             Type y1(interpolateValue(t[x1i].second(), valueY));
 
             // gradient in X
-            scalar x0 = t[x0i].first();
-            scalar x1 = t[x1i].first();
+            const scalar x0 = t[x0i].first();
+            const scalar x1 = t[x1i].first();
             Type mX = (y1 - y0)/(x1 - x0);
 
             // interpolate
@@ -420,7 +427,7 @@ Foam::interpolation2DTable<Type>::outOfBounds
 template<class Type>
 void Foam::interpolation2DTable<Type>::checkOrder() const
 {
-    label n = this->size();
+    const label n = this->size();
     const table& t = *this;
 
     scalar prevValue = t[0].first();
@@ -445,10 +452,8 @@ void Foam::interpolation2DTable<Type>::checkOrder() const
 template<class Type>
 void Foam::interpolation2DTable<Type>::write(Ostream& os) const
 {
-    os.writeKeyword("file")
-        << fileName_ << token::END_STATEMENT << nl;
-    os.writeKeyword("outOfBounds")
-        << boundsHandlingToWord(boundsHandling_) << token::END_STATEMENT << nl;
+    os.writeEntry("file", fileName_);
+    os.writeEntry("outOfBounds", boundsHandlingToWord(boundsHandling_));
 
     os  << *this;
 }
diff --git a/src/OpenFOAM/interpolations/interpolation2DTable/interpolation2DTable.H b/src/OpenFOAM/interpolations/interpolation2DTable/interpolation2DTable.H
index 9a3750385c..e38b0a979a 100644
--- a/src/OpenFOAM/interpolations/interpolation2DTable/interpolation2DTable.H
+++ b/src/OpenFOAM/interpolations/interpolation2DTable/interpolation2DTable.H
@@ -66,7 +66,7 @@ public:
             CLAMP           //!< Clamp value to the start/end value
         };
 
-        //- Cconvenience typedef
+        //- Convenience typedef
         typedef List<Tuple2<scalar, List<Tuple2<scalar, Type>>>> table;
 
 
@@ -156,7 +156,7 @@ public:
         const List<Tuple2<scalar, Type>>& operator[](const label) const;
 
         //- Return an interpolated value
-        Type operator()(const scalar, const scalar) const;
+        Type operator()(const scalar valueX, const scalar valueY) const;
 };
 
 
diff --git a/src/OpenFOAM/interpolations/interpolationTable/interpolationTable.C b/src/OpenFOAM/interpolations/interpolationTable/interpolationTable.C
index 6d71af1403..695e13dca4 100644
--- a/src/OpenFOAM/interpolations/interpolationTable/interpolationTable.C
+++ b/src/OpenFOAM/interpolations/interpolationTable/interpolationTable.C
@@ -205,8 +205,8 @@ Foam::interpolationTable<Type>::outOfBounds
 template<class Type>
 void Foam::interpolationTable<Type>::check() const
 {
-    label n = this->size();
-    scalar prevValue = List<Tuple2<scalar, Type>>::operator[](0).first();
+    const label n = this->size();
+    scalar prevValue = this->first().first();
 
     for (label i=1; i<n; ++i)
     {
@@ -229,10 +229,8 @@ void Foam::interpolationTable<Type>::check() const
 template<class Type>
 void Foam::interpolationTable<Type>::write(Ostream& os) const
 {
-    os.writeKeyword("file")
-        << fileName_ << token::END_STATEMENT << nl;
-    os.writeKeyword("outOfBounds")
-        << boundsHandlingToWord(boundsHandling_) << token::END_STATEMENT << nl;
+    os.writeEntry("file", fileName_);
+    os.writeEntry("outOfBounds", boundsHandlingToWord(boundsHandling_));
     if (reader_.valid())
     {
         reader_->write(os);
@@ -251,8 +249,8 @@ Type Foam::interpolationTable<Type>::rateOfChange(const scalar value) const
         return 0;
     }
 
-    scalar minLimit = List<Tuple2<scalar, Type>>::operator[](0).first();
-    scalar maxLimit = List<Tuple2<scalar, Type>>::operator[](n-1).first();
+    const scalar minLimit = this->first().first();
+    const scalar maxLimit = this->last().first();
     scalar lookupValue = value;
 
     if (lookupValue < minLimit)
@@ -272,7 +270,9 @@ Type Foam::interpolationTable<Type>::rateOfChange(const scalar value) const
                     << "value (" << lookupValue << ") underflow" << nl
                     << "    Zero rate of change."
                     << endl;
-                // fall-through to 'CLAMP'
+                // behaviour as per 'CLAMP'
+                return 0;
+                break;
             }
             case interpolationTable::CLAMP:
             {
@@ -305,7 +305,9 @@ Type Foam::interpolationTable<Type>::rateOfChange(const scalar value) const
                     << "value (" << lookupValue << ") overflow" << nl
                     << "    Zero rate of change."
                     << endl;
-                // fall-through to 'CLAMP'
+                // Behaviour as per 'CLAMP'
+                return 0;
+                break;
             }
             case interpolationTable::CLAMP:
             {
@@ -346,7 +348,7 @@ Type Foam::interpolationTable<Type>::rateOfChange(const scalar value) const
     }
     else if (hi == 0)
     {
-        // this treatment should should only occur under these conditions:
+        // this treatment should only occur under these conditions:
         //  -> the 'REPEAT' treatment
         //  -> (0 <= value <= minLimit)
         //  -> minLimit > 0
@@ -414,7 +416,9 @@ Foam::interpolationTable<Type>::operator[](const label i) const
                     << "index (" << ii << ") underflow" << nl
                     << "    Continuing with the first entry"
                     << endl;
-                // fall-through to 'CLAMP'
+                // Behaviour as per 'CLAMP'
+                ii = 0;
+                break;
             }
             case interpolationTable::CLAMP:
             {
@@ -448,7 +452,9 @@ Foam::interpolationTable<Type>::operator[](const label i) const
                     << "index (" << ii << ") overflow" << nl
                     << "    Continuing with the last entry"
                     << endl;
-                // fall-through to 'CLAMP'
+                // Behaviour as per 'CLAMP'
+                ii = n - 1;
+                break;
             }
             case interpolationTable::CLAMP:
             {
@@ -477,11 +483,11 @@ Type Foam::interpolationTable<Type>::operator()(const scalar value) const
 
     if (n <= 1)
     {
-        return List<Tuple2<scalar, Type>>::operator[](0).second();
+        return this->first().second();
     }
 
-    scalar minLimit = List<Tuple2<scalar, Type>>::operator[](0).first();
-    scalar maxLimit = List<Tuple2<scalar, Type>>::operator[](n-1).first();
+    const scalar minLimit = this->first().first();
+    const scalar maxLimit = this->last().first();
     scalar lookupValue = value;
 
     if (lookupValue < minLimit)
@@ -501,17 +507,19 @@ Type Foam::interpolationTable<Type>::operator()(const scalar value) const
                     << "value (" << lookupValue << ") underflow" << nl
                     << "    Continuing with the first entry"
                     << endl;
-                // fall-through to 'CLAMP'
+                // Behaviour as per 'CLAMP'
+                return this->first().second();
+                break;
             }
             case interpolationTable::CLAMP:
             {
-                return List<Tuple2<scalar, Type>>::operator[](0).second();
+                return this->first().second();
                 break;
             }
             case interpolationTable::REPEAT:
             {
                 // adjust lookupValue to >= minLimit
-                scalar span = maxLimit-minLimit;
+                const scalar span = maxLimit-minLimit;
                 lookupValue = fmod(lookupValue-minLimit, span) + minLimit;
                 break;
             }
@@ -534,17 +542,19 @@ Type Foam::interpolationTable<Type>::operator()(const scalar value) const
                     << "value (" << lookupValue << ") overflow" << nl
                     << "    Continuing with the last entry"
                     << endl;
-                // fall-through to 'CLAMP'
+                // Behaviour as per 'CLAMP'
+                return this->last().second();
+                break;
             }
             case interpolationTable::CLAMP:
             {
-                return List<Tuple2<scalar, Type>>::operator[](n-1).second();
+                return this->last().second();
                 break;
             }
             case interpolationTable::REPEAT:
             {
                 // adjust lookupValue <= maxLimit
-                scalar span = maxLimit-minLimit;
+                const scalar span = maxLimit-minLimit;
                 lookupValue = fmod(lookupValue-minLimit, span) + minLimit;
                 break;
             }
@@ -575,7 +585,7 @@ Type Foam::interpolationTable<Type>::operator()(const scalar value) const
     }
     else if (hi == 0)
     {
-        // this treatment should should only occur under these conditions:
+        // this treatment should only occur under these conditions:
         //  -> the 'REPEAT' treatment
         //  -> (0 <= value <= minLimit)
         //  -> minLimit > 0
diff --git a/src/OpenFOAM/meshes/meshTools/mergePoints.C b/src/OpenFOAM/meshes/meshTools/mergePoints.C
index 3fae798055..2b99235b72 100644
--- a/src/OpenFOAM/meshes/meshTools/mergePoints.C
+++ b/src/OpenFOAM/meshes/meshTools/mergePoints.C
@@ -3,7 +3,7 @@
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
     \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
-     \\/     M anipulation  |
+     \\/     M anipulation  | Copyright (C) 2017 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -29,16 +29,18 @@ License
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
-template<class Type>
+template<class PointList>
 Foam::label Foam::mergePoints
 (
-    const UList<Type>& points,
+    const PointList& points,
     const scalar mergeTol,
     const bool verbose,
     labelList& pointMap,
-    const Type& origin
+    typename PointList::const_reference origin
 )
 {
+    typedef typename PointList::value_type point_type;
+
     // Create a old to new point mapping array
     pointMap.setSize(points.size());
     pointMap = -1;
@@ -49,10 +51,10 @@ Foam::label Foam::mergePoints
     }
 
     // Explicitly convert to Field to support various list types
-    tmp<Field<Type>> tPoints(new Field<Type>(points));
+    tmp<Field<point_type>> tPoints(new Field<point_type>(points));
 
-    Type compareOrigin = origin;
-    if (origin == Type::max)
+    point_type compareOrigin = origin;
+    if (origin == point_type::max)
     {
         compareOrigin = sum(tPoints())/points.size();
     }
@@ -69,7 +71,7 @@ Foam::label Foam::mergePoints
     const scalar mergeTolSqr = Foam::sqr(scalar(mergeTol));
 
     // Sort points by magSqr
-    const Field<Type> d(tPoints - compareOrigin);
+    const Field<point_type> d(tPoints - compareOrigin);
 
     List<scalar> magSqrD(d.size());
     forAll(d, pointi)
@@ -77,15 +79,16 @@ Foam::label Foam::mergePoints
         magSqrD[pointi] = magSqr(d[pointi]);
     }
     labelList order;
-    sortedOrder(magSqrD, order);
+    Foam::sortedOrder(magSqrD, order);
 
 
     Field<scalar> sortedTol(points.size());
     forAll(order, sortI)
     {
-        label pointi = order[sortI];
+        const label pointi = order[sortI];
 
         // Convert to scalar precision
+        // NOTE: not yet using point_type template parameter
         const point pt
         (
             scalar(d[pointi].x()),
@@ -104,9 +107,11 @@ Foam::label Foam::mergePoints
     for (label sortI = 1; sortI < order.size(); sortI++)
     {
         // Get original point index
-        label pointi = order[sortI];
+        const label pointi = order[sortI];
         const scalar mag2 = magSqrD[order[sortI]];
+
         // Convert to scalar precision
+        // NOTE: not yet using point_type template parameter
         const point pt
         (
             scalar(points[pointi].x()),
@@ -126,7 +131,10 @@ Foam::label Foam::mergePoints
             prevSortI--
         )
         {
-            label prevPointi = order[prevSortI];
+            const label prevPointi = order[prevSortI];
+
+            // Convert to scalar precision
+            // NOTE: not yet using point_type template parameter
             const point prevPt
             (
                 scalar(points[prevPointi].x()),
@@ -169,18 +177,18 @@ Foam::label Foam::mergePoints
 }
 
 
-template<class Type>
+template<class PointList>
 bool Foam::mergePoints
 (
-    const UList<Type>& points,
+    const PointList& points,
     const scalar mergeTol,
     const bool verbose,
     labelList& pointMap,
-    List<Type>& newPoints,
-    const Type& origin
+    List<typename PointList::value_type>& newPoints,
+    typename PointList::const_reference origin
 )
 {
-    label nUnique = mergePoints
+    const label nUnique = mergePoints
     (
         points,
         mergeTol,
diff --git a/src/OpenFOAM/meshes/meshTools/mergePoints.H b/src/OpenFOAM/meshes/meshTools/mergePoints.H
index 37d41f3e7b..791075d04a 100644
--- a/src/OpenFOAM/meshes/meshTools/mergePoints.H
+++ b/src/OpenFOAM/meshes/meshTools/mergePoints.H
@@ -3,7 +3,7 @@
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
     \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
-     \\/     M anipulation  |
+     \\/     M anipulation  | Copyright (C) 2017 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -46,27 +46,28 @@ namespace Foam
 
 //- Sorts and merges points. All points closer than/equal mergeTol get merged.
 //  Returns the number of unique points and a map from old to new.
-template<class Type>
+template<class PointList>
 label mergePoints
 (
-    const UList<Type>& points,
+    const PointList& points,
     const scalar mergeTol,
     const bool verbose,
     labelList& pointMap,
-    const Type& origin = Type::zero
+    typename PointList::const_reference origin = PointList::value_type::zero
 );
 
+
 //- Sorts and merges points. Determines new points. Returns true if anything
 //  merged (though newPoints still sorted even if not merged).
-template<class Type>
+template<class PointList>
 bool mergePoints
 (
-    const UList<Type>& points,
+    const PointList& points,
     const scalar mergeTol,
     const bool verbose,
     labelList& pointMap,
-    List<Type>& newPoints,
-    const Type& origin = Type::zero
+    List<typename PointList::value_type>& newPoints,
+    typename PointList::const_reference origin = PointList::value_type::zero
 );
 
 } // End namespace Foam
diff --git a/src/OpenFOAM/primitives/enums/Enum.C b/src/OpenFOAM/primitives/enums/Enum.C
new file mode 100644
index 0000000000..8b4f2100f0
--- /dev/null
+++ b/src/OpenFOAM/primitives/enums/Enum.C
@@ -0,0 +1,238 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2017 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "Enum.H"
+#include "dictionary.H"
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+template<class EnumType>
+Foam::label Foam::Enum<EnumType>::getIndex(const word& enumName) const
+{
+    const label n = size();
+    for (label idx=0; idx < n; ++idx)
+    {
+        if (names_[idx] == enumName)
+        {
+            return idx;
+        }
+    }
+
+    return -1;
+}
+
+
+template<class EnumType>
+Foam::label Foam::Enum<EnumType>::getIndex(const EnumType e) const
+{
+    const int val = int(e);
+
+    const label n = size();
+    for (label idx=0; idx < n; ++idx)
+    {
+        if (values_[idx] == val)
+        {
+            return idx;
+        }
+    }
+
+    return -1;
+}
+
+
+template<class EnumType>
+EnumType Foam::Enum<EnumType>::getEnum(const word& enumName) const
+{
+    const label idx = getIndex(enumName);
+
+    if (idx < 0)
+    {
+        FatalErrorInFunction
+            << enumName << " is not in enumeration: "
+            << names_ << exit(FatalError);
+    }
+
+    return EnumType(values_[idx]);
+}
+
+
+template<class EnumType>
+const Foam::word& Foam::Enum<EnumType>::getName(const EnumType e) const
+{
+    const label idx = getIndex(e);
+
+    if (idx < 0)
+    {
+        return word::null;
+    }
+    else
+    {
+        return names_[idx];
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+template<class EnumType>
+Foam::Enum<EnumType>::Enum
+(
+    std::initializer_list<std::pair<EnumType, word>> lst
+)
+:
+    names_(lst.size()),
+    values_(lst.size())
+{
+    int idx = 0;
+    for (const auto& pair : lst)
+    {
+        names_[idx]  = pair.second;
+        values_[idx] = int(pair.first);
+
+        ++idx;
+    }
+}
+
+
+template<class EnumType>
+Foam::Enum<EnumType>::Enum
+(
+    const EnumType start,
+    std::initializer_list<word> lst
+)
+:
+    names_(lst.size()),
+    values_(lst.size())
+{
+    int val = int(start);
+
+    int idx = 0;
+    for (const auto& key : lst)
+    {
+        names_[idx]  = key;
+        values_[idx] = val;
+
+        ++val;
+        ++idx;
+    }
+}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+template<class EnumType>
+Foam::List<Foam::word> Foam::Enum<EnumType>::sortedToc() const
+{
+    wordList lst(names_);
+    Foam::sort(lst);
+
+    return lst;
+}
+
+
+template<class EnumType>
+EnumType Foam::Enum<EnumType>::read(Istream& is) const
+{
+    const word enumName(is);
+    const label idx = getIndex(enumName);
+
+    if (idx < 0)
+    {
+        FatalIOErrorInFunction(is)
+            << enumName << " is not in enumeration: "
+            << names_ << nl
+            << exit(FatalIOError);
+    }
+
+    return EnumType(values_[idx]);
+}
+
+
+template<class EnumType>
+void Foam::Enum<EnumType>::write(const EnumType e, Ostream& os) const
+{
+    const label idx = getIndex(e);
+    if (idx >= 0)
+    {
+        os << names_[idx];
+    }
+}
+
+
+template<class EnumType>
+EnumType Foam::Enum<EnumType>::lookup
+(
+    const word& key,
+    const dictionary& dict
+) const
+{
+    const word enumName(dict.lookup(key));
+    const label idx = getIndex(enumName);
+
+    if (idx < 0)
+    {
+        FatalIOErrorInFunction(dict)
+            << enumName << " is not in enumeration: "
+            << names_ << nl
+            << exit(FatalIOError);
+    }
+
+    return EnumType(values_[idx]);
+}
+
+
+template<class EnumType>
+EnumType Foam::Enum<EnumType>::lookupOrDefault
+(
+    const word& key,
+    const dictionary& dict,
+    const EnumType deflt
+) const
+{
+    if (dict.found(key))
+    {
+        return lookup(key, dict);
+    }
+    else
+    {
+        return deflt;
+    }
+}
+
+
+// * * * * * * * * * * * * * * * IOstream Operators  * * * * * * * * * * * * //
+
+template<class EnumType>
+Foam::Ostream& Foam::operator<<
+(
+    Ostream& os,
+    const Enum<EnumType>& wrapped
+)
+{
+    return wrapped.names().writeList(os, 10);
+}
+
+
+// ************************************************************************* //
diff --git a/src/OpenFOAM/primitives/enums/Enum.H b/src/OpenFOAM/primitives/enums/Enum.H
new file mode 100644
index 0000000000..dde620fb26
--- /dev/null
+++ b/src/OpenFOAM/primitives/enums/Enum.H
@@ -0,0 +1,220 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2017 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::Enum
+
+Description
+    A Enum is a wrapper around a list of names/values that represent
+    particular enumeration values.
+
+SourceFiles
+    Enum.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef Enum_H
+#define Enum_H
+
+#include "wordList.H"
+#include <initializer_list>
+#include <utility>
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+// Forward declarations
+class dictionary;
+template<class EnumType> class Enum;
+
+template<class EnumType>
+Ostream& operator<<(Ostream& os, const Enum<EnumType>& wrapped);
+
+/*---------------------------------------------------------------------------*\
+                            Class Enum Declaration
+\*---------------------------------------------------------------------------*/
+
+template<class EnumType>
+class Enum
+{
+    // Private Member Data
+
+        //- The names for the enum
+        List<word> names_;
+
+        //- The values for the enum
+        List<int> values_;
+
+
+    // Private Member Functions
+
+        //- The index for the given name. -1 if not found.
+        label getIndex(const word& enumName) const;
+
+        //- The index for the given enumeration. -1 if not found.
+        label getIndex(const EnumType e) const;
+
+        //- Lookup enumeration corresponding to the given name.
+        //  FatalError if not found.
+        EnumType getEnum(const word& enumName) const;
+
+        //- Lookup name corresponding to the given enumeration.
+        //  Return empty word if not found.
+        const word& getName(const EnumType e) const;
+
+
+        //- Disallow default bitwise copy construct
+        Enum(const Enum&) = delete;
+
+        //- Disallow default bitwise assignment
+        void operator=(const Enum&) = delete;
+
+
+public:
+
+    //- The type of enumeration wrapped by Enum
+    typedef EnumType value_type;
+
+
+    // Constructors
+
+        //- Construct from a values/names list.
+        //  Duplicate values are permitted (eg, for aliases).
+        //  Duplicate names are permitted, but won't make much sense.
+        explicit Enum(std::initializer_list<std::pair<EnumType, word>> lst);
+
+        //- Construct from a list of names with values incremented from the
+        //  specified start value.
+        Enum(const EnumType start, std::initializer_list<word> lst);
+
+
+    // Member Functions
+
+      // Access
+
+        //- The number of lookup names for the enumeration
+        inline label size() const;
+
+        //- The list of enum names, in construction order
+        inline const List<word>& names() const;
+
+        //- The list of enum names, in construction order
+        inline const List<word>& toc() const;
+
+        //- The sorted list of enum names
+        List<word> sortedToc() const;
+
+        //- The list of enum values, in construction order
+        inline const List<int>& values() const;
+
+
+      // Query
+
+        //- Test if there is an enumeration corresponding to the given name.
+        inline bool hasEnum(const word& enumName) const;
+
+        //- Test if there is a name corresponding to the given enumeration.
+        inline bool hasName(const EnumType e) const;
+
+
+      // Lookup
+
+        //- Lookup the key in the dictionary and return the corresponding
+        //  enumeration element based on its name.
+        //  Fatal if anything is incorrect.
+        EnumType lookup
+        (
+            const word& key,
+            const dictionary& dict
+        ) const;
+
+        //- Find the key in the dictionary and return the corresponding
+        //  enumeration element based on its name.
+        //  Return the default value if the key was not found in the dictionary.
+        //  Fatal if the enumerated name was incorrect.
+        EnumType lookupOrDefault
+        (
+            const word& key,
+            const dictionary& dict,
+            const EnumType deflt
+        ) const;
+
+
+      // IO
+
+        //- Read a word from Istream and return the corresponding enumeration
+        EnumType read(Istream& is) const;
+
+        //- Write the name representation of the enumeration to an Ostream
+        //  A noop if the enumeration wasn't found.
+        void write(const EnumType e, Ostream& os) const;
+
+        //- Write the names as a list to an Ostream
+        inline Ostream& writeList
+        (
+            Ostream& os,
+            const label shortListLen=0
+        ) const;
+
+
+    // Member Operators
+
+        //- Return the enumeration corresponding to the given name
+        //  Fatal if the name cannot be found.
+        inline const EnumType operator[](const word& name) const;
+
+        //- Return the first name corresponding to the given enumeration.
+        //  Returns an empty word on failure.
+        inline const word& operator[](const EnumType e) const;
+
+
+    // IOstream operators
+
+        //- Write names to Ostream, as per writeList() with shortListLen=10
+        friend Ostream& operator<< <EnumType>
+        (
+            Ostream& os,
+            const Enum<EnumType>& wrapped
+        );
+
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#include "EnumI.H"
+
+#ifdef NoRepository
+    #include "Enum.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/OpenFOAM/primitives/enums/EnumI.H b/src/OpenFOAM/primitives/enums/EnumI.H
new file mode 100644
index 0000000000..a991fd53d3
--- /dev/null
+++ b/src/OpenFOAM/primitives/enums/EnumI.H
@@ -0,0 +1,103 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2017 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+template<class EnumType>
+inline Foam::label Foam::Enum<EnumType>::size() const
+{
+    return names_.size();
+}
+
+
+template<class EnumType>
+inline const Foam::wordList& Foam::Enum<EnumType>::names() const
+{
+    return names_;
+}
+
+
+template<class EnumType>
+inline const Foam::wordList& Foam::Enum<EnumType>::toc() const
+{
+    return names_;
+}
+
+
+template<class EnumType>
+inline const Foam::List<int>& Foam::Enum<EnumType>::values() const
+{
+    return values_;
+}
+
+
+template<class EnumType>
+inline bool Foam::Enum<EnumType>::hasEnum(const word& enumName) const
+{
+    return getIndex(enumName) >= 0;
+}
+
+
+template<class EnumType>
+inline bool Foam::Enum<EnumType>::hasName(const EnumType e) const
+{
+    return getIndex(e) >= 0;
+}
+
+
+template<class EnumType>
+inline Foam::Ostream& Foam::Enum<EnumType>::writeList
+(
+    Ostream& os,
+    const label shortListLen
+) const
+{
+    return names_.writeList(os, shortListLen);
+}
+
+
+// * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
+
+template<class EnumType>
+inline const EnumType Foam::Enum<EnumType>::operator[]
+(
+    const word& name
+) const
+{
+    return getEnum(name);
+}
+
+
+template<class EnumType>
+inline const Foam::word& Foam::Enum<EnumType>::operator[]
+(
+    const EnumType e
+) const
+{
+    return getName(e);
+}
+
+
+// ************************************************************************* //
diff --git a/src/OpenFOAM/containers/NamedEnum/NamedEnum.C b/src/OpenFOAM/primitives/enums/NamedEnum.C
similarity index 58%
rename from src/OpenFOAM/containers/NamedEnum/NamedEnum.C
rename to src/OpenFOAM/primitives/enums/NamedEnum.C
index 0f5e05630f..7b5cc701de 100644
--- a/src/OpenFOAM/containers/NamedEnum/NamedEnum.C
+++ b/src/OpenFOAM/primitives/enums/NamedEnum.C
@@ -25,14 +25,48 @@ License
 
 #include "NamedEnum.H"
 #include "dictionary.H"
+#include "stdFoam.H"
 
-// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
-template<class Enum, int nEnum>
-template<class StringType>
-Foam::List<StringType> Foam::NamedEnum<Enum, nEnum>::getNamesList()
+template<class EnumType, int nEnum>
+Foam::NamedEnum<EnumType, nEnum>::NamedEnum()
+:
+    lookup_(2*nEnum)
 {
-    List<StringType> lst(nEnum);
+    for (int enumi=0; enumi < nEnum; ++enumi)
+    {
+        if (names[enumi] && names[enumi][0])
+        {
+            lookup_.insert(names[enumi], enumi);
+        }
+        else
+        {
+            // Bad name - generate error message
+            List<string> goodNames(enumi);
+
+            for (int i = 0; i < enumi; ++i)
+            {
+                goodNames[i] = names[i];
+            }
+
+            FatalErrorInFunction
+                << "Illegal enumeration name at position " << enumi << nl
+                << "after entries " << goodNames << nl
+                << "Possibly your NamedEnum<EnumType, nEnum>::names array"
+                << " is not of size " << nEnum << endl
+                << abort(FatalError);
+        }
+    }
+}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+template<class EnumType, int nEnum>
+Foam::wordList Foam::NamedEnum<EnumType, nEnum>::words() const
+{
+    List<word> lst(nEnum);
 
     label count = 0;
     for (int enumi=0; enumi < nEnum; ++enumi)
@@ -48,93 +82,74 @@ Foam::List<StringType> Foam::NamedEnum<Enum, nEnum>::getNamesList()
 }
 
 
-// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
-
-template<class Enum, int nEnum>
-Foam::NamedEnum<Enum, nEnum>::NamedEnum()
-:
-    table_type(2*nEnum)
+template<class EnumType, int nEnum>
+Foam::List<int> Foam::NamedEnum<EnumType, nEnum>::values() const
 {
+    List<int> lst(nEnum);
+
+    label count = 0;
     for (int enumi=0; enumi < nEnum; ++enumi)
     {
         if (names[enumi] && names[enumi][0])
         {
-            insert(names[enumi], enumi);
-        }
-        else
-        {
-            // Bad name - generate error message
-            stringList goodNames(enumi);
+            auto iter = lookup_.cfind(names[enumi]);
 
-            for (int i = 0; i < enumi; ++i)
+            if (iter.found())
             {
-                goodNames[i] = names[i];
+                lst[count++] = iter.object();
             }
-
-            FatalErrorInFunction
-                << "Illegal enumeration name at position " << enumi << nl
-                << "after entries " << goodNames << nl
-                << "Possibly your NamedEnum<Enum, nEnum>::names array"
-                << " is not of size " << nEnum << endl
-                << abort(FatalError);
         }
     }
+
+    lst.setSize(count);
+    return lst;
 }
 
 
-// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
-
-template<class Enum, int nEnum>
-Enum Foam::NamedEnum<Enum, nEnum>::read(Istream& is) const
+template<class EnumType, int nEnum>
+bool Foam::NamedEnum<EnumType, nEnum>::hasName(const EnumType e) const
 {
-    const word enumName(is);
-    table_type::const_iterator iter = find(enumName);
+    const int enumValue(e);
 
-    if (!iter.found())
+    forAllConstIters(lookup_, iter)
     {
-        FatalIOErrorInFunction(is)
-            << enumName << " is not in enumeration: "
-            << sortedToc() << exit(FatalIOError);
+        if (iter.object() == enumValue)
+        {
+            return true;
+        }
     }
-
-    return Enum(iter.object());
+    return false;
 }
 
 
-template<class Enum, int nEnum>
-void Foam::NamedEnum<Enum, nEnum>::write(const Enum e, Ostream& os) const
-{
-    os  << names[int(e)];
-}
-
-
-template<class Enum, int nEnum>
-Enum Foam::NamedEnum<Enum, nEnum>::lookup
+template<class EnumType, int nEnum>
+EnumType Foam::NamedEnum<EnumType, nEnum>::lookup
 (
     const word& key,
     const dictionary& dict
 ) const
 {
     const word enumName(dict.lookup(key));
-    table_type::const_iterator iter = find(enumName);
+    auto iter = lookup_.cfind(enumName);
 
     if (!iter.found())
     {
         FatalIOErrorInFunction(dict)
             << enumName << " is not in enumeration: "
-            << sortedToc() << exit(FatalIOError);
+            << lookup_.sortedToc() << nl
+            << exit(FatalIOError);
     }
 
-    return Enum(iter.object());
+    return EnumType(iter.object());
 }
 
 
-template<class Enum, int nEnum>
-Enum Foam::NamedEnum<Enum, nEnum>::lookupOrDefault
+template<class EnumType, int nEnum>
+EnumType Foam::NamedEnum<EnumType, nEnum>::lookupOrDefault
 (
     const word& key,
     const dictionary& dict,
-    const enum_type deflt
+    const EnumType deflt
 ) const
 {
     if (dict.found(key))
@@ -148,36 +163,49 @@ Enum Foam::NamedEnum<Enum, nEnum>::lookupOrDefault
 }
 
 
-template<class Enum, int nEnum>
-Foam::List<Enum> Foam::NamedEnum<Enum, nEnum>::enums()
+template<class EnumType, int nEnum>
+EnumType Foam::NamedEnum<EnumType, nEnum>::read(Istream& is) const
 {
-    List<Enum> lst(nEnum);
+    const word enumName(is);
+    auto iter = lookup_.cfind(enumName);
 
-    label count = 0;
-    for (int enumi = 0; enumi < nEnum; ++enumi)
+    if (!iter.found())
     {
-        if (names[enumi] && names[enumi][0])
-        {
-            lst[count++] = Enum(enumi);
-        }
+        FatalIOErrorInFunction(is)
+            << enumName << " is not in enumeration: "
+            << lookup_.sortedToc() << nl
+            << exit(FatalIOError);
     }
 
-    lst.setSize(count);
-    return lst;
+    return EnumType(iter.object());
 }
 
 
-template<class Enum, int nEnum>
-Foam::stringList Foam::NamedEnum<Enum, nEnum>::strings()
+template<class EnumType, int nEnum>
+void Foam::NamedEnum<EnumType, nEnum>::write
+(
+    const EnumType e,
+    Ostream& os
+) const
 {
-    return getNamesList<string>();
+    const int idx = int(e);
+    if (idx >= 0 && idx < nEnum)
+    {
+        os  << names[idx];
+    }
 }
 
 
-template<class Enum, int nEnum>
-Foam::wordList Foam::NamedEnum<Enum, nEnum>::words()
+// * * * * * * * * * * * * * * * IOstream Operators  * * * * * * * * * * * * //
+
+template<class EnumType, int nEnum>
+Foam::Ostream& Foam::operator<<
+(
+    Ostream& os,
+    const NamedEnum<EnumType, nEnum>& wrapped
+)
 {
-    return getNamesList<word>();
+    return wrapped.lookup_.writeKeys(os, 10);
 }
 
 
diff --git a/src/OpenFOAM/containers/NamedEnum/NamedEnum.H b/src/OpenFOAM/primitives/enums/NamedEnum.H
similarity index 64%
rename from src/OpenFOAM/containers/NamedEnum/NamedEnum.H
rename to src/OpenFOAM/primitives/enums/NamedEnum.H
index 0c1c0826fa..db41012cad 100644
--- a/src/OpenFOAM/containers/NamedEnum/NamedEnum.H
+++ b/src/OpenFOAM/primitives/enums/NamedEnum.H
@@ -25,9 +25,8 @@ Class
     Foam::NamedEnum
 
 Description
-    A NamedEnum is a wrapper around a static list of names that represent
-    a particular enumeration. Internally it uses a HashTable for quicker
-    lookups.
+    A NamedEnum is a wrapper around a list of names that represent
+    particular enumeration values.
 
 SourceFiles
     NamedEnum.C
@@ -38,7 +37,6 @@ SourceFiles
 #define NamedEnum_H
 
 #include "HashTable.H"
-#include "stringList.H"
 #include "wordList.H"
 #include <type_traits>
 
@@ -46,33 +44,32 @@ SourceFiles
 
 namespace Foam
 {
+// Forward declarations
 class dictionary;
+template<class EnumType, int nEnum> class NamedEnum;
+
+template<class EnumType, int nEnum>
+Ostream& operator<<(Ostream& os, const NamedEnum<EnumType, nEnum>& wrapped);
 
-// Forward declaration
-template<class Enum, int> class NamedEnum;
 
 /*---------------------------------------------------------------------------*\
                           Class NamedEnum Declaration
 \*---------------------------------------------------------------------------*/
 
-template<class Enum, int nEnum>
+template<class EnumType, int nEnum>
 class NamedEnum
-:
-    public HashTable<int>
 {
     //- The nEnum must be positive (non-zero)
     static_assert(nEnum > 0, "nEnum must be positive (non-zero)");
 
-    //- The type of HashTable used for the lookup.
-    typedef HashTable<int> table_type;
+    // Private Member Data
+
+        //- The values for the enum
+        HashTable<int> lookup_;
 
 
     // Private Member Functions
 
-        //- The names as a list of strings
-        template<class StringType>
-        static List<StringType> getNamesList();
-
         //- Disallow default bitwise copy construct
         NamedEnum(const NamedEnum&) = delete;
 
@@ -83,12 +80,12 @@ class NamedEnum
 public:
 
     //- The type of enumeration wrapped by NamedEnum
-    typedef Enum enum_type;
+    typedef EnumType value_type;
 
 
     // Static data members
 
-        //- The set of names corresponding to the enumeration Enum
+        //- The set of names corresponding to the enumeration EnumType
         static const char* names[nEnum];
 
 
@@ -100,17 +97,42 @@ public:
 
     // Member Functions
 
-        //- Read a word from Istream and return the corresponding
-        //  enumeration element
-        enum_type read(Istream& is) const;
+      // Access
 
-        //- Write the name representation of the enumeration to an Ostream
-        void write(const enum_type e, Ostream& os) const;
+        //- The number of lookup names for the enumeration
+        inline label size() const;
+
+        //- The list of enum names
+        inline wordList toc() const;
+
+        //- The sorted list of enum names
+        inline wordList sortedToc() const;
+
+        //- The list of enum names, in construction order
+        wordList words() const;
+
+        //- The list of enum values, in construction order
+        List<int> values() const;
+
+
+      // Query
+
+        //- Test if there is an enumeration corresponding to the given name.
+        inline bool found(const word& enumName) const;
+
+        //- Test if there is an enumeration corresponding to the given name.
+        inline bool hasEnum(const word& enumName) const;
+
+        //- Test if there is a name corresponding to the given enumeration.
+        bool hasName(const EnumType e) const;
+
+
+      // Lookup
 
         //- Lookup the key in the dictionary and return the corresponding
         // enumeration element based on its name.
         // Fatal if anything is incorrect.
-        enum_type lookup
+        EnumType lookup
         (
             const word& key,
             const dictionary& dict
@@ -120,42 +142,42 @@ public:
         //  enumeration element based on its name.
         //  Return the default value if the key was not found in the dictionary.
         //  Fatal if enumerated name was incorrect.
-        enum_type lookupOrDefault
+        EnumType lookupOrDefault
         (
             const word& key,
             const dictionary& dict,
-            const enum_type deflt
+            const EnumType deflt
         ) const;
 
-        //- List of enumerations
-        static List<enum_type> enums();
 
-        //- The set of names as a list of strings
-        static stringList strings();
+      // IO
 
-        //- The set of names as a list of words
-        static wordList words();
+        //- Read a word from Istream and return the corresponding enumeration
+        EnumType read(Istream& is) const;
+
+        //- Write the name representation of the enumeration to an Ostream
+        //  A noop if the enumeration wasn't found.
+        void write(const EnumType e, Ostream& os) const;
 
 
     // Member Operators
 
         //- Return the enumeration element corresponding to the given name
-        inline const enum_type operator[](const char* name) const
-        {
-            return enum_type(table_type::operator[](name));
-        }
-
-        //- Return the enumeration element corresponding to the given name
-        inline const enum_type operator[](const word& name) const
-        {
-            return enum_type(table_type::operator[](name));
-        }
+        inline const EnumType operator[](const word& name) const;
 
         //- Return the name of the given enumeration element
-        inline const char* operator[](const enum_type e) const
-        {
-            return names[int(e)];
-        }
+        inline const char* operator[](const EnumType e) const;
+
+
+    // IOstream operators
+
+        //- Write names to Ostream, as per writeKeys() with shortListLen=10
+        friend Ostream& operator<< <EnumType, nEnum>
+        (
+            Ostream& os,
+            const NamedEnum<EnumType, nEnum>& wrapped
+        );
+
 };
 
 
@@ -165,6 +187,8 @@ public:
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
+#include "NamedEnumI.H"
+
 #ifdef NoRepository
     #include "NamedEnum.C"
 #endif
diff --git a/src/OpenFOAM/primitives/enums/NamedEnumI.H b/src/OpenFOAM/primitives/enums/NamedEnumI.H
new file mode 100644
index 0000000000..f40a43185a
--- /dev/null
+++ b/src/OpenFOAM/primitives/enums/NamedEnumI.H
@@ -0,0 +1,91 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2017 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+template<class EnumType, int nEnum>
+inline Foam::label Foam::NamedEnum<EnumType, nEnum>::size() const
+{
+    return lookup_.size();
+}
+
+
+template<class EnumType, int nEnum>
+inline Foam::wordList Foam::NamedEnum<EnumType, nEnum>::toc() const
+{
+    return lookup_.toc();
+}
+
+
+template<class EnumType, int nEnum>
+inline Foam::wordList Foam::NamedEnum<EnumType, nEnum>::sortedToc() const
+{
+    return lookup_.sortedToc();
+}
+
+
+template<class EnumType, int nEnum>
+inline bool Foam::NamedEnum<EnumType, nEnum>::found
+(
+    const word& enumName
+) const
+{
+    return lookup_.found(enumName);
+}
+
+
+template<class EnumType, int nEnum>
+inline bool Foam::NamedEnum<EnumType, nEnum>::hasEnum
+(
+    const word& enumName
+) const
+{
+    return lookup_.found(enumName);
+}
+
+
+// * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
+
+template<class EnumType, int nEnum>
+inline const EnumType Foam::NamedEnum<EnumType, nEnum>::operator[]
+(
+    const word& name
+) const
+{
+    return EnumType(lookup_[name]);
+}
+
+
+template<class EnumType, int nEnum>
+inline const char* Foam::NamedEnum<EnumType, nEnum>::operator[]
+(
+    const EnumType e
+) const
+{
+    return names[int(e)];
+}
+
+
+// ************************************************************************* //
diff --git a/src/OpenFOAM/primitives/functions/Function1/Table/TableBase.C b/src/OpenFOAM/primitives/functions/Function1/Table/TableBase.C
index 95a5fce3e4..02d3b186ef 100644
--- a/src/OpenFOAM/primitives/functions/Function1/Table/TableBase.C
+++ b/src/OpenFOAM/primitives/functions/Function1/Table/TableBase.C
@@ -195,7 +195,7 @@ void Foam::Function1Types::TableBase<Type>::check() const
             << nl << exit(FatalError);
     }
 
-    label n = table_.size();
+    const label n = table_.size();
     scalar prevValue = table_[0].first();
 
     for (label i = 1; i < n; ++i)
@@ -221,7 +221,7 @@ bool Foam::Function1Types::TableBase<Type>::checkMinBounds
     scalar& xDash
 ) const
 {
-    if (x < table_[0].first())
+    if (x < table_.first().first())
     {
         switch (boundsHandling_)
         {
@@ -238,19 +238,28 @@ bool Foam::Function1Types::TableBase<Type>::checkMinBounds
                     << "value (" << x << ") underflow" << nl
                     << endl;
 
-                // fall-through to 'CLAMP'
+                // Behaviour as per 'CLAMP'
+                xDash = table_.first().first();
+                return true;
+                break;
             }
             case CLAMP:
             {
-                xDash = table_[0].first();
+                xDash = table_.first().first();
                 return true;
                 break;
             }
             case REPEAT:
             {
                 // adjust x to >= minX
-                scalar span = table_.last().first() - table_[0].first();
-                xDash = fmod(x - table_[0].first(), span) + table_[0].first();
+                const scalar span =
+                    table_.last().first() - table_.first().first();
+
+                xDash =
+                (
+                    fmod(x - table_.first().first(), span)
+                  + table_.first().first()
+                );
                 break;
             }
         }
@@ -288,7 +297,10 @@ bool Foam::Function1Types::TableBase<Type>::checkMaxBounds
                     << "value (" << x << ") overflow" << nl
                     << endl;
 
-                // fall-through to 'CLAMP'
+                // Behaviour as per 'CLAMP'
+                xDash = table_.last().first();
+                return true;
+                break;
             }
             case CLAMP:
             {
@@ -299,8 +311,14 @@ bool Foam::Function1Types::TableBase<Type>::checkMaxBounds
             case REPEAT:
             {
                 // adjust x to >= minX
-                scalar span = table_.last().first() - table_[0].first();
-                xDash = fmod(x - table_[0].first(), span) + table_[0].first();
+                const scalar span =
+                    table_.last().first() - table_.first().first();
+
+                xDash =
+                (
+                    fmod(x - table_.first().first(), span)
+                  + table_.first().first()
+                );
                 break;
             }
         }
@@ -335,7 +353,7 @@ Type Foam::Function1Types::TableBase<Type>::value(const scalar x) const
 
     if (checkMinBounds(x, xDash))
     {
-        return table_[0].second();
+        return table_.first().second();
     }
 
     if (checkMaxBounds(xDash, xDash))
@@ -411,13 +429,11 @@ void Foam::Function1Types::TableBase<Type>::writeEntries(Ostream& os) const
 {
     if (boundsHandling_ != CLAMP)
     {
-        os.writeKeyword("outOfBounds") << boundsHandlingToWord(boundsHandling_)
-            << token::END_STATEMENT << nl;
+        os.writeEntry("outOfBounds", boundsHandlingToWord(boundsHandling_));
     }
     if (interpolationScheme_ != "linear")
     {
-        os.writeKeyword("interpolationScheme") << interpolationScheme_
-            << token::END_STATEMENT << nl;
+        os.writeEntry("interpolationScheme", interpolationScheme_);
     }
 }
 
diff --git a/src/OpenFOAM/primitives/strings/stringOps/stringOps.C b/src/OpenFOAM/primitives/strings/stringOps/stringOps.C
index 6df273e138..dca9fe5e08 100644
--- a/src/OpenFOAM/primitives/strings/stringOps/stringOps.C
+++ b/src/OpenFOAM/primitives/strings/stringOps/stringOps.C
@@ -308,7 +308,7 @@ Foam::string Foam::stringOps::getVariable
             }
         }
 
-        if (value.empty())
+        if (!allowEmpty && value.empty())
         {
             FatalIOErrorInFunction
             (
@@ -317,7 +317,8 @@ Foam::string Foam::stringOps::getVariable
                 << name << exit(FatalIOError);
         }
     }
-    else
+
+    if (!allowEmpty && value.empty())
     {
         FatalIOErrorInFunction
         (
diff --git a/src/TurbulenceModels/compressible/turbulentFluidThermoModels/derivedFvPatchFields/temperatureCoupledBase/temperatureCoupledBase.C b/src/TurbulenceModels/compressible/turbulentFluidThermoModels/derivedFvPatchFields/temperatureCoupledBase/temperatureCoupledBase.C
index 8a7027a59c..50c15be701 100644
--- a/src/TurbulenceModels/compressible/turbulentFluidThermoModels/derivedFvPatchFields/temperatureCoupledBase/temperatureCoupledBase.C
+++ b/src/TurbulenceModels/compressible/turbulentFluidThermoModels/derivedFvPatchFields/temperatureCoupledBase/temperatureCoupledBase.C
@@ -111,7 +111,7 @@ Foam::tmp<Foam::scalarField> Foam::temperatureCoupledBase::kappa
         {
             typedef compressible::turbulenceModel turbulenceModel;
 
-            word turbName(turbulenceModel::propertiesName);
+            const word turbName(turbulenceModel::propertiesName);
 
             if
             (
@@ -205,8 +205,8 @@ Foam::tmp<Foam::scalarField> Foam::temperatureCoupledBase::kappa
                     << " on mesh " << mesh.name() << " patch " << patch_.name()
                     << nl
                     << "Please set 'kappaMethod' to one of "
-                    << KMethodTypeNames_.toc()
-                    << " and 'kappa' to the name of the volScalar"
+                    << flatOutput(KMethodTypeNames_.sortedToc()) << nl
+                    << "and 'kappa' to the name of the volScalar"
                     << " or volSymmTensor field (if kappaMethod=lookup)"
                     << exit(FatalError);
             }
@@ -219,8 +219,8 @@ Foam::tmp<Foam::scalarField> Foam::temperatureCoupledBase::kappa
             FatalErrorInFunction
                 << "Unimplemented method " << KMethodTypeNames_[method_] << nl
                 << "Please set 'kappaMethod' to one of "
-                << KMethodTypeNames_.toc()
-                << " and 'kappa' to the name of the volScalar"
+                << flatOutput(KMethodTypeNames_.sortedToc()) << nl
+                << "and 'kappa' to the name of the volScalar"
                 << " or volSymmTensor field (if kappaMethod=lookup)"
                 << exit(FatalError);
         }
diff --git a/src/conversion/ccm/Make/files b/src/conversion/ccm/Make/files
index 89ec20a1db..34495168b9 100644
--- a/src/conversion/ccm/Make/files
+++ b/src/conversion/ccm/Make/files
@@ -11,6 +11,4 @@ writer/ccmWriter.C
 writer/ccmWriterMesh.C
 writer/ccmWriterSolution.C
 
-/* misc/mergePoints1.C */
-
 LIB = $(FOAM_LIBBIN)/libccm
diff --git a/src/conversion/ccm/common/ccmBase.H b/src/conversion/ccm/common/ccmBase.H
index 5f789eadd0..203420d922 100644
--- a/src/conversion/ccm/common/ccmBase.H
+++ b/src/conversion/ccm/common/ccmBase.H
@@ -111,7 +111,7 @@ public:
 
     // Member Functions
 
-        // Access
+      // Access
 
         //- Explicity close the file and terminate ccmio access.
         //  Return false if it was already closed.
diff --git a/src/conversion/ccm/misc/ListOps1Templates.C b/src/conversion/ccm/misc/ListOps1Templates.C
deleted file mode 100644
index 14a9ac38c9..0000000000
--- a/src/conversion/ccm/misc/ListOps1Templates.C
+++ /dev/null
@@ -1,117 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
-     \\/     M anipulation  | Copyright (C) 2015-2016 OpenCFD Ltd.
--------------------------------------------------------------------------------
-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 "ListOps1.H"
-
-// * * * * * * * * * * * * * * * Global Functions  * * * * * * * * * * * * * //
-
-template<class ListType>
-ListType Foam::reorder
-(
-    const labelUList& oldToNew,
-    const ListType& lst,
-    const bool prune
-)
-{
-    const label sz = lst.size();
-
-    // Create copy
-    ListType newLst(sz);
-
-    // Ensure consistent addressable size (eg, DynamicList)
-    newLst.setSize(sz);
-
-
-    label maxIdx = 0;
-    forAll(lst, elemI)
-    {
-        const label newIdx = oldToNew[elemI];
-        if (newIdx >= 0) // could also require newIdx < sz
-        {
-            newLst[newIdx] = lst[elemI];
-            if (prune && maxIdx < newIdx)
-            {
-                maxIdx = newIdx;
-            }
-        }
-        else if (!prune)
-        {
-            newLst[elemI] = lst[elemI];
-        }
-    }
-
-    if (prune && maxIdx < sz)
-    {
-        newLst.setSize(maxIdx);
-    }
-
-    return newLst;
-}
-
-
-template<class ListType>
-void Foam::inplaceReorder
-(
-    const labelUList& oldToNew,
-    ListType& lst,
-    const bool prune
-)
-{
-    const label sz = lst.size();
-
-    // Create copy
-    ListType newLst(sz);
-
-    // Ensure consistent addressable size (eg, DynamicList)
-    newLst.setSize(sz);
-
-    label maxIdx = 0;
-    forAll(lst, elemI)
-    {
-        const label newIdx = oldToNew[elemI];
-        if (newIdx >= 0) // could also require newIdx < sz
-        {
-            newLst[newIdx] = lst[elemI];
-            if (prune && maxIdx < newIdx)
-            {
-                maxIdx = newIdx;
-            }
-        }
-        else if (!prune)
-        {
-            newLst[elemI] = lst[elemI];
-        }
-    }
-
-    if (prune && maxIdx < sz)
-    {
-        newLst.setSize(maxIdx);
-    }
-
-    lst.transfer(newLst);
-}
-
-
-// ************************************************************************* //
diff --git a/src/conversion/ccm/misc/mergePoints1.C b/src/conversion/ccm/misc/mergePoints1.C
deleted file mode 100644
index c1114df3ca..0000000000
--- a/src/conversion/ccm/misc/mergePoints1.C
+++ /dev/null
@@ -1,177 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
-     \\/     M anipulation  | Copyright (C) 2016 OpenCFD Ltd.
--------------------------------------------------------------------------------
-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 "ListOps.H"
-#include "point.H"
-#include "Field.H"
-
-// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
-
-
-// template<class Type, template<class> class ListType=UList>
-template<class Type>
-Foam::label Foam::mergePoints
-(
-    const bool dummy,
-    const UIndirectList<Type>& points,
-    const scalar mergeTol,
-    const bool verbose,
-    labelList& pointMap,
-    const Type& origin
-)
-{
-    // Create a old to new point mapping array
-    pointMap.setSize(points.size());
-    pointMap = -1;
-
-    if (points.empty())
-    {
-        return 0;
-    }
-
-    // No normal field operations on UIndirectList.
-    // Use a tmp pointField instead.
-    tmp<Field<Type>> tPoints(new pointField(points));
-
-    Type compareOrigin = origin;
-    if (origin == Type::max)
-    {
-        compareOrigin = sum(tPoints())/points.size();
-    }
-
-    // We're comparing distance squared to origin first.
-    // Say if starting from two close points:
-    //     x, y, z
-    //     x+mergeTol, y+mergeTol, z+mergeTol
-    // Then the magSqr of both will be
-    //     x^2+y^2+z^2
-    //     x^2+y^2+z^2 + 2*mergeTol*(x+z+y) + mergeTol^2*...
-    // so the difference will be 2*mergeTol*(x+y+z)
-
-    const scalar mergeTolSqr = Foam::sqr(scalar(mergeTol));
-
-    // Sort points by magSqr
-    const Field<Type> d(tPoints - compareOrigin);
-
-    List<scalar> magSqrD(d.size());
-    forAll(d, pointI)
-    {
-        magSqrD[pointI] = magSqr(d[pointI]);
-    }
-    labelList order;
-    sortedOrder(magSqrD, order);
-
-
-    Field<scalar> sortedTol(points.size());
-    forAll(order, sortI)
-    {
-        label pointI = order[sortI];
-
-        // Convert to scalar precision
-        const point pt
-        (
-            scalar(d[pointI].x()),
-            scalar(d[pointI].y()),
-            scalar(d[pointI].z())
-        );
-        sortedTol[sortI] = 2*mergeTol*(mag(pt.x())+mag(pt.y())+mag(pt.z()));
-    }
-
-    label newPointI = 0;
-
-    // Handle 0th point separately (is always unique)
-    label pointI = order[0];
-    pointMap[pointI] = newPointI++;
-
-
-    for (label sortI = 1; sortI < order.size(); sortI++)
-    {
-        // Get original point index
-        label pointI = order[sortI];
-        const scalar mag2 = magSqrD[order[sortI]];
-        // Convert to scalar precision
-        const point pt
-        (
-            scalar(points[pointI].x()),
-            scalar(points[pointI].y()),
-            scalar(points[pointI].z())
-        );
-
-
-        // Compare to previous points to find equal one.
-        label equalPointI = -1;
-
-        for
-        (
-            label prevSortI = sortI - 1;
-            prevSortI >= 0
-         && (mag(magSqrD[order[prevSortI]] - mag2) <= sortedTol[sortI]);
-            prevSortI--
-        )
-        {
-            label prevPointI = order[prevSortI];
-            const point prevPt
-            (
-                scalar(points[prevPointI].x()),
-                scalar(points[prevPointI].y()),
-                scalar(points[prevPointI].z())
-            );
-
-            if (magSqr(pt - prevPt) <= mergeTolSqr)
-            {
-                // Found match.
-                equalPointI = prevPointI;
-
-                break;
-            }
-        }
-
-
-        if (equalPointI != -1)
-        {
-            // Same coordinate as equalPointI. Map to same new point.
-            pointMap[pointI] = pointMap[equalPointI];
-
-            if (verbose)
-            {
-                Pout<< "Foam::mergePoints : Merging points "
-                    << pointI << " and " << equalPointI
-                    << " with coordinates:" << points[pointI]
-                    << " and " << points[equalPointI]
-                    << endl;
-            }
-        }
-        else
-        {
-            // Differs. Store new point.
-            pointMap[pointI] = newPointI++;
-        }
-    }
-
-    return newPointI;
-}
-
-
-// ************************************************************************* //
diff --git a/src/conversion/ccm/reader/ccmBoundaryInfo.H b/src/conversion/ccm/reader/ccmBoundaryInfo.H
index 2e5f2377eb..78655b898d 100644
--- a/src/conversion/ccm/reader/ccmBoundaryInfo.H
+++ b/src/conversion/ccm/reader/ccmBoundaryInfo.H
@@ -22,7 +22,7 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Description
-    Containers for holding STARCCM boundary information
+    Container for holding STARCCM boundary information
 
 \*---------------------------------------------------------------------------*/
 #ifndef ccmBoundaryInfo_H
@@ -40,8 +40,11 @@ namespace Foam
 namespace ccm
 {
 
+class ccmBoundaryInfo;
+Ostream& operator<<(Ostream& os, const ccmBoundaryInfo& entry);
+
 /*---------------------------------------------------------------------------*\
-                    Class ccm::ccmBoundaryInfo Declaration
+                 Class Foam::ccm::ccmBoundaryInfo Declaration
 \*---------------------------------------------------------------------------*/
 
 //- Helper when reading raw boundary information
@@ -95,6 +98,7 @@ public:
         return ccmIndex != rhs.ccmIndex;
     }
 
+
     //- Ostream Operator
     friend Ostream& operator<<(Ostream& os, const ccmBoundaryInfo& entry)
     {
diff --git a/src/conversion/ccm/reader/ccmInterfaceDefinitions.H b/src/conversion/ccm/reader/ccmInterfaceDefinitions.H
index 1c9ea2c8e5..066340be80 100644
--- a/src/conversion/ccm/reader/ccmInterfaceDefinitions.H
+++ b/src/conversion/ccm/reader/ccmInterfaceDefinitions.H
@@ -38,8 +38,14 @@ namespace Foam
 namespace ccm
 {
 
+class interfaceEntry;
+class interfaceDefinitions;
+
+Ostream& operator<<(Ostream& os, const interfaceEntry& entry);
+Ostream& operator<<(Ostream& os, const interfaceDefinitions& defs);
+
 /*---------------------------------------------------------------------------*\
-                     Class ccm::interfaceEntry Declaration
+                  Class Foam::ccm::interfaceEntry Declaration
 \*---------------------------------------------------------------------------*/
 
 //- A STARCCM interface definition is a pair of boundary ids
@@ -57,6 +63,7 @@ public:
         //- The second boundary
         label bnd1;
 
+
     // Constructors
 
         //- Construct null
@@ -106,6 +113,12 @@ public:
             return bndId == bnd0 || bndId == bnd1;
         }
 
+        //- True if all internal ids are non-negative
+        bool valid() const
+        {
+            return (id >= 0 && bnd0 >= 0 && bnd1 >= 0 && bnd0 != bnd1);
+        }
+
 
         //- Canonical name for boundary 0
         word canonicalName0() const
@@ -161,42 +174,57 @@ class interfaceDefinitions
 :
     public Map<interfaceEntry>
 {
+
+    inline Map<interfaceEntry>& map()
+    {
+        return *this;
+    }
+
+    inline const Map<interfaceEntry>& map() const
+    {
+        return *this;
+    }
+
+
 public:
     // Constructor
 
         //- Null construct
         interfaceDefinitions()
-        :
-            Map<interfaceEntry>()
         {}
 
-
-        //- Scan available interface entries for one matching this boundary id
-        bool add(interfaceEntry entry)
+        //- Size
+        label size() const
         {
-            if
-            (
-                entry.id >= 0
-             && entry.bnd0 >= 0 && entry.bnd1 >= 0
-             && entry.bnd0 != entry.bnd1
-            )
-            {
-                this->set(entry.id, entry);
-                return true;
-            }
-            else
-            {
-                return false;
-            }
+            return map().size();
+        }
+
+        //- Size
+        bool empty() const
+        {
+            return map().empty();
+        }
+
+        //- Clear
+        void clear()
+        {
+            map().clear();
+        }
+
+
+        //- Add (valid) interface entry
+        bool add(const interfaceEntry& entry)
+        {
+            return (entry.valid() && map().set(entry.id, entry));
         }
 
 
         //- Scan available interface entries for one matching this boundary id
         bool isInterface(label bndId)
         {
-            forAllConstIter(Map<interfaceEntry>, *this, iter)
+            forAllConstIters(map(), iter)
             {
-                if (iter().inInterface(bndId))
+                if (iter.object().inInterface(bndId))
                 {
                     return true;
                 }
@@ -210,9 +238,9 @@ public:
         word interfaceName(label bndId)
         {
             word ifname;
-            forAllConstIter(Map<interfaceEntry>, *this, iter)
+            forAllConstIters(map(), iter)
             {
-                ifname = iter().canonicalName(bndId);
+                ifname = iter.object().canonicalName(bndId);
                 if (!ifname.empty())
                 {
                     break;
@@ -231,9 +259,7 @@ public:
             const interfaceDefinitions& defs
         )
         {
-            os  << static_cast<const Map<interfaceEntry>& >(defs)
-                << nl;
-
+            os  << defs.map() << nl;
             return os;
         }
 
diff --git a/src/conversion/ccm/reader/ccmReader.H b/src/conversion/ccm/reader/ccmReader.H
index 14408d3f94..67d937f136 100644
--- a/src/conversion/ccm/reader/ccmReader.H
+++ b/src/conversion/ccm/reader/ccmReader.H
@@ -368,7 +368,7 @@ private:
         void validateInterface(List<labelPair>&);
 
         //- Renumber interface faces
-        void renumberInterfaces(const List<label>&);
+        void renumberInterfaces(const labelUList& oldToNew);
 
         //- Remove interfaces between domains (fluid/porosity; fluid/solid, etc)
         //  reorganize baffle interfaces into [0-N/2; N/2-N] lists at the
@@ -394,23 +394,27 @@ private:
         ) const;
 
         // polyMesh Friend Functions
-        void addPatches(polyMesh&) const;
+        void addPatches(polyMesh& mesh) const;
 
         //- Add faceZones based on monitoring boundary conditions
-        void addFaceZones(polyMesh&) const;
+        void addFaceZones(polyMesh& mesh) const;
 
         //- Get information about all available solutions
         bool detectSolution();
 
         //- Get information about available fields
         //  assume that all fields are available for all solution intervals
-        void determineFieldInfo(const ccmID& fieldSetNode, fieldTable&);
+        void determineFieldInfo
+        (
+            const ccmID& fieldSetNode,
+            fieldTable& table
+        );
 
 
     // Static Members
 
         //- Get map of porous regions
-        static Map<word> selectPorous(const Map<dictionary>&);
+        static Map<word> selectPorous(const Map<dictionary>& table);
 
 
 public:
@@ -418,13 +422,13 @@ public:
     // Static Members
 
         //- Warn about repeated name
-        static void warnDuplicates(const word& context, const wordList&);
+        static void warnDuplicates(const word& context, const wordList& lst);
 
 
     // Constructors
 
         //- Open a file for reading
-        reader(const fileName&, const options& opts);
+        reader(const fileName& file, const reader::options& opts);
 
 
     //- Destructor (closes file)
@@ -433,7 +437,7 @@ public:
 
     // Member Functions
 
-    // Access
+      // Access
 
         //- Reference to the reader options
         const reader::options& option() const;
@@ -459,7 +463,7 @@ public:
         // const pointField& points() const { return points_; }
 
 
-    // Check
+      // Check
 
         //- Return true if file has geometry associated with it
         bool hasGeometry();
@@ -468,7 +472,7 @@ public:
         bool hasSolution();
 
 
-    // Edit
+      // Edit
 
         //- Remap cellTable and boundaryRegion according to dictionary
         bool remapMeshInfo
@@ -478,17 +482,17 @@ public:
         );
 
 
-    // Write
+      // Write
 
         //- Write the polyMesh
         void writeMesh
         (
-            const polyMesh&,
+            const polyMesh& mesh,
             IOstream::streamFormat fmt = IOstream::BINARY
         ) const;
 
         //- Write cellTable, boundaryRegion and interface information
-        void writeAux(const objectRegistry&) const;
+        void writeAux(const objectRegistry& registry) const;
 
         //- Detect and read geometry if possible
         bool readGeometry(const scalar scaleFactor = 1.0);
@@ -593,12 +597,10 @@ class reader::options
         //- Merge in-place interfaces (default true)
         bool mergeInterfaces_;
 
-        //- Rename interface boundaries as InterfaceN_0, InterfaceN_1 (default true)
+        //- Rename interface boundaries as InterfaceN_0, InterfaceN_1
+        //  (default true)
         bool renameInterfaces_;
 
-        //- Combine identically named boundaries (default false)
-        bool combineBoundaries_;
-
         //- Remove baffles by merging their respective faces (default false)
         bool removeBaffles_;
 
@@ -623,7 +625,7 @@ public:
 
     // Member Functions
 
-    // Access
+      // Access
 
         //- Keep fluid regions (default true)
         bool keepFluid() const;
@@ -640,12 +642,10 @@ public:
         //- Merge in-place interfaces (default true)
         bool mergeInterfaces() const;
 
-        //- Rename interface boundaries as InterfaceN_0, InterfaceN_1 (default true)
+        //- Rename interface boundaries as InterfaceN_0, InterfaceN_1
+        //  (default true)
         bool renameInterfaces() const;
 
-        //- Combine identically named boundaries (default false)
-        bool combineBoundaries() const;
-
         //- Remove baffles by merging their respective faces (default false)
         bool removeBaffles() const;
 
@@ -660,37 +660,35 @@ public:
         scalar undefScalar() const;
 
 
-    // Edit
+      // Edit
 
         //- Keep fluid regions
-        void keepFluid(bool);
+        void keepFluid(bool b);
 
         //- Keep porous regions
-        void keepPorous(bool);
+        void keepPorous(bool b);
 
         //- Keep solid regions
-        void keepSolid(bool);
+        void keepSolid(bool b);
 
         //- Merge in-place interfaces
-        void mergeInterfaces(bool);
+        void mergeInterfaces(bool b);
 
         //- Rename interface boundaries as InterfaceN_0, InterfaceN_1
-        void renameInterfaces(bool);
+        void renameInterfaces(bool b);
 
-        //- Combine identically named boundaries
-        void combineBoundaries(bool);
 
         //- Remove baffles by merging their respective faces
-        void removeBaffles(bool);
+        void removeBaffles(bool b);
 
         //- Use numbered names (eg, patch_0, zone_0) instead of human-readable
-        void useNumberedNames(bool);
+        void useNumberedNames(bool b);
 
         //- Merge tolerance for points (default 0.05e-3)
-        void mergeTol(const scalar&);
+        void mergeTol(const scalar& tol);
 
         //- Value to assign for undefined solutions (default: NaN)
-        void undefScalar(const scalar&);
+        void undefScalar(const scalar& val);
 
 };
 
diff --git a/src/conversion/ccm/reader/ccmReaderAux.C b/src/conversion/ccm/reader/ccmReaderAux.C
index f820dcb7f5..717cdd20e8 100644
--- a/src/conversion/ccm/reader/ccmReaderAux.C
+++ b/src/conversion/ccm/reader/ccmReaderAux.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2016 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2016-2017 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -44,7 +44,7 @@ Foam::Map<Foam::word> Foam::ccm::reader::selectPorous
 {
     Map<word> lookup;
 
-    forAllConstIter(Map<dictionary>, table, iter)
+    forAllConstIters(table, iter)
     {
         if (iter().lookupOrDefault<label>("PorosityId", 0) != 0)
         {
@@ -70,21 +70,21 @@ void Foam::ccm::reader::warnDuplicates
     const wordList& lst
 )
 {
-    HashTable<label> hashed(lst.size());
+    HashTable<label> hashed(2*lst.size());
     bool duplicates = false;
 
-    forAll(lst, elemI)
+    for (const word& item : lst)
     {
-        // Check duplicate name
-        HashTable<label>::iterator iter = hashed.find(lst[elemI]);
-        if (iter != hashed.end())
+        // Check duplicate names
+        auto iter = hashed.find(item);
+        if (iter.found())
         {
             (*iter)++;
             duplicates = true;
         }
         else
         {
-            hashed.insert(lst[elemI], 1);
+            hashed.insert(item, 1);
         }
     }
 
@@ -92,9 +92,9 @@ void Foam::ccm::reader::warnDuplicates
     if (duplicates)
     {
         Info << nl << "WARNING: " << context << " with identical names:";
-        forAllConstIter(HashTable<label>, hashed, iter)
+        forAllConstIters(hashed, iter)
         {
-            if (*iter > 1)
+            if (iter.object() > 1)
             {
                 Info << "  " << iter.key();
             }
diff --git a/src/conversion/ccm/reader/ccmReaderMesh.C b/src/conversion/ccm/reader/ccmReaderMesh.C
index 5c4bf5c1fd..bb81960625 100644
--- a/src/conversion/ccm/reader/ccmReaderMesh.C
+++ b/src/conversion/ccm/reader/ccmReaderMesh.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2016 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2016-2017 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -37,8 +37,8 @@ License
 #include "PackedList.H"
 #include "uindirectPrimitivePatch.H"
 #include "SortableList.H"
-#include "mergePoints1.H"
-#include "ListOps1.H"
+#include "mergePoints.H"
+#include "ListOps.H"
 
 #include "ccmInternal.H" // include last to avoid any strange interactions
 
@@ -479,8 +479,8 @@ void Foam::ccm::reader::readCells
         info.setPatchName(ccmReadOptstr("Label", nodeId));
 
         // Lookup the name, type from boundary region info:
-        Map<dictionary>::iterator dictIter = boundaryRegion_.find(info.ccmIndex);
-        if (dictIter != boundaryRegion_.end())
+        auto dictIter = boundaryRegion_.find(info.ccmIndex);
+        if (dictIter.found())
         {
             word patchName(dictIter()["Label"]);
             word patchType(dictIter()["BoundaryType"]);
@@ -517,51 +517,6 @@ void Foam::ccm::reader::readCells
     origBndId_  = -1;
     nPatches = 0;
 
-    HashTable<label, std::string> hashedNames;
-    if (option().combineBoundaries())
-    {
-        // Ensure all the interfaces are orderd up-front:
-        forAll(interfaceDefinitions_, interI)
-        {
-            const interfaceEntry& ifentry = interfaceDefinitions_[interI];
-
-            label info0Index = -1;
-            label info1Index = -1;
-
-            forAll(bndInfo, infoI)
-            {
-                if (bndInfo[infoI].ccmIndex == ifentry.bnd0)
-                {
-                    info0Index = infoI;
-                }
-                else if (bndInfo[infoI].ccmIndex == ifentry.bnd1)
-                {
-                    info1Index = infoI;
-                }
-            }
-
-            if (info0Index == info1Index || info0Index < 0 || info1Index < 0)
-            {
-                // this should never be able to happen
-                continue;
-            }
-
-            ccmBoundaryInfo& info0 = bndInfo[info0Index];
-            ccmBoundaryInfo& info1 = bndInfo[info1Index];
-
-            // Preserve interface order
-            info0.patchId = nPatches++;
-            info1.patchId = nPatches++;
-
-            // full safety:
-            info0.patchName = ifentry.canonicalName0();
-            info1.patchName = ifentry.canonicalName1();
-
-            hashedNames.insert(info0.patchName, info0Index);
-            hashedNames.insert(info1.patchName, info1Index);
-        }
-    }
-
     forAll(bndInfo, infoI)
     {
         ccmBoundaryInfo& info = bndInfo[infoI];
@@ -573,27 +528,8 @@ void Foam::ccm::reader::readCells
         }
         else
         {
-            if (option().combineBoundaries())
-            {
-                // Check if patch name was already seen
-                HashTable<label, std::string>::const_iterator citer = hashedNames.find(info.patchName);
-                if (citer != hashedNames.end())
-                {
-                    info.patchId = bndInfo[citer()].patchId;
-                }
-                else
-                {
-                    hashedNames.insert(info.patchName, infoI);
-
-                    info.patchId = nPatches++;
-                    origBndId_[info.patchId] = info.ccmIndex;
-                }
-            }
-            else
-            {
-                info.patchId = nPatches++;
-                origBndId_[info.patchId] = info.ccmIndex;
-            }
+            info.patchId = nPatches++;
+            origBndId_[info.patchId] = info.ccmIndex;
         }
 
         patchSizes_[info.patchId] += info.size;
@@ -622,20 +558,6 @@ void Foam::ccm::reader::readCells
         ccmLookupOrder.resetAddressing(addr.xfer());
     }
 
-    if (option().combineBoundaries())
-    {
-        Info<<"patches combined by name: ";
-        if (nPatches == bndInfo.size())
-        {
-            Info<<"none" << endl;
-        }
-        else
-        {
-            Info<< bndInfo.size() << " into " << nPatches << endl;
-        }
-        // Info<< ccmLookupOrder << endl;
-    }
-
 
     //
     // Now we are ready to do the reading
@@ -775,7 +697,11 @@ void Foam::ccm::reader::readCells
                 kCCMIOStart,
                 kCCMIOEnd
             );
-            assertNoError("Error reading boundary face cells - index " + ::Foam::name(info.ccmIndex));
+            assertNoError
+            (
+                "Error reading boundary face cells - index "
+              + ::Foam::name(info.ccmIndex)
+            );
 
             // Copy into Foam list
             // ccmFaces are organized as [nVert vrt1 .. vrtN]
@@ -797,7 +723,11 @@ void Foam::ccm::reader::readCells
         }
         else
         {
-            assertNoError("Error reading boundary faces - index " + ::Foam::name(info.ccmIndex));
+            assertNoError
+            (
+                "Error reading boundary faces - index "
+              + ::Foam::name(info.ccmIndex)
+            );
         }
     }
 
@@ -1106,11 +1036,10 @@ void Foam::ccm::reader::readMonitoring
                 << "ccmRegionId: " << ccmRegionId << endl;
 #endif
 
-            Map<dictionary>::const_iterator
-                iter = boundaryRegion_.find(ccmRegionId);
+            auto iter = boundaryRegion_.cfind(ccmRegionId);
 
             word zoneName;
-            if (iter != boundaryRegion_.end())
+            if (iter.found())
             {
                 iter().lookup("Label") >> zoneName;
             }
@@ -1314,7 +1243,7 @@ void Foam::ccm::reader::removeUnwanted()
         {
             Map<word> keepMap;
 
-            forAllConstIter(Map<dictionary>, cellTable_, iter)
+            forAllConstIters(cellTable_, iter)
             {
                 const label tableId = iter.key();
                 if (!removeMap.found(tableId))
@@ -1326,17 +1255,19 @@ void Foam::ccm::reader::removeUnwanted()
             Info<<"remove "<< nRemove << " cells in "
                 << removeMap.size() << " unwanted cellZone(s)" << nl;
 
-            forAllConstIter(Map<word>, removeMap, iter)
+            forAllConstIters(removeMap, iter)
             {
-                Info<< "    zone " << iter.key() << " : "<< iter() << nl;
+                Info<< "    zone "
+                    << iter.key() << " : " << iter.object() << nl;
             }
 
             Info<<"retain "<< (nCells_ - nRemove) << " cells in "
                 << keepMap.size() << " cellZone(s)" << nl;
 
-            forAllConstIter(Map<word>, keepMap, iter)
+            forAllConstIters(keepMap, iter)
             {
-                Info<< "    zone " << iter.key() << " : "<< iter() << nl;
+                Info<< "    zone "
+                    << iter.key() << " : " << iter.object() << nl;
             }
         }
     }
@@ -1512,7 +1443,7 @@ void Foam::ccm::reader::validateInterface
 
 void Foam::ccm::reader::renumberInterfaces
 (
-    const labelList& oldToNew
+    const labelUList& oldToNew
 )
 {
     forAll(domInterfaces_, elemI)
@@ -1544,8 +1475,8 @@ void Foam::ccm::reader::cleanupInterfaces()
 
     if (bafInterfaces_.size() <= 0 && domInterfaces_.size() <= 0)
     {
-        Info<<"0 baffle interface pairs" << endl;
-        Info<<"0 domain interface pairs" << endl;
+        Info<<"0 baffle interface pairs" << nl
+            <<"0 domain interface pairs" << endl;
         return;
     }
 
@@ -1559,8 +1490,8 @@ void Foam::ccm::reader::cleanupInterfaces()
 
     forAll(domInterfaces_, elemI)
     {
-        label face0 = domInterfaces_[elemI][0];
-        label face1 = domInterfaces_[elemI][1];
+        const label face0 = domInterfaces_[elemI][0];
+        const label face1 = domInterfaces_[elemI][1];
 
         Info<< "interface [" << elemI << "] = "
             << face0 << " - " << face1 << " own/neigh = "
@@ -1821,7 +1752,7 @@ void Foam::ccm::reader::cleanupInterfaces()
 //             << SubList<label>(oldToNew, nFaces_ - nInternalFaces_, nInternalFaces_)
 //             << endl;
 
-        forAllIter(HashTable<labelList>, monitoringSets_, iter)
+        forAllIters(monitoringSets_, iter)
         {
             inplaceRenumber(oldToNew, iter());
         }
@@ -1893,9 +1824,11 @@ void Foam::ccm::reader::mergeInplaceInterfaces()
     // List of patch pairs that are interfaces
     DynamicList<labelPair> interfacePatches(interfaceDefinitions_.size());
 
-    forAll(interfaceDefinitions_, interI)
+    label nWarn = 0;
+
+    forAllConstIters(interfaceDefinitions_, iter)
     {
-        const interfaceEntry& ifentry = interfaceDefinitions_[interI];
+        const interfaceEntry& ifentry = iter.object();
 
         labelPair patchPair
         (
@@ -1903,10 +1836,15 @@ void Foam::ccm::reader::mergeInplaceInterfaces()
             findIndex(origBndId_, ifentry.bnd1)
         );
 
-        if (patchPair[0] == patchPair[1] || patchPair[0] < 0 || patchPair[1] < 0)
+        if
+        (
+            patchPair[0] == patchPair[1]
+         || patchPair[0] < 0
+         || patchPair[1] < 0
+        )
         {
             // This should not happen
-            Info<<"Warning : bad interface " << interI << " " << ifentry
+            Info<<"Warning : bad interface " << ifentry.id << " " << ifentry
                 <<" on patches " << patchPair << endl;
         }
         else if
@@ -1916,11 +1854,18 @@ void Foam::ccm::reader::mergeInplaceInterfaces()
          || patchSizes_[patchPair[1]] == 0
         )
         {
-            Info<<"Warning : skip interface " << interI << " " << ifentry
-                <<" on patches " << patchPair << nl
-                <<"   has zero or different number of faces: ("
-                << patchSizes_[patchPair[0]]  << " " << patchSizes_[patchPair[1]] << ")"
-                << endl;
+            if (!nWarn++)
+            {
+                Info<<"Warning: skip interface with zero or different"
+                    << " number of faces" << nl;
+            }
+
+            Info<<"  Interface:" << ifentry.id << " " << ifentry
+                <<" patches " << patchPair
+                <<" sizes ("
+                << patchSizes_[patchPair[0]]
+                << " " << patchSizes_[patchPair[1]] << ")"
+                << nl;
         }
         else
         {
@@ -1947,7 +1892,8 @@ void Foam::ccm::reader::mergeInplaceInterfaces()
     // Markup points to merge
     PackedBoolList whichPoints(points_.size());
 
-    Info<< "interface merge points (tol=" << option().mergeTol() << "):" << endl;
+    Info<< "interface merge points (tol="
+        << option().mergeTol() << "):" << endl;
 
     DynamicList<label> interfacesToMerge(interfacePatches.size());
     forAll(interfacePatches, interI)
@@ -1985,12 +1931,11 @@ void Foam::ccm::reader::mergeInplaceInterfaces()
 
         const UIndirectList<point> pointsToMerge(points_, addr);
 
-        Info<< "    patch "  << patch0 << ", " << patch1 << ": ("
+        Info<< "    patch "  << patch0 << "," << patch1 << ": ("
             << nPatch0Faces << " and " << nPatch1Faces << " faces) " << flush;
 
-        label nMerged = mergePoints
+        const label nMerged = mergePoints
         (
-            true,
             pointsToMerge,
             option().mergeTol(),
             false,
@@ -2003,9 +1948,9 @@ void Foam::ccm::reader::mergeInplaceInterfaces()
         if (nMerged)
         {
             // Transcribe local to global addressing
-            forAll(mergedPointMap, lookupI)
+            forAll(mergedPointMap, i)
             {
-                oldToNew[addr[lookupI]] = addr[mergedPointMap[lookupI]];
+                oldToNew[addr[i]] = addr[mergedPointMap[i]];
             }
 
             interfacesToMerge.append(interI);
@@ -2175,11 +2120,11 @@ void Foam::ccm::reader::mergeInplaceInterfaces()
             // Note which one were successful
             labelHashSet done(failed0.size());
 
-            forAllConstIter(labelHashSet, failed0, iter0)
+            forAllConstIters(failed0, iter0)
             {
                 const label face0I = iter0.key();
 
-                forAllConstIter(labelHashSet, failed1, iter1)
+                forAllConstIters(failed1, iter1)
                 {
                     const label face1I = iter1.key();
 
@@ -2421,10 +2366,10 @@ void Foam::ccm::reader::reorderMesh()
     inplaceReorder(oldToNew, faceNeighbour_);
     inplaceReorder(oldToNew, origFaceId_);
 
-    forAllIter(HashTable<labelList>, monitoringSets_, iter)
+    forAllIters(monitoringSets_, iter)
     {
-        inplaceRenumber(oldToNew, iter());
-        labelList &lst = iter();
+        labelList& lst = iter.object();
+        inplaceRenumber(oldToNew, lst);
 
         // disallow monitoring on boundaries
         label nElem = 0;
@@ -2436,7 +2381,7 @@ void Foam::ccm::reader::reorderMesh()
                 {
                     lst[nElem] = lst[i];
                 }
-                nElem++;
+                ++nElem;
             }
         }
 
@@ -2478,10 +2423,9 @@ void Foam::ccm::reader::addPatches
         word patchName;
         word patchType;
 
-        Map<dictionary>::const_iterator
-            citer = boundaryRegion_.find(origBndId_[patchI]);
+        auto citer = boundaryRegion_.cfind(origBndId_[patchI]);
 
-        if (citer != boundaryRegion_.end())
+        if (citer.found())
         {
             citer().lookup("Label") >> patchName;
             citer().lookup("BoundaryType") >> patchType;
@@ -2593,7 +2537,7 @@ void Foam::ccm::reader::addFaceZones
     }
 
     nZone = 0;
-    forAllConstIter(HashTable<labelList>, monitoringSets_, iter)
+    forAllConstIters(monitoringSets_, iter)
     {
         Info<< "faceZone " << nZone
             << " (size: " << iter().size() << ") name: "
@@ -2612,7 +2556,7 @@ void Foam::ccm::reader::addFaceZones
             )
         );
 
-        nZone++;
+        ++nZone;
     }
 
     mesh.faceZones().writeOpt() = IOobject::AUTO_WRITE;
diff --git a/src/conversion/ccm/reader/ccmReaderOptions.C b/src/conversion/ccm/reader/ccmReaderOptions.C
index c6bfe87d7d..994dba080c 100644
--- a/src/conversion/ccm/reader/ccmReaderOptions.C
+++ b/src/conversion/ccm/reader/ccmReaderOptions.C
@@ -34,7 +34,6 @@ Foam::ccm::reader::options::options()
     keepSolid_(true),
     mergeInterfaces_(false),
     renameInterfaces_(true),
-    combineBoundaries_(false),
     removeBaffles_(false),
     useNumberedNames_(false),
     mergeTol_(0.05e-3),
@@ -80,12 +79,6 @@ bool Foam::ccm::reader::options::renameInterfaces() const
 }
 
 
-bool Foam::ccm::reader::options::combineBoundaries() const
-{
-    return combineBoundaries_;
-}
-
-
 bool Foam::ccm::reader::options::removeBaffles() const
 {
     return removeBaffles_;
@@ -141,12 +134,6 @@ void Foam::ccm::reader::options::renameInterfaces(bool b)
 }
 
 
-void Foam::ccm::reader::options::combineBoundaries(bool b)
-{
-    combineBoundaries_ = b;
-}
-
-
 void Foam::ccm::reader::options::removeBaffles(bool b)
 {
     removeBaffles_ = b;
diff --git a/src/conversion/ccm/reader/ccmReaderSolution.C b/src/conversion/ccm/reader/ccmReaderSolution.C
index 04881011f3..e849823b34 100644
--- a/src/conversion/ccm/reader/ccmReaderSolution.C
+++ b/src/conversion/ccm/reader/ccmReaderSolution.C
@@ -622,7 +622,7 @@ Foam::ccm::reader::readField
                             // transcribe to output list
                             forAll(mapData, i)
                             {
-                                label cellId = mapData[i];
+                                const label cellId = mapData[i];
                                 scalarData[cellId] = rawData[i];
                             }
 
diff --git a/src/conversion/ccm/reader/ccmSolutionTable.H b/src/conversion/ccm/reader/ccmSolutionTable.H
index e223d1c748..1a58d67cc6 100644
--- a/src/conversion/ccm/reader/ccmSolutionTable.H
+++ b/src/conversion/ccm/reader/ccmSolutionTable.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2016 OpenCFD Ltd.
+    \\  /    A nd           | Copyright (C) 2016-2017 OpenCFD Ltd.
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -29,8 +29,8 @@ Description
 #define ccmSolutionTable_H
 
 #include "SLList.H"
-#include "stringListOps.H"
 #include "Ostream.H"
+#include "stringListOps.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -39,8 +39,16 @@ namespace Foam
 namespace ccm
 {
 
+class fieldEntry;
+class fieldTable;
+class solutionEntry;
+
+Ostream& operator<<(Ostream& os, const fieldEntry& entry);
+Ostream& operator<<(Ostream& os, const fieldTable& entry);
+Ostream& operator<<(Ostream& os, const solutionEntry& entry);
+
 /*---------------------------------------------------------------------------*\
-                      Class ccm::namesList Declaration
+                    Class Foam::ccm::namesList Declaration
 \*---------------------------------------------------------------------------*/
 
 //- A linked-list that is searchable by the 'name()' of the items
@@ -50,8 +58,8 @@ class namesList
     public SLList<T>
 {
 public:
-    typedef typename SLList<T>::const_iterator const_iterator;
-    typedef typename SLList<T>::iterator iterator;
+    using const_iterator = typename SLList<T>::const_iterator;
+    using iterator = typename SLList<T>::iterator;
 
     // Constructors
 
@@ -65,12 +73,7 @@ public:
         //- Return true if a list element has a name that matches key
         bool found(const word& key) const
         {
-            for
-            (
-                const_iterator iter = SLList<T>::begin();
-                iter != SLList<T>::end();
-                ++iter
-            )
+            forAllConstIters(*this, iter)
             {
                 if (iter().name() == key)
                 {
@@ -85,12 +88,7 @@ public:
         //- Find a list element has a name matching key
         iterator find(const word& key)
         {
-            for
-            (
-                iterator iter = SLList<T>::begin();
-                iter != SLList<T>::end();
-                ++iter
-            )
+            forAllIters(*this, iter)
             {
                 if (iter().name() == key)
                 {
@@ -112,12 +110,7 @@ public:
             List<word> matched(SLList<T>::size());
 
             label matchI = 0;
-            for
-            (
-                const_iterator iter = SLList<T>::begin();
-                iter != SLList<T>::end();
-                ++iter
-            )
+            forAllConstIters(*this, iter)
             {
                 const word& name = iter().name();
 
@@ -139,7 +132,7 @@ public:
 
 
 /*---------------------------------------------------------------------------*\
-                      Class ccm::fieldEntry Declaration
+                    Class Foam::ccm::fieldEntry Declaration
 \*---------------------------------------------------------------------------*/
 
 //- A ccm field entry with short name, name, maxId and type
@@ -223,15 +216,6 @@ public:
 
     // Edit
 
-        //- Set the field units
-        void units(const char* units)
-        {
-            if (units && *units)
-            {
-                units_ = units;
-            }
-        }
-
         //- Set the field units
         void units(const std::string& units)
         {
@@ -279,8 +263,9 @@ public:
 
 };
 
+
 /*---------------------------------------------------------------------------*\
-                    Class ccm::solutionEntry Declaration
+                  Class Foam::ccm::solutionEntry Declaration
 \*---------------------------------------------------------------------------*/
 
 //- A ccm solution entry with name, iteration and time
@@ -306,8 +291,8 @@ public:
         solutionEntry
         (
             const word& name,
-            const label& iteration,
-            const scalar& timeValue = 0
+            const label iteration,
+            const scalar timeValue = 0
         )
         :
             name_(name),
@@ -355,7 +340,7 @@ public:
 
 
 /*---------------------------------------------------------------------------*\
-                    Class ccm::solutionTable Declaration
+                  Class Foam::ccm::solutionTable Declaration
 \*---------------------------------------------------------------------------*/
 
 // Typedef: ccm::solutionTable
@@ -364,7 +349,7 @@ typedef namesList<solutionEntry> solutionTable;
 
 
 /*---------------------------------------------------------------------------*\
-                      Class ccm::fieldTable Declaration
+                    Class Foam::ccm::fieldTable Declaration
 \*---------------------------------------------------------------------------*/
 
 //- A list of the available fields
@@ -382,15 +367,16 @@ public:
             namesList<fieldEntry>()
         {}
 
+
     // Access
 
         //- The maximum cell Id referenced in the list
         label maxCellId() const
         {
             label maxId = 0;
-            forAllConstIter(namesList<fieldEntry>, *this, iter)
+            forAllConstIters(*this, iter)
             {
-                label currMax = (iter()).maxCellId();
+                const label currMax = iter().maxCellId();
 
                 if (maxId < currMax)
                 {
@@ -406,10 +392,9 @@ public:
         label maxFaceId() const
         {
             label maxId = 0;
-
-            forAllConstIter(namesList<fieldEntry>, *this, iter)
+            forAllConstIters(*this, iter)
             {
-                label currMax = (iter()).maxFaceId();
+                const label currMax = iter().maxFaceId();
 
                 if (maxId < currMax)
                 {
diff --git a/src/conversion/ccm/writer/ccmWriter.C b/src/conversion/ccm/writer/ccmWriter.C
index c78a2fa068..8cd6dfdd50 100644
--- a/src/conversion/ccm/writer/ccmWriter.C
+++ b/src/conversion/ccm/writer/ccmWriter.C
@@ -95,7 +95,7 @@ void Foam::ccm::writer::writeBoundaryRegion
     // Create dictionary lookup for constant/boundaryRegion
     dictionary typeDict;
 
-    forAllConstIter(Map<dictionary>, boundaryRegion_, iter)
+    forAllConstIters(boundaryRegion_, iter)
     {
         const dictionary& dict = iter();
         if
@@ -207,7 +207,7 @@ void Foam::ccm::writer::writeCellTable
 
     ccmID nodeId;
 
-    forAllConstIter(Map<dictionary>, cellTable_, iter)
+    forAllConstIters(cellTable_, iter)
     {
         label intVal = iter.key();
         const dictionary& dict = iter();
@@ -292,7 +292,6 @@ void Foam::ccm::writer::writeProblem
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
-// Construct for writing geometry
 Foam::ccm::writer::writer
 (
     const fileName& file,
diff --git a/src/conversion/ccm/writer/ccmWriter.H b/src/conversion/ccm/writer/ccmWriter.H
index a2d57148c9..c7b71c6311 100644
--- a/src/conversion/ccm/writer/ccmWriter.H
+++ b/src/conversion/ccm/writer/ccmWriter.H
@@ -219,7 +219,12 @@ public:
     // Constructors
 
         //- Open a file for writing, with backup/overwrite existing file
-        writer(const fileName&, const polyMesh&, const bool backup=true);
+        writer
+        (
+            const fileName& file,
+            const polyMesh& mesh,
+            const bool backup=true
+        );
 
 
     //- Destructor (closes file)
@@ -228,7 +233,7 @@ public:
 
     // Member Functions
 
-        // Write
+      // Write
 
         //- Write the mesh
         void writeGeometry();
@@ -237,7 +242,7 @@ public:
         //  provide optional remapping dictionary
         void writeSolution
         (
-            const IOobjectList&,
+            const IOobjectList& objects,
             const fileName& remappingDictName = fileName::null
         );
 
diff --git a/src/conversion/ccm/writer/ccmWriterMesh.C b/src/conversion/ccm/writer/ccmWriterMesh.C
index f17a56a530..1e2bd0f2b2 100644
--- a/src/conversion/ccm/writer/ccmWriterMesh.C
+++ b/src/conversion/ccm/writer/ccmWriterMesh.C
@@ -567,9 +567,9 @@ void Foam::ccm::writer::writeCells
                     tableId = cellTable_.append(dict);
                 }
 
-                forAll(cZone, i)
+                for (auto id : cZone)
                 {
-                    mapData[cZone[i]] = tableId;
+                    mapData[id] = tableId;
                 }
             }
         }
@@ -582,11 +582,11 @@ void Foam::ccm::writer::writeCells
             dict.add("MaterialType", "fluid");
             label tableId = cellTable_.append(dict);
 
-            forAll(mapData, i)
+            for (auto& id : mapData)
             {
-                if (mapData[i] < 0)
+                if (id < 0)
                 {
-                    mapData[i] = tableId;
+                    id = tableId;
                 }
             }
         }
diff --git a/src/conversion/ccm/writer/ccmWriterSolution.C b/src/conversion/ccm/writer/ccmWriterSolution.C
index 354e9cdf93..3887f895e5 100644
--- a/src/conversion/ccm/writer/ccmWriterSolution.C
+++ b/src/conversion/ccm/writer/ccmWriterSolution.C
@@ -463,8 +463,6 @@ void Foam::ccm::writer::writeSolution
         &phaseNode
     );
 
-
-
     forAllConstIter(IOobjectList, objects, iter)
     {
         word fieldName = (*iter()).name();
diff --git a/src/conversion/fire/FIREMeshReader.C b/src/conversion/fire/FIREMeshReader.C
index e79d70b060..c57a188615 100644
--- a/src/conversion/fire/FIREMeshReader.C
+++ b/src/conversion/fire/FIREMeshReader.C
@@ -375,7 +375,7 @@ bool Foam::fileFormats::FIREMeshReader::readGeometry(const scalar scaleFactor)
     IOstream::streamFormat fmt = IOstream::ASCII;
 
     const word ext = geometryFile_.ext();
-    bool supported = FIRECore::file3dExtensions.found(ext);
+    bool supported = FIRECore::file3dExtensions.hasEnum(ext);
     if (supported)
     {
         FIRECore::fileExt3d fireFileType = FIRECore::file3dExtensions[ext];
diff --git a/src/conversion/fire/FIREMeshWriter.C b/src/conversion/fire/FIREMeshWriter.C
index 29746005d0..9c6146c3e0 100644
--- a/src/conversion/fire/FIREMeshWriter.C
+++ b/src/conversion/fire/FIREMeshWriter.C
@@ -278,7 +278,7 @@ bool Foam::fileFormats::FIREMeshWriter::write(const fileName& meshName) const
     {
         const word ext = baseName.ext();
 
-        if (FIRECore::file3dExtensions.found(ext))
+        if (FIRECore::file3dExtensions.hasEnum(ext))
         {
             FIRECore::fileExt3d fireFileType = FIRECore::file3dExtensions[ext];
             if (fireFileType == FIRECore::POLY_ASCII)
diff --git a/src/dynamicMesh/meshSubsetHelper/meshSubsetHelper.C b/src/dynamicMesh/meshSubsetHelper/meshSubsetHelper.C
index 7a7d4fbcf7..2e55e4a0ea 100644
--- a/src/dynamicMesh/meshSubsetHelper/meshSubsetHelper.C
+++ b/src/dynamicMesh/meshSubsetHelper/meshSubsetHelper.C
@@ -90,9 +90,13 @@ void Foam::meshSubsetHelper::correct(bool verbose)
 
 Foam::polyMesh::readUpdateState Foam::meshSubsetHelper::readUpdate()
 {
-    polyMesh::readUpdateState meshState = baseMesh_.readUpdate();
+    const polyMesh::readUpdateState meshState = baseMesh_.readUpdate();
 
-    if (meshState == polyMesh::TOPO_CHANGE || polyMesh::TOPO_PATCH_CHANGE)
+    if
+    (
+        meshState == polyMesh::TOPO_CHANGE
+     || meshState == polyMesh::TOPO_PATCH_CHANGE
+    )
     {
         correct(true);
     }
diff --git a/src/finiteVolume/functionObjects/volRegion/volRegion.C b/src/finiteVolume/functionObjects/volRegion/volRegion.C
index 3a0dcede22..ab2f65fcfb 100644
--- a/src/finiteVolume/functionObjects/volRegion/volRegion.C
+++ b/src/finiteVolume/functionObjects/volRegion/volRegion.C
@@ -83,6 +83,7 @@ Foam::functionObjects::volRegion::volRegion
       ? regionTypeNames_.read(dict.lookup("regionType"))
       : vrtAll
     ),
+    regionName_(polyMesh::defaultRegion),
     regionID_(-1)
 {
     read(dict);
@@ -143,7 +144,7 @@ bool Foam::functionObjects::volRegion::read
         {
             FatalIOErrorInFunction(dict)
                 << "Unknown region type. Valid region types are:"
-                << regionTypeNames_
+                << regionTypeNames_.toc()
                 << exit(FatalIOError);
         }
     }
diff --git a/src/functionObjects/field/fieldValues/surfaceFieldValue/surfaceFieldValue.C b/src/functionObjects/field/fieldValues/surfaceFieldValue/surfaceFieldValue.C
index f28944d995..3d39aa4655 100644
--- a/src/functionObjects/field/fieldValues/surfaceFieldValue/surfaceFieldValue.C
+++ b/src/functionObjects/field/fieldValues/surfaceFieldValue/surfaceFieldValue.C
@@ -564,9 +564,10 @@ void Foam::functionObjects::fieldValues::surfaceFieldValue::initialise
         {
             FatalErrorInFunction
                 << type() << " " << name() << ": "
-                << regionTypeNames_[regionType_] << "(" << regionName_ << "):"
+                << int(regionType_) << "(" << regionName_ << "):"
                 << nl << "    Unknown region type. Valid region types are:"
-                << regionTypeNames_.sortedToc() << nl << exit(FatalError);
+                << regionTypeNames_ << nl
+                << exit(FatalError);
         }
     }
 
diff --git a/src/functionObjects/field/fieldValues/volFieldValue/volFieldValueTemplates.C b/src/functionObjects/field/fieldValues/volFieldValue/volFieldValueTemplates.C
index 94a3b8b758..a4f1fb82a6 100644
--- a/src/functionObjects/field/fieldValues/volFieldValue/volFieldValueTemplates.C
+++ b/src/functionObjects/field/fieldValues/volFieldValue/volFieldValueTemplates.C
@@ -217,12 +217,17 @@ bool Foam::functionObjects::fieldValues::volFieldValue::writeValues
 
             if (Pstream::master())
             {
+                word outName = fieldName + '_' + regionTypeNames_[regionType_];
+                if (this->volRegion::regionName_ != polyMesh::defaultRegion)
+                {
+                    outName = outName + '-' + this->volRegion::regionName_;
+                }
+
                 IOField<Type>
                 (
                     IOobject
                     (
-                        fieldName + '_' + regionTypeNames_[regionType_]
-                      + '-' + volRegion::regionName_,
+                        outName,
                         obr_.time().timeName(),
                         obr_,
                         IOobject::NO_READ,
@@ -241,13 +246,17 @@ bool Foam::functionObjects::fieldValues::volFieldValue::writeValues
         file()<< tab << result;
 
         Log << "    " << operationTypeNames_[operation_]
-            << "(" << volRegion::regionName_ << ") of " << fieldName
+            << "(" << this->volRegion::regionName_ << ") of " << fieldName
             <<  " = " << result << endl;
 
         // Write state/results information
         const word& opName = operationTypeNames_[operation_];
-        word resultName =
-            opName + '(' + volRegion::regionName_ + ',' + fieldName + ')';
+        word outName = fieldName;
+        if (this->volRegion::regionName_ != polyMesh::defaultRegion)
+        {
+            outName = this->volRegion::regionName_ + ',' + outName;
+        }
+        word resultName = opName + '(' + outName + ')';
         this->setResult(resultName, result);
     }
 
diff --git a/src/functionObjects/field/mapFields/mapFields.C b/src/functionObjects/field/mapFields/mapFields.C
index 00a387ad6e..f0d250f659 100644
--- a/src/functionObjects/field/mapFields/mapFields.C
+++ b/src/functionObjects/field/mapFields/mapFields.C
@@ -71,14 +71,14 @@ void Foam::functionObjects::mapFields::createInterpolation
         )
     );
     const fvMesh& mapRegion = mapRegionPtr_();
-    word mapMethodName(dict.lookup("mapMethod"));
-    if (!meshToMesh::interpolationMethodNames_.found(mapMethodName))
+    const word mapMethodName(dict.lookup("mapMethod"));
+    if (!meshToMesh::interpolationMethodNames_.hasEnum(mapMethodName))
     {
         FatalErrorInFunction
             << type() << " " << name() << ": unknown map method "
             << mapMethodName << nl
             << "Available methods include: "
-            << meshToMesh::interpolationMethodNames_.sortedToc()
+            << meshToMesh::interpolationMethodNames_
             << exit(FatalError);
     }
 
diff --git a/src/functionObjects/utilities/writeObjects/writeObjects.C b/src/functionObjects/utilities/writeObjects/writeObjects.C
index aad0e40554..eade946402 100644
--- a/src/functionObjects/utilities/writeObjects/writeObjects.C
+++ b/src/functionObjects/utilities/writeObjects/writeObjects.C
@@ -196,7 +196,8 @@ bool Foam::functionObjects::writeObjects::write()
                 FatalErrorInFunction
                     << "Unknown writeOption "
                     << writeOptionNames_[writeOption_]
-                    << ". Valid writeOption types are" << writeOptionNames_
+                    << ". Valid writeOption types are "
+                    << writeOptionNames_
                     << exit(FatalError);
             }
         }
diff --git a/src/fvOptions/cellSetOption/cellSetOption.C b/src/fvOptions/cellSetOption/cellSetOption.C
index 665b98343d..929b457a7e 100644
--- a/src/fvOptions/cellSetOption/cellSetOption.C
+++ b/src/fvOptions/cellSetOption/cellSetOption.C
@@ -82,7 +82,8 @@ void Foam::fv::cellSetOption::setSelection(const dictionary& dict)
             FatalErrorInFunction
                 << "Unknown selectionMode "
                 << selectionModeTypeNames_[selectionMode_]
-                << ". Valid selectionMode types are" << selectionModeTypeNames_
+                << ". Valid selectionMode types are "
+                << selectionModeTypeNames_
                 << exit(FatalError);
         }
     }
@@ -186,7 +187,8 @@ void Foam::fv::cellSetOption::setCellSet()
             FatalErrorInFunction
                 << "Unknown selectionMode "
                 << selectionModeTypeNames_[selectionMode_]
-                << ". Valid selectionMode types are" << selectionModeTypeNames_
+                << ". Valid selectionMode types are "
+                << selectionModeTypeNames_
                 << exit(FatalError);
         }
     }
diff --git a/src/fvOptions/sources/derived/directionalPressureGradientExplicitSource/directionalPressureGradientExplicitSource.C b/src/fvOptions/sources/derived/directionalPressureGradientExplicitSource/directionalPressureGradientExplicitSource.C
index 7607aacf79..0bc5217e98 100644
--- a/src/fvOptions/sources/derived/directionalPressureGradientExplicitSource/directionalPressureGradientExplicitSource.C
+++ b/src/fvOptions/sources/derived/directionalPressureGradientExplicitSource/directionalPressureGradientExplicitSource.C
@@ -236,7 +236,7 @@ directionalPressureGradientExplicitSource
             << "Did not find mode " << model_
             << nl
             << "Please set 'model' to one of "
-            << PressureDropModelNames_.toc()
+            << PressureDropModelNames_
             << exit(FatalError);
     }
 
@@ -290,7 +290,6 @@ void Foam::fv::directionalPressureGradientExplicitSource::correct
                 const scalarField nu(turbModel.nu(), cells_);
 
                 gradPporous_ = -flowDir_*(D_*nu + I_*0.5*magUn)*magUn*length_;
-                break;
             }
             else
             {
@@ -307,6 +306,7 @@ void Foam::fv::directionalPressureGradientExplicitSource::correct
                 gradPporous_ =
                     - flowDir_*(D_*mu + I_*0.5*rho*magUn)*magUn*length_;
             }
+            break;
         }
         case pConstant:
         {
diff --git a/src/fvOptions/sources/derived/rotorDiskSource/rotorDiskSource.C b/src/fvOptions/sources/derived/rotorDiskSource/rotorDiskSource.C
index 129d5b1699..bf8594073b 100644
--- a/src/fvOptions/sources/derived/rotorDiskSource/rotorDiskSource.C
+++ b/src/fvOptions/sources/derived/rotorDiskSource/rotorDiskSource.C
@@ -376,7 +376,8 @@ void Foam::fv::rotorDiskSource::createCoordinateSystem()
             FatalErrorInFunction
                 << "Unknown geometryMode " << geometryModeTypeNames_[gm]
                 << ". Available geometry modes include "
-                << geometryModeTypeNames_ << exit(FatalError);
+                << geometryModeTypeNames_
+                << exit(FatalError);
         }
     }
 
diff --git a/src/mesh/snappyHexMesh/snappyHexMeshDriver/snappyLayerDriver.C b/src/mesh/snappyHexMesh/snappyHexMeshDriver/snappyLayerDriver.C
index a8ebbcd9ea..e24f9c5497 100644
--- a/src/mesh/snappyHexMesh/snappyHexMeshDriver/snappyLayerDriver.C
+++ b/src/mesh/snappyHexMesh/snappyHexMeshDriver/snappyLayerDriver.C
@@ -493,9 +493,22 @@ void Foam::snappyLayerDriver::handleNonStringConnected
     // warning from checkMesh. These faces cannot be extruded so
     // there is no need to even attempt it.
 
-List<extrudeMode> oldExtrudeStatus(extrudeStatus);
-OBJstream str(meshRefiner_.mesh().time().path()/"nonStringConnected.obj");
-Pout<< "Dumping string edges to " << str.name();
+    List<extrudeMode> oldExtrudeStatus;
+    autoPtr<OBJstream> str;
+    if (debug&meshRefinement::LAYERINFO)
+    {
+        oldExtrudeStatus = extrudeStatus;
+        str.reset
+        (
+            new OBJstream
+            (
+                meshRefiner_.mesh().time().path()
+               /"nonStringConnected.obj"
+            )
+        );
+        Pout<< "Dumping string edges to " << str().name();
+    }
+
 
     // 1) Local
     Map<label> nCommonPoints(100);
@@ -521,18 +534,24 @@ Pout<< "Dumping string edges to " << str.name();
 
     // 2) TDB. Other face remote
 
-forAll(extrudeStatus, pointi)
-{
-    if (extrudeStatus[pointi] != oldExtrudeStatus[pointi])
+
+
+    if (debug&meshRefinement::LAYERINFO)
     {
-        str.write(meshRefiner_.mesh().points()[pp.meshPoints()[pointi]]);
+        forAll(extrudeStatus, pointi)
+        {
+            if (extrudeStatus[pointi] != oldExtrudeStatus[pointi])
+            {
+                str().write
+                (
+                    meshRefiner_.mesh().points()[pp.meshPoints()[pointi]]
+                );
+            }
+        }
     }
 }
 
 
-}
-
-
 // No extrusion at non-manifold points.
 void Foam::snappyLayerDriver::handleNonManifolds
 (
diff --git a/src/meshTools/Make/files b/src/meshTools/Make/files
index b77d0bdbc9..f9af11d9be 100644
--- a/src/meshTools/Make/files
+++ b/src/meshTools/Make/files
@@ -25,6 +25,12 @@ $(edgeMeshFormats)/starcd/STARCDedgeFormatRunTime.C
 $(edgeMeshFormats)/vtk/VTKedgeFormat.C
 $(edgeMeshFormats)/vtk/VTKedgeFormatRunTime.C
 
+
+edgeMeshTools = $(em)/edgeMeshTools
+$(edgeMeshTools)/edgeMeshTools.C
+$(edgeMeshTools)/edgeMeshFeatureProximity.C
+
+
 $(em)/featureEdgeMesh/featureEdgeMesh.C
 
 eem = $(em)/extendedEdgeMesh
@@ -215,6 +221,8 @@ triSurface/triangleFuncs/triangleFuncs.C
 triSurface/surfaceFeatures/surfaceFeatures.C
 triSurface/triSurfaceLoader/triSurfaceLoader.C
 triSurface/triSurfaceTools/triSurfaceTools.C
+triSurface/triSurfaceTools/triSurfaceCloseness.C
+triSurface/triSurfaceTools/triSurfaceCurvature.C
 triSurface/triSurfaceTools/geompack/geompack.C
 triSurface/triSurfaceTools/pointToPointPlanarInterpolation.C
 
diff --git a/src/meshTools/edgeMesh/edgeMeshTools/edgeMeshFeatureProximity.C b/src/meshTools/edgeMesh/edgeMeshTools/edgeMeshFeatureProximity.C
new file mode 100644
index 0000000000..c5e9e883e7
--- /dev/null
+++ b/src/meshTools/edgeMesh/edgeMeshTools/edgeMeshFeatureProximity.C
@@ -0,0 +1,228 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2017 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "edgeMeshTools.H"
+
+#include "extendedEdgeMesh.H"
+#include "triSurface.H"
+#include "triSurfaceFields.H"
+#include "pointIndexHit.H"
+#include "MeshedSurface.H"
+#include "OFstream.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+static scalar calcProximityOfFeaturePoints
+(
+    const List<pointIndexHit>& hitList,
+    const scalar defaultCellSize
+)
+{
+    scalar minDist = defaultCellSize;
+
+    for
+    (
+        label hI1 = 0;
+        hI1 < hitList.size() - 1;
+        ++hI1
+    )
+    {
+        const pointIndexHit& pHit1 = hitList[hI1];
+
+        if (pHit1.hit())
+        {
+            for
+            (
+                label hI2 = hI1 + 1;
+                hI2 < hitList.size();
+                ++hI2
+            )
+            {
+                const pointIndexHit& pHit2 = hitList[hI2];
+
+                if (pHit2.hit())
+                {
+                    scalar curDist = mag(pHit1.hitPoint() - pHit2.hitPoint());
+
+                    minDist = min(curDist, minDist);
+                }
+            }
+        }
+    }
+
+    return minDist;
+}
+
+
+scalar calcProximityOfFeatureEdges
+(
+    const edgeMesh& emesh,
+    const List<pointIndexHit>& hitList,
+    const scalar defaultCellSize
+)
+{
+    scalar minDist = defaultCellSize;
+
+    for
+    (
+        label hI1 = 0;
+        hI1 < hitList.size() - 1;
+        ++hI1
+    )
+    {
+        const pointIndexHit& pHit1 = hitList[hI1];
+
+        if (pHit1.hit())
+        {
+            const edge& e1 = emesh.edges()[pHit1.index()];
+
+            for
+            (
+                label hI2 = hI1 + 1;
+                hI2 < hitList.size();
+                ++hI2
+            )
+            {
+                const pointIndexHit& pHit2 = hitList[hI2];
+
+                if (pHit2.hit())
+                {
+                    const edge& e2 = emesh.edges()[pHit2.index()];
+
+                    // Don't refine if the edges are connected to each other
+                    if (!e1.connects(e2))
+                    {
+                        scalar curDist =
+                            mag(pHit1.hitPoint() - pHit2.hitPoint());
+
+                        minDist = min(curDist, minDist);
+                    }
+                }
+            }
+        }
+    }
+
+    return minDist;
+}
+
+} // End namespace Foam
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+Foam::tmp<Foam::scalarField> Foam::edgeMeshTools::featureProximity
+(
+    const extendedEdgeMesh& emesh,
+    const triSurface& surf,
+    const scalar searchDistance
+)
+{
+    tmp<scalarField> tfld(new scalarField(surf.size(), searchDistance));
+    scalarField& featureProximity = tfld.ref();
+
+    Info<< "Extracting proximity of close feature points and "
+        << "edges to the surface" << endl;
+
+    forAll(surf, fI)
+    {
+        const triPointRef& tri = surf[fI].tri(surf.points());
+        const point& triCentre = tri.circumCentre();
+
+        const scalar radiusSqr = min
+        (
+            sqr(4*tri.circumRadius()),
+            sqr(searchDistance)
+        );
+
+        List<pointIndexHit> hitList;
+
+        emesh.allNearestFeatureEdges(triCentre, radiusSqr, hitList);
+
+        featureProximity[fI] =
+            calcProximityOfFeatureEdges
+            (
+                emesh,
+                hitList,
+                featureProximity[fI]
+            );
+
+        emesh.allNearestFeaturePoints(triCentre, radiusSqr, hitList);
+
+        featureProximity[fI] =
+            calcProximityOfFeaturePoints
+            (
+                hitList,
+                featureProximity[fI]
+            );
+    }
+
+    return tfld;
+}
+
+
+Foam::tmp<Foam::scalarField> Foam::edgeMeshTools::writeFeatureProximity
+(
+    const Time& runTime,
+    const word& basename,
+    const extendedEdgeMesh& emesh,
+    const triSurface& surf,
+    const scalar searchDistance
+)
+{
+    Info<< nl << "Extracting curvature of surface at the points."
+        << endl;
+
+
+    tmp<scalarField> tfld =
+        edgeMeshTools::featureProximity(emesh, surf, searchDistance);
+    scalarField& featureProximity = tfld.ref();
+
+    triSurfaceScalarField outputField
+    (
+        IOobject
+        (
+            basename + ".featureProximity",
+            runTime.constant(),
+            "triSurface",
+            runTime,
+            IOobject::NO_READ,
+            IOobject::NO_WRITE
+        ),
+        surf,
+        dimLength,
+        scalarField()
+    );
+
+    outputField.swap(featureProximity);
+    outputField.write();
+    outputField.swap(featureProximity);
+
+    return tfld;
+}
+
+// ************************************************************************* //
diff --git a/src/meshTools/edgeMesh/edgeMeshTools/edgeMeshTools.C b/src/meshTools/edgeMesh/edgeMeshTools/edgeMeshTools.C
new file mode 100644
index 0000000000..eac159b8e9
--- /dev/null
+++ b/src/meshTools/edgeMesh/edgeMeshTools/edgeMeshTools.C
@@ -0,0 +1,65 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2017 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "edgeMeshTools.H"
+
+#include "extendedFeatureEdgeMesh.H"
+#include "OFstream.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+void Foam::edgeMeshTools::writeStats
+(
+    Ostream& os,
+    const extendedFeatureEdgeMesh& emesh
+)
+{
+    os  << "Feature set:" << nl
+        << "    points : " << emesh.points().size() << nl
+        << "    of which" << nl
+        << "        convex             : "
+        << emesh.concaveStart() << nl
+        << "        concave            : "
+        << (emesh.mixedStart()-emesh.concaveStart()) << nl
+        << "        mixed              : "
+        << (emesh.nonFeatureStart()-emesh.mixedStart()) << nl
+        << "        non-feature        : "
+        << (emesh.points().size()-emesh.nonFeatureStart()) << nl
+        << "    edges  : " << emesh.edges().size() << nl
+        << "    of which" << nl
+        << "        external edges     : "
+        << emesh.internalStart() << nl
+        << "        internal edges     : "
+        << (emesh.flatStart()- emesh.internalStart()) << nl
+        << "        flat edges         : "
+        << (emesh.openStart()- emesh.flatStart()) << nl
+        << "        open edges         : "
+        << (emesh.multipleStart()- emesh.openStart()) << nl
+        << "        multiply connected : "
+        << (emesh.edges().size()- emesh.multipleStart()) << endl;
+}
+
+
+// ************************************************************************* //
diff --git a/src/meshTools/edgeMesh/edgeMeshTools/edgeMeshTools.H b/src/meshTools/edgeMesh/edgeMeshTools/edgeMeshTools.H
new file mode 100644
index 0000000000..aab9216f34
--- /dev/null
+++ b/src/meshTools/edgeMesh/edgeMeshTools/edgeMeshTools.H
@@ -0,0 +1,98 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2017 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Namespace
+    Foam::edgeMeshTools
+
+Description
+    Collection of static functions related to edgeMesh features.
+
+SourceFiles
+    edgeMeshTools.C
+    edgeMeshFeatureProximity.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef edgeMeshTools_H
+#define edgeMeshTools_H
+
+#include "tmp.H"
+#include "scalarField.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+class edgeMesh;
+class extendedEdgeMesh;
+class extendedFeatureEdgeMesh;
+class triSurface;
+class Time;
+class Ostream;
+
+/*---------------------------------------------------------------------------*\
+                      Namespace edgeMeshTools Declaration
+\*---------------------------------------------------------------------------*/
+
+namespace edgeMeshTools
+{
+    //- Write some information
+    void writeStats
+    (
+        Ostream& os,
+        const extendedFeatureEdgeMesh& emesh
+    );
+
+
+    //- Calculate proximity of the features to the surface
+    tmp<scalarField> featureProximity
+    (
+        const extendedEdgeMesh& emesh,
+        const triSurface& surf,
+        const scalar searchDistance
+    );
+
+
+    //- Calculate proximity of the features to the surface and write the field
+    tmp<scalarField> writeFeatureProximity
+    (
+        const Time& runTime,
+        const word& basename,
+        const extendedEdgeMesh& emesh,
+        const triSurface& surf,
+        const scalar searchDistance
+    );
+
+} // End namespace edgeMeshTools
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/meshTools/edgeMesh/extendedEdgeMesh/extendedEdgeMesh.C b/src/meshTools/edgeMesh/extendedEdgeMesh/extendedEdgeMesh.C
index 977cb457ca..24c13c3559 100644
--- a/src/meshTools/edgeMesh/extendedEdgeMesh/extendedEdgeMesh.C
+++ b/src/meshTools/edgeMesh/extendedEdgeMesh/extendedEdgeMesh.C
@@ -1277,13 +1277,15 @@ void Foam::extendedEdgeMesh::add(const extendedEdgeMesh& fem)
         );
     }
 
-    pointField newEdgeDirections(newEdgeI);
+    pointField newEdgeDirections
+    (
+        edgeDirections().size()
+      + fem.edgeDirections().size()
+    );
     newEdgeDirections.rmap(edgeDirections(), reverseEdgeMap);
     newEdgeDirections.rmap(fem.edgeDirections(), reverseFemEdgeMap);
 
 
-
-
     // Normals
     // ~~~~~~~
 
diff --git a/src/meshTools/edgeMesh/extendedEdgeMesh/extendedEdgeMesh.H b/src/meshTools/edgeMesh/extendedEdgeMesh/extendedEdgeMesh.H
index 914287df13..71a4b81779 100644
--- a/src/meshTools/edgeMesh/extendedEdgeMesh/extendedEdgeMesh.H
+++ b/src/meshTools/edgeMesh/extendedEdgeMesh/extendedEdgeMesh.H
@@ -94,23 +94,22 @@ public:
 
     enum pointStatus
     {
-        CONVEX,     // Fully convex point (w.r.t normals)
-        CONCAVE,    // Fully concave point
-        MIXED,      // A point surrounded by both convex and concave edges
-        NONFEATURE  // Not a feature point
+        CONVEX,     //!< Fully convex point (w.r.t normals)
+        CONCAVE,    //!< Fully concave point
+        MIXED,      //!< A point surrounded by both convex and concave edges
+        NONFEATURE  //!< Not a feature point
     };
 
     static const Foam::NamedEnum<pointStatus, 4> pointStatusNames_;
 
     enum edgeStatus
     {
-        EXTERNAL,   // "Convex" edge
-        INTERNAL,   // "Concave" edge
-        FLAT,       // Neither concave or convex, on a flat surface
-        OPEN,       // i.e. only connected to one face
-        MULTIPLE,   // Multiply connected (connected to more than two faces)
-        NONE        // Not a classified feature edge (consistency with
-                    // surfaceFeatures)
+        EXTERNAL,   //!< "Convex" edge
+        INTERNAL,   //!< "Concave" edge
+        FLAT,       //!< Neither concave or convex, on a flat surface
+        OPEN,       //!< Only connected to a single face
+        MULTIPLE,   //!< Multiply connected (connected to more than two faces)
+        NONE        //!< Unclassified (consistency with surfaceFeatures)
     };
 
     static const Foam::NamedEnum<edgeStatus, 6> edgeStatusNames_;
@@ -118,10 +117,10 @@ public:
     //- Normals point to the outside
     enum sideVolumeType
     {
-        INSIDE  = 0,  // mesh inside
-        OUTSIDE = 1,  // mesh outside
-        BOTH    = 2,  // e.g. a baffle
-        NEITHER = 3   // not sure when this may be used
+        INSIDE  = 0,  //!< mesh inside
+        OUTSIDE = 1,  //!< mesh outside
+        BOTH    = 2,  //!< e.g. a baffle
+        NEITHER = 3   //!< not sure when this may be used
     };
 
     static const Foam::NamedEnum<sideVolumeType, 4> sideVolumeTypeNames_;
diff --git a/src/meshTools/mappedPatches/mappedPolyPatch/mappedPatchBase.C b/src/meshTools/mappedPatches/mappedPolyPatch/mappedPatchBase.C
index 1972082d78..ac6be7983d 100644
--- a/src/meshTools/mappedPatches/mappedPolyPatch/mappedPatchBase.C
+++ b/src/meshTools/mappedPatches/mappedPolyPatch/mappedPatchBase.C
@@ -1070,7 +1070,7 @@ Foam::mappedPatchBase::mappedPatchBase
     {
         offsetMode_ = offsetModeNames_.read(dict.lookup("offsetMode"));
 
-        switch(offsetMode_)
+        switch (offsetMode_)
         {
             case UNIFORM:
             {
@@ -1109,7 +1109,7 @@ Foam::mappedPatchBase::mappedPatchBase
         (
             dict
         )   << "Please supply the offsetMode as one of "
-            << NamedEnum<offsetMode, 3>::words()
+            << offsetModeNames_
             << exit(FatalIOError);
     }
 }
diff --git a/src/meshTools/meshTools/meshToolsTemplates.C b/src/meshTools/meshTools/meshToolsTemplates.C
index 51d7e328ec..17dc152a45 100644
--- a/src/meshTools/meshTools/meshToolsTemplates.C
+++ b/src/meshTools/meshTools/meshToolsTemplates.C
@@ -49,7 +49,7 @@ void Foam::meshTools::writeOBJ
             }
         }
 
-        os << 'l';
+        os << 'f';
         forAll(f, fp)
         {
             os << ' ' << foamToObj[f[fp]]+1;
diff --git a/src/meshTools/triSurface/booleanOps/intersectedSurface/edgeSurface.C b/src/meshTools/triSurface/booleanOps/intersectedSurface/edgeSurface.C
index 87405317a2..8491d6dee1 100644
--- a/src/meshTools/triSurface/booleanOps/intersectedSurface/edgeSurface.C
+++ b/src/meshTools/triSurface/booleanOps/intersectedSurface/edgeSurface.C
@@ -27,56 +27,37 @@ License
 #include "triSurface.H"
 #include "surfaceIntersection.H"
 #include "meshTools.H"
-#include "OFstream.H"
+#include "OBJstream.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
 namespace Foam
 {
 defineTypeNameAndDebug(edgeSurface, 0);
-}
 
-
-// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
-
-// Write whole pointField and edges to stream
-void Foam::edgeSurface::writeOBJ
-(
-    const pointField& points,
-    const edgeList& edges,
-    Ostream& os
-)
+// file-scope
+// Write points in obj format
+static void writeObjPoints(const UList<point>& pts, Ostream& os)
 {
-    forAll(points, pointi)
+    forAll(pts, i)
     {
-        const point& pt = points[pointi];
-
-        os << "v " << pt.x() << ' ' << pt.y() << ' ' << pt.z() << endl;
-    }
-    forAll(edges, edgeI)
-    {
-        const edge& e = edges[edgeI];
-
-        os << "l " << e.start()+1 << ' ' << e.end()+1 << endl;
+        const point& pt = pts[i];
+        os << "v " << pt.x() << ' ' << pt.y() << ' ' << pt.z() << nl;
     }
 }
 
 
 // Write whole pointField and selected edges to stream
-void Foam::edgeSurface::writeOBJ
+void writeObjEdges
 (
-    const pointField& points,
+    const UList<point>& points,
     const edgeList& edges,
     const labelList& edgeLabels,
     Ostream& os
 )
 {
-    forAll(points, pointi)
-    {
-        const point& pt = points[pointi];
+    writeObjPoints(points, os);
 
-        os << "v " << pt.x() << ' ' << pt.y() << ' ' << pt.z() << endl;
-    }
     forAll(edgeLabels, i)
     {
         const edge& e = edges[edgeLabels[i]];
@@ -85,6 +66,10 @@ void Foam::edgeSurface::writeOBJ
     }
 }
 
+} // End namespace Foam
+
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 
 // Pointedges in edgeSurface indices only.
 void Foam::edgeSurface::calcPointEdges()
@@ -253,29 +238,16 @@ Foam::edgeSurface::edgeSurface
     }
 
 
-
-
     // Add intersection edges to faceEdges
     // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-    forAllConstIter(labelPairLookup, inter.facePairToEdge(), iter)
+    forAllConstIters(inter.facePairToEdgeId(), iter)
     {
+        // The faceId from the correct surface
+        const label facei = iter.key()[isFirstSurface ? 0 : 1];
+
         // Edge label in intersection
-        const label edgeI = iter();
-
-        // Get the face from the correct surface
-        const FixedList<label, 2>& twoFaces = iter.key();
-
-        label facei;
-
-        if (isFirstSurface)
-        {
-            facei = twoFaces[0];
-        }
-        else
-        {
-            facei = twoFaces[1];
-        }
+        const label edgeI = iter.object();
 
         // Store on face-edge addressing. (note: offset edge)
         allFaceEdges[facei].append(edgeI + nSurfaceEdges_);
@@ -312,18 +284,17 @@ Foam::edgeSurface::edgeSurface
                     << " to " << faceFName << endl;
 
                 OFstream fStream(faceFName);
-                writeOBJ(points_, edges_, fEdges, fStream);
+                writeObjEdges(points_, edges_, fEdges, fStream);
             }
         }
 
         Pout<< "edgeSurface : Dumping edges to edges.obj" << endl;
-        OFstream eStream("edges.obj");
-        writeOBJ(points_, edges_, eStream);
+        OBJstream("edges.obj").write(edges_, points_);
 
         Pout<< "edgeSurface : Dumping intersectionEdges to"
             << " intersectionEdges.obj" << endl;
-        OFstream intEdgesStream("intersectionEdges.obj");
 
+        OFstream intEdgesStream("intersectionEdges.obj");
         labelList edgeLabels(edges_.size() - nSurfaceEdges_);
 
         label i = 0;
@@ -332,7 +303,7 @@ Foam::edgeSurface::edgeSurface
             edgeLabels[i++] = edgeI;
         }
 
-        writeOBJ(points_, edges_, edgeLabels, intEdgesStream);
+        writeObjEdges(points_, edges_, edgeLabels, intEdgesStream);
     }
 }
 
diff --git a/src/meshTools/triSurface/booleanOps/intersectedSurface/edgeSurface.H b/src/meshTools/triSurface/booleanOps/intersectedSurface/edgeSurface.H
index d8564be949..76c83ee2ed 100644
--- a/src/meshTools/triSurface/booleanOps/intersectedSurface/edgeSurface.H
+++ b/src/meshTools/triSurface/booleanOps/intersectedSurface/edgeSurface.H
@@ -93,25 +93,12 @@ private:
         //- From face to our edges_
         labelListList faceEdges_;
 
-
         //- Constructed from above: pointEdges
         labelListList pointEdges_;
 
 
     // Private Member Functions
 
-        //- Dump edges in obj format
-        static void writeOBJ(const pointField&, const edgeList&, Ostream&);
-
-        //- Dump selected edges in obj format
-        static void writeOBJ
-        (
-            const pointField&,
-            const edgeList&,
-            const labelList&,
-            Ostream&
-        );
-
         //- Calculate pointEdges
         void calcPointEdges();
 
diff --git a/src/meshTools/triSurface/booleanOps/surfaceIntersection/surfaceIntersection.C b/src/meshTools/triSurface/booleanOps/surfaceIntersection/surfaceIntersection.C
index a98dd53e91..8c552335d4 100644
--- a/src/meshTools/triSurface/booleanOps/surfaceIntersection/surfaceIntersection.C
+++ b/src/meshTools/triSurface/booleanOps/surfaceIntersection/surfaceIntersection.C
@@ -3,7 +3,7 @@
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
     \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
-     \\/     M anipulation  | Copyright (C) 2015 OpenCFD Ltd.
+     \\/     M anipulation  | Copyright (C) 2015-2017 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -25,8 +25,9 @@ License
 
 #include "surfaceIntersection.H"
 #include "triSurfaceSearch.H"
-#include "OFstream.H"
+#include "OBJstream.H"
 #include "labelPairHashes.H"
+#include "PackedBoolList.H"
 #include "triSurface.H"
 #include "pointIndexHit.H"
 #include "mergePoints.H"
@@ -40,221 +41,205 @@ namespace Foam
 defineTypeNameAndDebug(surfaceIntersection, 0);
 }
 
+const Foam::Enum<Foam::surfaceIntersection::intersectionType>
+Foam::surfaceIntersection::selfIntersectionNames
+{
+    { intersectionType::SELF, "self" },
+    { intersectionType::SELF_REGION, "region" },
+    { intersectionType::NONE, "none" },
+};
+
 
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 
-// Checks if there exists a special topological situation that causes
-// edge and the face it hit not to be recognized.
-//
-// For now if the face shares a point with the edge
-bool Foam::surfaceIntersection::excludeEdgeHit
-(
-    const triSurface& surf,
-    const label edgeI,
-    const label facei,
-    const scalar
-)
+void Foam::surfaceIntersection::setOptions(const dictionary& dict)
 {
-    const triSurface::FaceType& f = surf.localFaces()[facei];
-    const edge& e = surf.edges()[edgeI];
-
-    forAll(f, fp)
-    {
-        if (f[0] == e.start() || f[0] == e.end())
-        {
-            return true;
-        }
-    }
-
-// {
-//        // Get edge vector
-//        vector eVec = e.vec(surf.localPoints());
-//        eVec /= mag(eVec) + VSMALL;
-//
-//        const labelList& eLabels = surf.faceEdges()[facei];
-//
-//        // Get edge vector of 0th edge of face
-//        vector e0Vec = surf.edges()[eLabels[0]].vec(surf.localPoints());
-//        e0Vec /= mag(e0Vec) + VSMALL;
-//
-//        vector n = e0Vec ^ eVec;
-//
-//        if (mag(n) < SMALL)
-//        {
-//            // e0 is aligned with e. Choose next edge of face.
-//            vector e1Vec = surf.edges()[eLabels[1]].vec(surf.localPoints());
-//            e1Vec /= mag(e1Vec) + VSMALL;
-//
-//            n = e1Vec ^ eVec;
-//
-//            if (mag(n) < SMALL)
-//            {
-//                // Problematic triangle. Two edges aligned with edgeI. Give
-//                // up.
-//                return true;
-//            }
-//        }
-//
-//        // Check if same as faceNormal
-//        if (mag(n & surf.faceNormals()[facei]) > 1-tol)
-//        {
-//
-//            Pout<< "edge:" << e << "  face:" << facei
-//                << "  e0Vec:" << e0Vec << "  n:" << n
-//                << "  normalComponent:" << (n & surf.faceNormals()[facei])
-//                << "  tol:" << tol << endl;
-//
-//            return true;
-//        }
-//        else
-//        {
-//            return false;
-//        }
-// }
-
-    return false;
+    dict.readIfPresent("tolerance",       tolerance_);
+    dict.readIfPresent("allowEdgeHits",   allowEdgeHits_);
+    dict.readIfPresent("snap",            snapToEnd_);
+    dict.readIfPresent("warnDegenerate",  warnDegenerate_);
 }
 
 
-//// Find intersection of plane with edges of hitFacei. Returns
-//// - edgeI
-//// - intersection point
-//Foam::pointIndexHit Foam::surfaceIntersection::faceEdgeIntersection
-//(
-//    const triSurface& surf,
-//    const label hitFacei,
-//
-//    const vector& n,
-//    const point& eStart,
-//    const point& eEnd
-//)
-//{
-//    pointIndexHit pInter;
-//
-//    const pointField& points = surf.points();
-//
-//    const triSurface::FaceType& f = surf.localFaces()[hitFacei];
-//
-//    // Plane for intersect test.
-//    plane pl(eStart, n);
-//
-//    forAll(f, fp)
-//    {
-//        label fp1 = f.fcIndex(fp);
-//
-//        const point& start = points[f[fp]];
-//        const point& end = points[f[fp1]];
-//
-//        vector eVec(end - start);
-//
-//        scalar s = pl.normalIntersect(start, eVec);
-//
-//        if (s < 0 || s > 1)
-//        {
-//            pInter.setPoint(start + s*eVec);
-//
-//            // Check if is correct one: orientation walking
-//            //  eStart - eEnd - hitPoint should be opposite n
-//            vector n2(triPointRef(start, end, pInter.hitPoint()).normal());
-//
-//            Pout<< "plane normal:" << n
-//                << "  start:" << start << "  end:" << end
-//                << "  hit at:" << pInter.hitPoint()
-//                << "  resulting normal:" << n2 << endl;
-//
-//            if ((n2 & n) < 0)
-//            {
-//                pInter.setHit();
-//
-//                // Find corresponding edge between f[fp] f[fp1]
-//                label edgeI =
-//                    meshTools::findEdge
-//                    (
-//                        surf.edges(),
-//                        surf.faceEdges()[hitFacei],
-//                        f[fp],
-//                        f[fp1]
-//                    );
-//
-//                pInter.setIndex(edgeI);
-//
-//                return pInter;
-//            }
-//        }
-//    }
-//
-//    FatalErrorInFunction
-//        << "Did not find intersection of plane " << pl
-//        << " with edges of face " << hitFacei << " verts:" << f
-//        << abort(FatalError);
-//
-//    return pInter;
-//}
-
-
 void Foam::surfaceIntersection::storeIntersection
 (
-    const bool isFirstSurf,
+    const enum intersectionType cutFrom,
     const labelList& facesA,
     const label faceB,
-    DynamicList<edge>& allCutEdges,
-    DynamicList<point>& allCutPoints
+    const UList<point>& allCutPoints,
+    const label cutPointId,
+    DynamicList<edge>& allCutEdges
 )
 {
+    // Our lookup for two faces - populate with faceB (invariant)
+    // Normally always have face from the first surface as first element
+    labelPair twoFaces(faceB, faceB);
+
     forAll(facesA, facesAI)
     {
-        label faceA = facesA[facesAI];
+        const label faceA = facesA[facesAI];
 
-        // Combine two faces. Always make sure the face from the first surface
-        // is element 0.
-        FixedList<label, 2> twoFaces;
-        if (isFirstSurf)
+        switch (cutFrom)
         {
-            twoFaces[0] = faceA;
-            twoFaces[1] = faceB;
-        }
-        else
-        {
-            twoFaces[0] = faceB;
-            twoFaces[1] = faceA;
-        }
-
-        labelPairLookup::const_iterator iter = facePairToVertex_.find(twoFaces);
-
-        if (iter == facePairToVertex_.end())
-        {
-            // New intersection. Store face-face intersection.
-            facePairToVertex_.insert(twoFaces, allCutPoints.size()-1);
-        }
-        else
-        {
-            // Second occurrence of surf1-surf2 intersection.
-            // Or rather the face on surf1 intersects a face on
-            // surface2 twice -> we found edge.
-
-            // Check whether perhaps degenerate
-            const point& prevHit = allCutPoints[*iter];
-            const point& thisHit = allCutPoints.last();
-
-            if (mag(prevHit - thisHit) < SMALL)
+            case surfaceIntersection::FIRST:
             {
-                WarningInFunction
-                    << "Encountered degenerate edge between face "
-                    << twoFaces[0] << " on first surface"
-                    << " and face " << twoFaces[1] << " on second surface"
-                    << endl
-                    << "Point on first surface:" << prevHit << endl
-                    << "Point on second surface:" << thisHit << endl
-                    << endl;
+                // faceA from 1st, faceB from 2nd
+                twoFaces.first() = faceA;
+                break;
+            }
+            case surfaceIntersection::SECOND:
+            {
+                // faceA from 2nd, faceB from 1st
+                twoFaces.second() = faceA;
+                break;
+            }
+            case surfaceIntersection::SELF:
+            case surfaceIntersection::SELF_REGION:
+            {
+                // Lookup should be commutativity - use sorted order
+                if (faceA < faceB)
+                {
+                    twoFaces.first()  = faceA;
+                    twoFaces.second() = faceB;
+                }
+                else
+                {
+                    twoFaces.first()  = faceB;
+                    twoFaces.second() = faceA;
+                }
+                break;
+            }
+
+            case surfaceIntersection::NONE:
+                return;
+                break;
+        }
+
+
+        // Get existing edge, or create a null edge (with -1)
+        edge& thisEdge = facePairToEdge_(twoFaces);
+        const label pointCount = thisEdge.count();
+
+        if (pointCount == 0)
+        {
+            // First intersection of the faces - record it.
+            thisEdge.insert(cutPointId);
+
+            if (debug & 4)
+            {
+                Pout<< "intersect faces " << twoFaces
+                    << " point-1: " << cutPointId << " = "
+                    << allCutPoints[cutPointId] << endl;
+            }
+            continue;
+        }
+        else if (pointCount == 2)
+        {
+            // This occurs for ugly surfaces with shards that result in multiple
+            // cuts very near a snapped end point.
+            if (debug & 4)
+            {
+                Pout<< "suppressed double intersection " << twoFaces
+                    << thisEdge << endl;
+            }
+            continue;
+        }
+
+        if (thisEdge.insert(cutPointId))
+        {
+            // Second intersection of the faces - this is an edge,
+            // with special treatment:
+            // - avoid duplicate points: addressed by the insert() above
+            // - avoid degenerate lengths
+            // - avoid duplicate edges - can occur with really dirty geometry
+
+            if (edgeToId_.found(thisEdge))
+            {
+                // Already have this edgeId, but not for this intersection.
+                thisEdge.sort();
+                if (facePairToEdge_.insert(twoFaces, thisEdge))
+                {
+                    if (debug & 4)
+                    {
+                        Pout<< "reuse edge - faces " << twoFaces << " edge#"
+                            << edgeToId_[thisEdge] << " edge " << thisEdge
+                            << " = " << thisEdge.line(allCutPoints)
+                            << endl;
+                    }
+                }
+            }
+            else if (thisEdge.mag(allCutPoints) < SMALL)
+            {
+                // Degenerate length
+                // - eg, end snapping was disabled or somehow failed.
+
+                // Don't normally emit warnings, since these also arise for
+                // manifold connections. For example,
+                //
+                //   e1|  /e2
+                //     | /
+                //     |/
+                // ----.---- plane
+                //
+                // The plane is correctly pierced at the '.' by both edge-1
+                // and edge-2, which belong to the same originating face.
+
+                // Filter/merge away the extraneous points later.
+                if (warnDegenerate_ > 0)
+                {
+                    --warnDegenerate_;
+                    WarningInFunction
+                        << "Degenerate edge between faces " << twoFaces
+                        << " on 1st/2nd surface with points "
+                        << thisEdge.line(allCutPoints)
+                        << endl;
+                }
+                else if (debug & 4)
+                {
+                    Pout<< "degenerate edge face-pair " << twoFaces << " "
+                        << thisEdge[0] << " point " << allCutPoints[thisEdge[0]]
+                        << endl;
+                }
+
+                // This is a failed edge - undo this second interaction
+                thisEdge.erase(cutPointId);
             }
             else
             {
-                allCutEdges.append(edge(*iter, allCutPoints.size()-1));
+                // This is a new edge.
+                const label edgeId = allCutEdges.size();
 
-                // Remember face on surf
-                facePairToEdge_.insert(twoFaces, allCutEdges.size()-1);
+                if (facePairToEdgeId_.insert(twoFaces, edgeId))
+                {
+                    // Record complete (line) intersection of two faces
+                    thisEdge.sort();
+                    edgeToId_.insert(thisEdge, edgeId);
+                    allCutEdges.append(thisEdge);
+
+                    if (debug & 4)
+                    {
+                        Pout<< "create edge - faces " << twoFaces << " edge#"
+                            << edgeId << " edge " << thisEdge
+                            << " = " << thisEdge.line(allCutPoints)
+                            << endl;
+                    }
+                }
+                else
+                {
+                    // Faces already had an intersection
+                    // This should not fail, but for safety.
+                    Info<<"WARN " << twoFaces
+                        << " already intersected= " << thisEdge << endl;
+                    thisEdge.erase(cutPointId);
+                }
             }
         }
+        else
+        {
+            // Duplicate point - usually zero-length edge from snapping
+            // - can discard this face/face interaction entirely
+            facePairToEdge_.erase(twoFaces);
+        }
     }
 }
 
@@ -274,17 +259,16 @@ void Foam::surfaceIntersection::classifyHit
     const triSurface& surf1,
     const scalarField& surf1PointTol,
     const triSurface& surf2,
-    const bool isFirstSurf,
+    const enum intersectionType cutFrom,
     const label edgeI,
-    const scalar tolDim,
     const pointIndexHit& pHit,
 
-    DynamicList<edge>& allCutEdges,
     DynamicList<point>& allCutPoints,
+    DynamicList<edge>& allCutEdges,
     List<DynamicList<label>>& surfEdgeCuts
 )
 {
-    const edge& e = surf1.edges()[edgeI];
+    const edge& e1 = surf1.edges()[edgeI];
 
     const labelList& facesA = surf1.edgeFaces()[edgeI];
 
@@ -294,6 +278,7 @@ void Foam::surfaceIntersection::classifyHit
     // Classify point on surface2
 
     const triSurface::FaceType& f2 = surf2.localFaces()[surf2Facei];
+    const pointField& surf1Pts = surf1.localPoints();
     const pointField& surf2Pts = surf2.localPoints();
 
     label nearType, nearLabel;
@@ -301,14 +286,14 @@ void Foam::surfaceIntersection::classifyHit
     f2.nearestPointClassify(pHit.hitPoint(), surf2Pts, nearType, nearLabel);
 
     // Classify points on edge of surface1
-    label edgeEnd =
+    const label edgeEnd =
         classify
         (
-            surf1PointTol[e.start()],
-            surf1PointTol[e.end()],
+            surf1PointTol[e1.start()],
+            surf1PointTol[e1.end()],
             pHit.hitPoint(),
-            e,
-            surf1.localPoints()
+            e1,
+            surf1Pts
         );
 
     if (nearType == triPointRef::POINT)
@@ -318,37 +303,87 @@ void Foam::surfaceIntersection::classifyHit
             // 1. Point hits point. Do nothing.
             if (debug & 2)
             {
-                Pout<< pHit.hitPoint() << " is surf1:"
-                    << " end point of edge " << e
+                Pout<< "hit-type[1] " << pHit.hitPoint() << " is surf1:"
+                    << " end point of edge[" << edgeI << "] " << e1
+                    << "==" << e1.line(surf1Pts)
                     << " surf2: vertex " << f2[nearLabel]
-                    << " coord:" << surf2Pts[f2[nearLabel]] << endl;
+                    << " coord:" << surf2Pts[f2[nearLabel]]
+                    << " - suppressed" << endl;
             }
         }
         else
         {
             // 2. Edge hits point. Cut edge with new point.
-            if (debug & 2)
+            label cutPointId = -1;
+            const label nearVert = f2[nearLabel];
+
+            // For self-intersection, we have tolerances for each point
+            // (surf2 is actually surf1) so we shift the hit to coincide
+            // identically.
+            if
+            (
+                cutFrom == surfaceIntersection::SELF
+             || cutFrom == surfaceIntersection::SELF_REGION
+            )
             {
-                Pout<< pHit.hitPoint() << " is surf1:"
-                    << " somewhere on edge " << e
-                    << " surf2: vertex " << f2[nearLabel]
-                    << " coord:" << surf2Pts[f2[nearLabel]] << endl;
+                const point& nearPt = surf1Pts[nearVert];
+
+                if
+                (
+                    mag(pHit.hitPoint() - nearPt)
+                  < surf1PointTol[nearVert]
+                )
+                {
+                    cutPointId = allCutPoints.size();
+
+                    if (snapToEnd_)
+                    {
+                        if (snappedEnds_.insert(nearVert, cutPointId))
+                        {
+                            // Initial snap
+                            allCutPoints.append(nearPt);
+                        }
+                        else
+                        {
+                            // Already snapped this point.
+                            cutPointId = snappedEnds_[nearVert];
+                        }
+                    }
+                    else
+                    {
+                        allCutPoints.append(nearPt);
+                    }
+                }
             }
 
-            allCutPoints.append(pHit.hitPoint());
-            surfEdgeCuts[edgeI].append(allCutPoints.size()-1);
+            if (debug & 2)
+            {
+                Pout<< "hit-type[2] " << pHit.hitPoint() << " is surf1:"
+                    << " from edge[" << edgeI << "] " << e1
+                    << " surf2: vertex " << f2[nearLabel]
+                    << " coord:" << surf2Pts[f2[nearLabel]]
+                    << " - "
+                    << (cutPointId >= 0 ? "snapped" : "stored") << endl;
+            }
+
+            if (cutPointId == -1)
+            {
+                cutPointId = allCutPoints.size();
+                allCutPoints.append(pHit.hitPoint());
+            }
+            surfEdgeCuts[edgeI].append(cutPointId);
 
             const labelList& facesB = surf2.pointFaces()[f2[nearLabel]];
-
             forAll(facesB, faceBI)
             {
                 storeIntersection
                 (
-                    isFirstSurf,
+                    cutFrom,
                     facesA,
                     facesB[faceBI],
-                    allCutEdges,
-                    allCutPoints
+                    allCutPoints,
+                    cutPointId,
+                    allCutEdges
                 );
             }
         }
@@ -357,18 +392,123 @@ void Foam::surfaceIntersection::classifyHit
     {
         if (edgeEnd >= 0)
         {
-            // 3. Point hits edge. Do nothing on this side. Reverse
-            // is handled by 2 (edge hits point)
-            label edge2I = getEdge(surf2, surf2Facei, nearLabel);
-            const edge& e2 = surf2.edges()[edge2I];
+            // 3. Point hits edge.
+            // Normally do nothing on this side since the reverse
+            // (edge hits point) is handled by 2.
+            // However, if the surfaces are separated by a minor gap,
+            // the end-point of a tolerance-extended edge can intersect another
+            // edge without itself being intersected by an edge.
 
-            if (debug&2)
+            const label edge2I = getEdge(surf2, surf2Facei, nearLabel);
+            const edge& e2 = surf2.edges()[edge2I];
+            const label nearVert = e1[edgeEnd];
+
+            label cutPointId = -1;
+
+            // Storage treatment
+            // =0: nothing/ignore
+            // >0: store point/edge-cut. Attempt to create new edge.
+            // <0: store point/edge-cut only
+            int handling = (allowEdgeHits_ ? 1 : 0);
+            if
+            (
+                allowEdgeHits_
+             &&
+                (
+                    cutFrom == surfaceIntersection::SELF
+                 || cutFrom == surfaceIntersection::SELF_REGION
+                )
+            )
             {
-                Pout<< pHit.hitPoint() << " is surf1:"
-                    << " end point of edge " << e
-                    << " surf2: edge " << e2
-                    << " coords:" << surf2Pts[e2.start()]
-                    << surf2Pts[e2.end()] << endl;
+                // The edge-edge intersection is hashed as an 'edge' to
+                // exploit the commutative lookup.
+                // Ie, only do the cut once
+                const edge intersect(edgeI, edge2I);
+
+                if (e2.found(nearVert))
+                {
+                    // Actually the same as #1 above, but missed due to
+                    // tolerancing
+                    handling = 0; // suppress
+                }
+                else if (edgeEdgeIntersection_.insert(intersect))
+                {
+                    const point& nearPt = surf1Pts[nearVert];
+
+                    if
+                    (
+                        mag(pHit.hitPoint() - nearPt)
+                      < surf1PointTol[nearVert]
+                    )
+                    {
+                        cutPointId = allCutPoints.size();
+
+                        if (snapToEnd_)
+                        {
+                            if (snappedEnds_.insert(nearVert, cutPointId))
+                            {
+                                // Initial snap
+                                allCutPoints.append(nearPt);
+                            }
+                            else
+                            {
+                                // Already snapped this point.
+                                cutPointId = snappedEnds_[nearVert];
+                                handling = 2;  // cached
+                            }
+                        }
+                        else
+                        {
+                            allCutPoints.append(nearPt);
+                        }
+                    }
+                }
+                else
+                {
+                    handling = 0; // ignore - already did this interaction
+                }
+            }
+
+            if (debug & 2)
+            {
+                Pout<< "hit-type[3] " << pHit.hitPoint() << " is surf1:"
+                    << " end point of edge[" << edgeI << "] " << e1
+                    << "==" << e1.line(surf1Pts)
+                    << " surf2: edge[" << edge2I << "] " << e2
+                    << " coords:" << e2.line(surf2Pts)
+                    << " - "
+                    << (
+                           handling > 1
+                         ? "cached" : handling
+                         ? "stored" : "suppressed"
+                       ) << endl;
+            }
+
+            if (handling)
+            {
+                if (cutPointId == -1)
+                {
+                    cutPointId = allCutPoints.size();
+                    allCutPoints.append(pHit.hitPoint());
+                }
+                surfEdgeCuts[edgeI].append(cutPointId);
+            }
+
+            if (handling > 0)
+            {
+                const labelList& facesB = surf2.edgeFaces()[edge2I];
+                forAll(facesB, faceBI)
+                {
+                    storeIntersection
+                    (
+                        cutFrom,
+                        facesA,
+                        facesB[faceBI],
+                        allCutPoints,
+                        cutPointId,
+                        allCutEdges
+                    );
+                }
             }
         }
         else
@@ -379,42 +519,141 @@ void Foam::surfaceIntersection::classifyHit
             // doing the surf2 with surf1 intersection but these
             // are merged later on)
 
-            label edge2I = getEdge(surf2, surf2Facei, nearLabel);
-            const edge& e2 = surf2.edges()[edge2I];
+            // edge hits all faces on surf2 connected to the edge
+            //
+            // The edge-edge intersection is symmetric, store only once.
+            // - When intersecting two surfaces, note which edges are cut each
+            //   time, but only create an edge from the first pass.
+            // - For self-intersection, it is slightly trickier if we don't
+            //   want too many duplicate points.
 
-            if (debug&2)
+            const label edge2I = getEdge(surf2, surf2Facei, nearLabel);
+            const edge& e2 = surf2.edges()[edge2I];
+            label cutPointId = -1;
+
+            // Storage treatment
+            // =0: nothing/ignore
+            // >0: store point/edge-cut. Attempt to create new edge.
+            // <0: store point/edge-cut only
+            int handling = 0;
+            switch (cutFrom)
             {
-                Pout<< pHit.hitPoint() << " is surf1:"
-                    << " somewhere on edge " << e
-                    << " surf2: edge " << e2
-                    << " coords:" << surf2Pts[e2.start()]
-                    << surf2Pts[e2.end()] << endl;
+                case surfaceIntersection::FIRST:
+                {
+                    handling = 1;
+                    break;
+                }
+                case surfaceIntersection::SECOND:
+                {
+                    handling = -1;
+                    break;
+                }
+                case surfaceIntersection::SELF:
+                case surfaceIntersection::SELF_REGION:
+                {
+                    // The edge-edge intersection is hashed as an 'edge' to
+                    // exploit the commutative lookup.
+                    // Ie, only do the cut once
+                    const edge intersect(edgeI, edge2I);
+
+                    if (edgeEdgeIntersection_.insert(intersect))
+                    {
+                        handling = 1;
+                        forAll(e1, edgepti)
+                        {
+                            const label endId = e1[edgepti];
+                            const point& nearPt = surf1Pts[endId];
+
+                            if
+                            (
+                                mag(pHit.hitPoint() - nearPt)
+                              < surf1PointTol[endId]
+                            )
+                            {
+                                cutPointId = allCutPoints.size();
+
+                                if (snapToEnd_)
+                                {
+                                    if (snappedEnds_.insert(endId, cutPointId))
+                                    {
+                                        // First time with this end-point
+                                        allCutPoints.append(nearPt);
+                                    }
+                                    else
+                                    {
+                                        // Already seen this end point
+                                        cutPointId = snappedEnds_[endId];
+                                        handling = 2;  // cached
+                                    }
+                                }
+                                else
+                                {
+                                    allCutPoints.append(nearPt);
+                                }
+
+                                break;
+                            }
+                        }
+                    }
+
+                    break;
+                }
+
+                case surfaceIntersection::NONE:
+                    return;
+                    break;
             }
 
-            allCutPoints.append(pHit.hitPoint());
-            surfEdgeCuts[edgeI].append(allCutPoints.size()-1);
-
-            // edge hits all faces on surf2 connected to the edge
-
-            if (isFirstSurf)
+            if (debug & 2)
             {
-                // edge-edge intersection is symmetric, store only
-                // once.
-                // edge hits all faces on surf2 connected to the
-                // edge
+                Pout<< "hit-type[4] " << pHit.hitPoint() << " is surf1:"
+                    << " from edge[" << edgeI << "] " << e1
+                    << "==" << e1.line(surf1Pts)
+                    << " surf2: edge[" << edge2I << "] " << e2
+                    << " coords:" << e2.line(surf2Pts)
+                    << " - "
+                    << (
+                         handling < 0
+                       ? "cut-point" : handling
+                       ? "stored" : "suppressed"
+                       )
+                    << endl;
+            }
+
+            if (handling)
+            {
+                if (cutPointId == -1)
+                {
+                    cutPointId = allCutPoints.size();
+                    allCutPoints.append(pHit.hitPoint());
+                }
+                surfEdgeCuts[edgeI].append(cutPointId);
+            }
+
+            if (handling)
+            {
+                const vector eVec = e1.unitVec(surf1Pts);
 
                 const labelList& facesB = surf2.edgeFaces()[edge2I];
-
                 forAll(facesB, faceBI)
                 {
-                    storeIntersection
+                    // Intersecting edge should be non-coplanar with face
+                    if
                     (
-                        isFirstSurf,
-                        facesA,
-                        facesB[faceBI],
-                        allCutEdges,
-                        allCutPoints
-                    );
+                        mag((surf2.faceNormals()[facesB[faceBI]] & eVec))
+                      > 0.01
+                    )
+                    {
+                        storeIntersection
+                        (
+                            cutFrom,
+                            facesA,
+                            facesB[faceBI],
+                            allCutPoints,
+                            cutPointId,
+                            allCutEdges
+                        );
+                    }
                 }
             }
         }
@@ -425,131 +664,117 @@ void Foam::surfaceIntersection::classifyHit
         {
             // 5. Point hits face. Do what? Introduce
             // point & triangulation in face?
-            if (debug&2)
-            {
-                Pout<< pHit.hitPoint() << " is surf1:"
-                    << " end point of edge " << e
-                    << " surf2: face " << surf2Facei
-                    << endl;
-            }
 
-            //
             // Look exactly at what side (of surf2) edge is. Leave out ones on
             // inside of surf2 (i.e. on opposite side of normal)
-            //
 
-            // Vertex on/near surf2
-            label nearVert = -1;
+            // Vertex on/near surf2; vertex away from surf2
+            // otherVert on outside of surf2
+            const label nearVert  = (edgeEnd == 0 ? e1.start() : e1.end());
+            const label otherVert = (edgeEnd == 0 ? e1.end() : e1.start());
 
-            if (edgeEnd == 0)
-            {
-                nearVert = e.start();
-            }
-            else
-            {
-                nearVert = e.end();
-            }
+            const point& nearPt  = surf1Pts[nearVert];
+            const point& otherPt = surf1Pts[otherVert];
 
-            const point& nearPt = surf1.localPoints()[nearVert];
-
-            // Vertex away from surf2
-            label otherVert = e.otherVertex(nearVert);
-
-            const point& otherPt = surf1.localPoints()[otherVert];
-
-
-            if (debug)
-            {
-                Pout
-                    << pHit.hitPoint() << " is surf1:"
-                    << " end point of edge " << e << " coord:"
-                    << surf1.localPoints()[nearVert]
-                    << " surf2: face " << surf2Facei << endl;
-            }
-
-            vector eVec = otherPt - nearPt;
+            const vector eVec = otherPt - nearPt;
 
             if ((surf2.faceNormals()[surf2Facei] & eVec) > 0)
             {
-                // otherVert on outside of surf2
+                // map to nearVert
+                // Reclassify as normal edge-face pierce (see below)
+                bool cached = false;
 
-                // Shift hitPoint a bit along edge.
-                //point hitPt = nearPt + 0.1*eVec;
-                point hitPt = nearPt;
-
-                if (debug&2)
+                label cutPointId = allCutPoints.size();
+                if (snapToEnd_)
                 {
-                    Pout<< "Shifted " << pHit.hitPoint()
-                        << " to " << hitPt
-                        << " along edge:" << e
-                        << " coords:" << surf1.localPoints()[e.start()]
-                        << surf1.localPoints()[e.end()] << endl;
+                    if (snappedEnds_.insert(nearVert, cutPointId))
+                    {
+                        // First time with this end-point
+                        allCutPoints.append(nearPt);
+                    }
+                    else
+                    {
+                        // Already seen this end point
+                        cutPointId = snappedEnds_[nearVert];
+                        cached = true;
+                    }
+                }
+                else
+                {
+                    allCutPoints.append(nearPt);
                 }
 
-                // Reclassify as normal edge-face pierce (see below)
+                surfEdgeCuts[edgeI].append(cutPointId);
 
-                allCutPoints.append(hitPt);
-                surfEdgeCuts[edgeI].append(allCutPoints.size()-1);
+                if (debug & 2)
+                {
+                    Pout<< "hit-type[5] " << pHit.hitPoint()
+                        << " shifted to " << nearPt
+                        << " from edge[" << edgeI << "] " << e1
+                        << "==" << e1.line(surf1Pts)
+                        << " hits surf2 face[" << surf2Facei << "]"
+                        << " - "
+                        << (cached ? "cached" : "stored") << endl;
+                }
 
                 // edge hits single face only
                 storeIntersection
                 (
-                    isFirstSurf,
+                    cutFrom,
                     facesA,
                     surf2Facei,
-                    allCutEdges,
-                    allCutPoints
+                    allCutPoints,
+                    cutPointId,
+                    allCutEdges
                 );
             }
             else
             {
-                if (debug&2)
+                if (debug & 2)
                 {
-                    Pout<< "Discarding " << pHit.hitPoint()
-                        << " since edge " << e << " on inside of surf2."
-                        << " surf2 normal:" << surf2.faceNormals()[surf2Facei]
-                        << endl;
+                    Pout<< "hit-type[5] " << pHit.hitPoint()
+                        << " from edge[" << edgeI << "] " << e1
+                        << " hits inside of surf2 face[" << surf2Facei << "]"
+                        << " - discarded" << endl;
                 }
             }
         }
         else
         {
             // 6. Edge pierces face. 'Normal' situation.
-            if (debug&2)
+            if (debug & 2)
             {
-                Pout<< pHit.hitPoint() << " is surf1:"
-                    << " somewhere on edge " << e
-                    << " surf2: face " << surf2Facei
-                    << endl;
+                Pout<< "hit-type[6] " << pHit.hitPoint()
+                    << " from edge[" << edgeI << "] " << e1
+                    << "==" << e1.line(surf1Pts)
+                    << " hits surf2 face[" << surf2Facei << "]"
+                    << " - stored" << endl;
             }
 
-            // edgeI intersects surf2. Store point.
+            const label cutPointId = allCutPoints.size();
             allCutPoints.append(pHit.hitPoint());
-            surfEdgeCuts[edgeI].append(allCutPoints.size()-1);
+            surfEdgeCuts[edgeI].append(cutPointId);
 
             // edge hits single face only
             storeIntersection
             (
-                isFirstSurf,
+                cutFrom,
                 facesA,
                 surf2Facei,
-                allCutEdges,
-                allCutPoints
+                allCutPoints,
+                cutPointId,
+                allCutEdges
             );
         }
     }
-    if (debug&2)
-    {
-        Pout<< endl;
-    }
 }
 
 
 // Cut all edges of surf1 with surf2. Sets
 // - cutPoints          : coordinates of cutPoints
 // - cutEdges           : newly created edges between cutPoints
-// - facePairToVertex   : hash from face1I and face2I to cutPoint
-// - facePairToEdge     : hash from face1I and face2I to cutEdge
+// - facePairToVertex   : hash from face1I and face2I to edge
+// - facePairToEdgeId   : hash from face1I and face2I to index in cutEdge
 // - surfEdgeCuts       : gives for each edge the cutPoints
 //                        (in order from start to end)
 //
@@ -557,15 +782,14 @@ void Foam::surfaceIntersection::doCutEdges
 (
     const triSurface& surf1,
     const triSurfaceSearch& querySurf2,
-    const bool isFirstSurf,
-    const bool isSelfIntersection,
+    const enum intersectionType cutFrom,
 
-    DynamicList<edge>& allCutEdges,
     DynamicList<point>& allCutPoints,
+    DynamicList<edge>& allCutEdges,
     List<DynamicList<label>>& surfEdgeCuts
 )
 {
-    scalar oldTol = intersection::setPlanarTol(1e-3);
+    const scalar oldTol = intersection::setPlanarTol(tolerance_);
 
     const pointField& surf1Pts = surf1.localPoints();
 
@@ -574,152 +798,289 @@ void Foam::surfaceIntersection::doCutEdges
 
     forAll(surf1PointTol, pointi)
     {
-        surf1PointTol[pointi] =
-            intersection::planarTol()
-          * minEdgeLen(surf1, pointi);
+        surf1PointTol[pointi] = tolerance_ * minEdgeLen(surf1, pointi);
     }
 
-    const triSurface& surf2 = querySurf2.surface();
+    const indexedOctree<treeDataPrimitivePatch<triSurface>>& searchTree
+        = querySurf2.tree();
 
-    forAll(surf1.edges(), edgeI)
+    if
+    (
+        cutFrom == surfaceIntersection::SELF
+     || cutFrom == surfaceIntersection::SELF_REGION
+    )
     {
-        const edge& e = surf1.edges()[edgeI];
+        // An edge may intersect multiple faces
+        // - mask out faces that have already been hit before trying again
+        // - never intersect with faces attached to the edge itself
+        DynamicList<label> maskFaces(32);
 
-        point pStart = surf1Pts[e.start()];
-        const point& pEnd = surf1Pts[e.end()];
+        // Optionally prevent intersection within a single region.
+        // Like self-intersect, but only if regions are different
+        PackedBoolList maskRegions(32);
 
-        const point tolVec = intersection::planarTol()*(pEnd-pStart);
-        const scalar tolDim = mag(tolVec);
+        treeDataTriSurface::findAllIntersectOp
+            allIntersectOp(searchTree, maskFaces);
 
-        bool doTrack = false;
-        do
+        forAll(surf1.edges(), edgeI)
         {
-            pointIndexHit pHit = querySurf2.tree().findLine(pStart, pEnd);
+            const edge& e = surf1.edges()[edgeI];
+            const vector edgeVec = e.vec(surf1Pts);
 
-            if (pHit.hit())
+            // Extend start/end by 1/2 tolerance - ensures cleaner cutting
+            const point ptStart =
+                surf1Pts[e.start()] - 0.5*surf1PointTol[e.start()]*edgeVec;
+            const point ptEnd =
+                surf1Pts[e.end()]   + 0.5*surf1PointTol[e.end()]*edgeVec;
+
+            maskRegions.clear();
+            if (cutFrom == surfaceIntersection::SELF_REGION)
             {
-                if (isSelfIntersection)
+                for (auto& facei : surf1.edgeFaces()[edgeI])
                 {
-                    // Skip all intersections which are hit at endpoints of
-                    // edge.
-                    // Problem is that if faces are almost coincident the
-                    // intersection point will be calculated quite incorrectly
-                    // The error might easily be larger than 1% of the edge
-                    // length.
-                    // So what we do here is to exclude hit faces if our edge
-                    // is in their plane and they share a point with the edge.
-
-                    // Label of face on surface2 edgeI intersected
-                    label hitFacei = pHit.index();
-
-                    if
-                    (
-                        !excludeEdgeHit
-                        (
-                            surf1,
-                            edgeI,
-                            hitFacei,
-                            0.1         // 1-cos of angle between normals
-                        )
-                    )
-                    {
-                        // Classify point on surface1
-                        label edgeEnd = classify
-                        (
-                            surf1PointTol[e.start()],
-                            surf1PointTol[e.end()],
-                            pHit.hitPoint(),
-                            e,
-                            surf1Pts
-                        );
-
-                        if (edgeEnd < 0)
-                        {
-                            if (debug)
-                            {
-                                Pout<< "edge:" << edgeI << " vertices:" << e
-                                    << "  start:" << surf1Pts[e.start()]
-                                    << "  end:" << surf1Pts[e.end()]
-                                    << "  hit:" << pHit.hitPoint()
-                                    << "  tolDim:" << tolDim
-                                    << "  planarTol:"
-                                    << intersection::planarTol()
-                                    << endl;
-                            }
-                            allCutPoints.append(pHit.hitPoint());
-                            surfEdgeCuts[edgeI].append(allCutPoints.size()-1);
-                        }
-                    }
-                }
-                else
-                {
-                    classifyHit
-                    (
-                        surf1,
-                        surf1PointTol,
-                        surf2,
-                        isFirstSurf,
-                        edgeI,
-                        tolDim,
-                        pHit,
-
-                        allCutEdges,
-                        allCutPoints,
-                        surfEdgeCuts
-                    );
-                }
-
-                if (mag(pHit.hitPoint() - pEnd) < tolDim)
-                {
-                    doTrack = false;
-                }
-                else
-                {
-                    pStart = pHit.hitPoint() + tolVec;
-
-                    doTrack = true;
+                    maskRegions.set(surf1[facei].region());
                 }
             }
-            else
+
+            // Never intersect with faces attached directly to the edge itself,
+            // nor with faces attached to its end points. This mask contains
+            // some duplicates, but filtering them out is less efficient.
+            maskFaces = surf1.pointFaces()[e.start()];
+            maskFaces.append(surf1.pointFaces()[e.end()]);
+
+            while (true)
             {
-                doTrack = false;
+                pointIndexHit pHit = searchTree.findLine
+                (
+                    ptStart,
+                    ptEnd,
+                    allIntersectOp
+                );
+
+                if (!pHit.hit())
+                {
+                    break;
+                }
+
+                maskFaces.append(pHit.index());
+
+                if (maskRegions[surf1[pHit.index()].region()])
+                {
+                    continue;
+                }
+
+                classifyHit
+                (
+                    surf1,
+                    surf1PointTol,
+                    surf1,
+                    cutFrom,
+                    edgeI,
+                    pHit,
+
+                    allCutPoints,
+                    allCutEdges,
+                    surfEdgeCuts
+                );
             }
         }
-        while (doTrack);
     }
+    else
+    {
+        const triSurface& surf2 = querySurf2.surface();
+
+        forAll(surf1.edges(), edgeI)
+        {
+            const edge& e = surf1.edges()[edgeI];
+            const vector edgeVec = e.vec(surf1Pts);
+
+            const point tolVec = intersection::planarTol()*(edgeVec);
+            const scalar tolDim = mag(tolVec);
+
+            // Extend start/end by 1/2 tolerance - ensures cleaner cutting
+            point ptStart =
+                surf1Pts[e.start()] - 0.5*surf1PointTol[e.start()]*edgeVec;
+            const point ptEnd =
+                surf1Pts[e.end()]   + 0.5*surf1PointTol[e.end()]*edgeVec;
+
+            bool doTrack = false;
+            do
+            {
+                pointIndexHit pHit = searchTree.findLine(ptStart, ptEnd);
+
+                if (!pHit.hit())
+                {
+                    break;
+                }
+
+                classifyHit
+                (
+                    surf1,
+                    surf1PointTol,
+                    surf2,
+                    cutFrom,
+                    edgeI,
+                    pHit,
+
+                    allCutPoints,
+                    allCutEdges,
+                    surfEdgeCuts
+                );
+
+                if (tolerance_ > 0)
+                {
+                    if (mag(pHit.hitPoint() - ptEnd) < tolDim)
+                    {
+                        // Near the end => done
+                        doTrack = false;
+                    }
+                    else
+                    {
+                        // Continue tracking a bit further on
+                        ptStart = pHit.hitPoint() + tolVec;
+                        doTrack = true;
+                    }
+                }
+            }
+            while (doTrack);  // execute at least once
+        }
+    }
+    if (debug & 2)
+    {
+        Pout<< endl;
+    }
+
+    // These temporaries are now unneeded:
+    edgeEdgeIntersection_.clear();
+    snappedEnds_.clear();
 
     intersection::setPlanarTol(oldTol);
 }
 
 
+void Foam::surfaceIntersection::joinDisconnected
+(
+    DynamicList<edge>& allCutEdges
+)
+{
+    // This simple heuristic seems to work just as well (or better) than
+    // more complicated schemes
+    //
+    // For any face/face intersection that only appears once,
+    // consider which other faces/points are involved and connect between
+    // those points.
+    // Just do a simple connect-the-dots?
+
+    Pair<Map<labelPairHashSet>> missedFacePoint;
+
+    // Stage 1:
+    // - Extract "faceId -> (faceId, pointId)"
+    //   for all face/face pairs that only have one interaction
+    forAllConstIters(facePairToEdge_, iter)
+    {
+        const labelPair& twoFaces = iter.key();
+        const edge& e = iter.object();
+
+        if (e.count() == 1)
+        {
+            // minVertex = -1 (unused), maxVertex = pointId
+            const label pointId = e.maxVertex();
+
+            missedFacePoint[0](twoFaces[0]).insert
+            (
+                labelPair(twoFaces[1], pointId)
+            );
+
+            missedFacePoint[1](twoFaces[1]).insert
+            (
+                labelPair(twoFaces[0], pointId)
+            );
+        }
+    }
+
+
+    // Stage 2:
+    // - anything with two cross-interactions could cause a new edge:
+
+    edgeHashSet newEdges;
+    forAll(missedFacePoint, sidei)
+    {
+        const auto& mapping = missedFacePoint[sidei];
+
+        forAllConstIters(mapping, iter)
+        {
+            const auto& connect = iter.object();
+
+            if (connect.size() == 2)
+            {
+                // exactly two face/face cross-interactions
+
+                edge e;
+                for (const auto& facePoint : connect)
+                {
+                    e.insert(facePoint.second());
+                }
+                e.sort();
+
+                // Only consider edges with two unique ends,
+                // and do not introduce duplicates
+                if (e.count() == 2 && !edgeToId_.found(e))
+                {
+                    newEdges.insert(e);
+                }
+            }
+        }
+    }
+
+    label edgeId = allCutEdges.size();
+    edgeList newEdgesLst = newEdges.sortedToc();
+    for (const auto& e : newEdgesLst)
+    {
+        // Record complete (line) intersection of two faces
+        allCutEdges.append(e);
+        edgeToId_.insert(e, edgeId);
+        ++edgeId;
+    }
+}
+
+
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
-// Null constructor
 Foam::surfaceIntersection::surfaceIntersection()
 :
+    tolerance_(1e-3),
+    allowEdgeHits_(true),
+    snapToEnd_(true),
+    warnDegenerate_(0),
     cutPoints_(0),
     cutEdges_(0),
-    facePairToVertex_(0),
     facePairToEdge_(0),
+    facePairToEdgeId_(0),
     surf1EdgeCuts_(0),
     surf2EdgeCuts_(0)
 {}
 
 
-// Construct from two surfaces
 Foam::surfaceIntersection::surfaceIntersection
 (
     const triSurfaceSearch& query1,
-    const triSurfaceSearch& query2
+    const triSurfaceSearch& query2,
+    const dictionary& dict
 )
 :
+    tolerance_(1e-3),
+    allowEdgeHits_(true),
+    snapToEnd_(true),
+    warnDegenerate_(0),
     cutPoints_(0),
     cutEdges_(0),
-    facePairToVertex_(2*max(query1.surface().size(), query2.surface().size())),
     facePairToEdge_(2*max(query1.surface().size(), query2.surface().size())),
+    facePairToEdgeId_(2*max(query1.surface().size(), query2.surface().size())),
     surf1EdgeCuts_(0),
     surf2EdgeCuts_(0)
 {
+    setOptions(dict);
+
     const triSurface& surf1 = query1.surface();
     const triSurface& surf2 = query2.surface();
 
@@ -732,23 +1093,21 @@ Foam::surfaceIntersection::surfaceIntersection
     }
 
 
-    DynamicList<edge> allCutEdges(surf1.nEdges()/20);
+    DynamicList<edge>  allCutEdges(surf1.nEdges()/20);
     DynamicList<point> allCutPoints(surf1.nPoints()/20);
 
 
     // From edge to cut index on surface1
     List<DynamicList<label>> edgeCuts1(query1.surface().nEdges());
 
+    // 1st surf (for labelPair order)
     doCutEdges
     (
         surf1,
         query2,
-        true,               // is first surface; construct labelPair in correct
-                            // order
-        false,              // not self intersection
-
-        allCutEdges,
+        surfaceIntersection::FIRST,
         allCutPoints,
+        allCutEdges,
         edgeCuts1
     );
     // Transfer to straight labelListList
@@ -766,24 +1125,25 @@ Foam::surfaceIntersection::surfaceIntersection
     // From edge to cut index
     List<DynamicList<label>> edgeCuts2(query2.surface().nEdges());
 
+    // 2nd surf (for labelPair order)
     doCutEdges
     (
         surf2,
         query1,
-        false,              // is second surface
-        false,              // not self intersection
-
-        allCutEdges,
+        surfaceIntersection::SECOND,
         allCutPoints,
+        allCutEdges,
         edgeCuts2
     );
 
+    // join disconnected intersection points
+    joinDisconnected(allCutEdges);
+
     // Transfer to straight label(List)List
     transfer(edgeCuts2, surf2EdgeCuts_);
     cutEdges_.transfer(allCutEdges);
     cutPoints_.transfer(allCutPoints);
 
-
     if (debug)
     {
         Pout<< "surfaceIntersection : Intersection generated:"
@@ -794,8 +1154,7 @@ Foam::surfaceIntersection::surfaceIntersection
         Pout<< "surfaceIntersection : Writing intersection to intEdges.obj"
             << endl;
 
-        OFstream intStream("intEdges.obj");
-        writeOBJ(cutPoints_, cutEdges_, intStream);
+        OBJstream("intEdges.obj").write(cutEdges_, cutPoints_);
 
         // Dump all cut edges to files
         Pout<< "Dumping cut edges of surface1 to surf1EdgeCuts.obj" << endl;
@@ -806,10 +1165,127 @@ Foam::surfaceIntersection::surfaceIntersection
         OFstream edge2Stream("surf2EdgeCuts.obj");
         writeIntersectedEdges(surf2, surf2EdgeCuts_, edge2Stream);
     }
+
+    // Temporaries
+    facePairToEdge_.clear();
+
+    // Cleanup any duplicate cuts?
+    // mergeEdges();
+}
+
+
+Foam::surfaceIntersection::surfaceIntersection
+(
+    const triSurfaceSearch& query1,
+    const dictionary& dict
+)
+:
+    tolerance_(1e-3),
+    allowEdgeHits_(true),
+    snapToEnd_(true),
+    warnDegenerate_(0),
+    cutPoints_(0),
+    cutEdges_(0),
+    facePairToEdge_(2*query1.surface().size()),
+    facePairToEdgeId_(2*query1.surface().size()),
+    surf1EdgeCuts_(0),
+    surf2EdgeCuts_(0)
+{
+    setOptions(dict);
+
+    const intersectionType cutFrom = selfIntersectionNames.lookupOrDefault
+    (
+        "intersectionMethod",
+        dict,
+        intersectionType::SELF
+    );
+
+    if (cutFrom == intersectionType::NONE)
+    {
+        if (debug)
+        {
+            Pout<< "Skipping self-intersection (selected: none)" << endl;
+        }
+
+        // Temporaries
+        facePairToEdge_.clear();
+        facePairToEdgeId_.clear();
+
+        return;
+    }
+
+    const triSurface& surf1 = query1.surface();
+
+    //
+    // Cut all edges of surf1 with surf1 itself.
+    //
+    if (debug)
+    {
+        Pout<< "Cutting surf1 edges" << endl;
+    }
+
+    DynamicList<edge>  allCutEdges;
+    DynamicList<point> allCutPoints;
+
+    // From edge to cut index on surface1
+    List<DynamicList<label>> edgeCuts1(query1.surface().nEdges());
+
+    // self-intersection
+    doCutEdges
+    (
+        surf1,
+        query1,
+        cutFrom,
+        allCutPoints,
+        allCutEdges,
+        edgeCuts1
+    );
+
+    // join disconnected intersection points
+    joinDisconnected(allCutEdges);
+
+    // Transfer to straight label(List)List
+    transfer(edgeCuts1, surf1EdgeCuts_);
+    cutEdges_.transfer(allCutEdges);
+    cutPoints_.transfer(allCutPoints);
+
+    // Short-circuit
+    if (cutPoints_.empty() && cutEdges_.empty())
+    {
+        if (debug)
+        {
+            Pout<< "Empty intersection" << endl;
+        }
+        return;
+    }
+
+    if (debug)
+    {
+        Pout<< "surfaceIntersection : Intersection generated and compressed:"
+            << endl
+            << "    points:" << cutPoints_.size() << endl
+            << "    edges :" << cutEdges_.size() << endl;
+
+
+        Pout<< "surfaceIntersection : Writing intersection to intEdges.obj"
+            << endl;
+
+        OBJstream("intEdges.obj").write(cutEdges_, cutPoints_);
+
+        // Dump all cut edges to files
+        Pout<< "Dumping cut edges of surface1 to surf1EdgeCuts.obj" << endl;
+        OFstream edge1Stream("surf1EdgeCuts.obj");
+        writeIntersectedEdges(surf1, surf1EdgeCuts_, edge1Stream);
+    }
+
+    // Temporaries
+    facePairToEdge_.clear();
+
+    // // Cleanup any duplicate cuts?
+    // mergeEdges();
 }
 
 
-// Construct from full intersection information
 Foam::surfaceIntersection::surfaceIntersection
 (
     const triSurface& surf1,
@@ -818,16 +1294,20 @@ Foam::surfaceIntersection::surfaceIntersection
     const edgeIntersections& intersections2
 )
 :
+    tolerance_(1e-3),
+    allowEdgeHits_(true),
+    snapToEnd_(true),
+    warnDegenerate_(0),
     cutPoints_(0),
     cutEdges_(0),
-    facePairToVertex_(2*max(surf1.size(), surf2.size())),
     facePairToEdge_(2*max(surf1.size(), surf2.size())),
+    facePairToEdgeId_(2*max(surf1.size(), surf2.size())),
     surf1EdgeCuts_(0),
     surf2EdgeCuts_(0)
 {
 
     // All intersection Pout (so for both surfaces)
-    DynamicList<edge> allCutEdges((surf1.nEdges() + surf2.nEdges())/20);
+    DynamicList<edge>  allCutEdges((surf1.nEdges() + surf2.nEdges())/20);
     DynamicList<point> allCutPoints((surf1.nPoints() + surf2.nPoints())/20);
 
 
@@ -849,19 +1329,21 @@ Foam::surfaceIntersection::surfaceIntersection
 
             forAll(intersections, i)
             {
-                const pointIndexHit& pHit = intersections[i];
-
                 // edgeI intersects surf2. Store point.
+                const pointIndexHit& pHit = intersections[i];
+                const label cutPointId = allCutPoints.size();
+
                 allCutPoints.append(pHit.hitPoint());
-                edgeCuts1[edgeI].append(allCutPoints.size()-1);
+                edgeCuts1[edgeI].append(cutPointId);
 
                 storeIntersection
                 (
-                    true,                       // is first surface
+                    surfaceIntersection::FIRST,
                     surf1.edgeFaces()[edgeI],
-                    pHit.index(),               // surf2Facei
-                    allCutEdges,
-                    allCutPoints
+                    pHit.index(),
+                    allCutPoints,
+                    cutPointId,
+                    allCutEdges
                 );
             }
         }
@@ -871,7 +1353,6 @@ Foam::surfaceIntersection::surfaceIntersection
     }
 
 
-
     // Cut all edges of surf2 with surf1
     // ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
@@ -890,19 +1371,21 @@ Foam::surfaceIntersection::surfaceIntersection
 
             forAll(intersections, i)
             {
-                const pointIndexHit& pHit = intersections[i];
-
                 // edgeI intersects surf1. Store point.
+                const pointIndexHit& pHit = intersections[i];
+                const label cutPointId = allCutPoints.size();
+
                 allCutPoints.append(pHit.hitPoint());
-                edgeCuts2[edgeI].append(allCutPoints.size()-1);
+                edgeCuts2[edgeI].append(cutPointId);
 
                 storeIntersection
                 (
-                    false,                      // is second surface
+                    surfaceIntersection::SECOND,
                     surf2.edgeFaces()[edgeI],
-                    pHit.index(),               // surf2Facei
-                    allCutEdges,
-                    allCutPoints
+                    pHit.index(),
+                    allCutPoints,
+                    cutPointId,
+                    allCutEdges
                 );
             }
         }
@@ -927,8 +1410,7 @@ Foam::surfaceIntersection::surfaceIntersection
         Pout<< "surfaceIntersection : Writing intersection to intEdges.obj"
             << endl;
 
-        OFstream intStream("intEdges.obj");
-        writeOBJ(cutPoints_, cutEdges_, intStream);
+        OBJstream("intEdges.obj").write(cutEdges_, cutPoints_);
 
         // Dump all cut edges to files
         Pout<< "Dumping cut edges of surface1 to surf1EdgeCuts.obj" << endl;
@@ -940,189 +1422,11 @@ Foam::surfaceIntersection::surfaceIntersection
         writeIntersectedEdges(surf2, surf2EdgeCuts_, edge2Stream);
     }
 
+    // Temporaries
+    facePairToEdge_.clear();
 
-    // Debugging stuff
-    {
-        // Check all facePairToVertex is used.
-        labelHashSet usedPoints;
-
-        forAllConstIter(labelPairLookup, facePairToEdge_, iter)
-        {
-            label edgeI = iter();
-
-            const edge& e = cutEdges_[edgeI];
-
-            usedPoints.insert(e[0]);
-            usedPoints.insert(e[1]);
-        }
-
-        forAllConstIter(labelPairLookup, facePairToVertex_, iter)
-        {
-            label pointi = iter();
-
-            if (!usedPoints.found(pointi))
-            {
-                WarningInFunction
-                    << "Problem: cut point:" << pointi
-                    << " coord:" << cutPoints_[pointi]
-                    << " not used by any edge" << endl;
-            }
-        }
-    }
-}
-
-
-// Construct from single surface. Used to test for self-intersection.
-Foam::surfaceIntersection::surfaceIntersection
-(
-    const triSurfaceSearch& query1
-)
-:
-    cutPoints_(0),
-    cutEdges_(0),
-    facePairToVertex_(2*query1.surface().size()),
-    facePairToEdge_(2*query1.surface().size()),
-    surf1EdgeCuts_(0),
-    surf2EdgeCuts_(0)
-{
-    const triSurface& surf1 = query1.surface();
-
-    //
-    // Cut all edges of surf1 with surf1 itself.
-    //
-    if (debug)
-    {
-        Pout<< "Cutting surf1 edges" << endl;
-    }
-
-    DynamicList<edge> allCutEdges;
-    DynamicList<point> allCutPoints;
-
-    // From edge to cut index on surface1
-    List<DynamicList<label>> edgeCuts1(query1.surface().nEdges());
-
-    doCutEdges
-    (
-        surf1,
-        query1,
-        true,               // is first surface; construct labelPair in correct
-                            // order
-        true,               // self intersection
-
-
-        allCutEdges,
-        allCutPoints,
-        edgeCuts1
-    );
-
-    // Transfer to straight label(List)List
-    transfer(edgeCuts1, surf1EdgeCuts_);
-    cutEdges_.transfer(allCutEdges);
-    cutPoints_.transfer(allCutPoints);
-
-    // Shortcut.
-    if (cutPoints_.empty() && cutEdges_.empty())
-    {
-        if (debug)
-        {
-            Pout<< "Empty intersection" << endl;
-        }
-        return;
-    }
-
-    //
-    // Remove duplicate points (from edge-point or edge-edge cutting)
-    //
-
-    // Get typical dimension.
-    scalar minEdgeLen = GREAT;
-    forAll(surf1.edges(), edgeI)
-    {
-        minEdgeLen = min
-        (
-            minEdgeLen,
-            surf1.edges()[edgeI].mag(surf1.localPoints())
-        );
-    }
-
-    // Merge points
-    labelList pointMap;
-    pointField newPoints;
-
-    bool hasMerged = mergePoints
-    (
-        cutPoints_,
-        minEdgeLen*intersection::planarTol(),
-        false,
-        pointMap,
-        newPoints
-    );
-
-    if (hasMerged)
-    {
-        if (debug)
-        {
-            Pout<< "Merged:" << hasMerged
-                << "  mergeDist:" << minEdgeLen*intersection::planarTol()
-                << "  cutPoints:" << cutPoints_.size()
-                << "  newPoints:" << newPoints.size()
-                << endl;
-        }
-
-        // Copy points
-        cutPoints_.transfer(newPoints);
-
-        // Renumber vertices referenced by edges
-        forAll(cutEdges_, edgeI)
-        {
-            edge& e = cutEdges_[edgeI];
-
-            e.start() = pointMap[e.start()];
-            e.end() = pointMap[e.end()];
-
-            if (e.mag(cutPoints_) < minEdgeLen*intersection::planarTol())
-            {
-                if (debug)
-                {
-                    Pout<< "Degenerate cut:" << edgeI << " vertices:" << e
-                        << " coords:" << cutPoints_[e.start()] << ' '
-                        << cutPoints_[e.end()] << endl;
-                }
-            }
-        }
-
-        // Renumber vertices referenced by edgeCut lists. Remove duplicates.
-        forAll(surf1EdgeCuts_, edgeI)
-        {
-            // Get indices of cutPoints this edge is cut by
-            labelList& cutVerts = surf1EdgeCuts_[edgeI];
-
-            removeDuplicates(pointMap, cutVerts);
-        }
-    }
-
-    if (debug)
-    {
-        Pout<< "surfaceIntersection : Intersection generated and compressed:"
-            << endl
-            << "    points:" << cutPoints_.size() << endl
-            << "    edges :" << cutEdges_.size() << endl;
-
-
-        Pout<< "surfaceIntersection : Writing intersection to intEdges.obj"
-            << endl;
-
-        OFstream intStream("intEdges.obj");
-        writeOBJ(cutPoints_, cutEdges_, intStream);
-    }
-
-    if (debug)
-    {
-        // Dump all cut edges to files
-        Pout<< "Dumping cut edges of surface1 to surf1EdgeCuts.obj" << endl;
-        OFstream edge1Stream("surf1EdgeCuts.obj");
-        writeIntersectedEdges(surf1, surf1EdgeCuts_, edge1Stream);
-    }
+    // // Cleanup any duplicate cuts?
+    // mergeEdges();
 }
 
 
@@ -1140,15 +1444,9 @@ const Foam::edgeList& Foam::surfaceIntersection::cutEdges() const
 }
 
 
-const Foam::labelPairLookup& Foam::surfaceIntersection::facePairToVertex() const
+const Foam::labelPairLookup& Foam::surfaceIntersection::facePairToEdgeId() const
 {
-    return facePairToVertex_;
-}
-
-
-const Foam::labelPairLookup& Foam::surfaceIntersection::facePairToEdge() const
-{
-    return facePairToEdge_;
+    return facePairToEdgeId_;
 }
 
 
@@ -1180,4 +1478,84 @@ const Foam::labelListList& Foam::surfaceIntersection::surf2EdgeCuts() const
 }
 
 
+void Foam::surfaceIntersection::mergePoints(const scalar mergeDist)
+{
+    pointField newPoints;
+    labelList pointMap;
+
+    const label nMerged = Foam::mergePoints
+    (
+        cutPoints_,
+        mergeDist,
+        false,
+        pointMap,
+        newPoints
+    );
+
+    if (nMerged)
+    {
+        cutPoints_.transfer(newPoints);
+
+        forAll(cutEdges_, edgei)
+        {
+            edge& e = cutEdges_[edgei];
+
+            e[0] = pointMap[e[0]];
+            e[1] = pointMap[e[1]];
+        }
+
+        forAll(surf1EdgeCuts_, edgei)
+        {
+            inplaceRenumber(pointMap, surf1EdgeCuts_[edgei]);
+            inplaceUniqueSort(surf1EdgeCuts_[edgei]);
+        }
+        forAll(surf2EdgeCuts_, edgei)
+        {
+            inplaceRenumber(pointMap, surf2EdgeCuts_[edgei]);
+            inplaceUniqueSort(surf2EdgeCuts_[edgei]);
+        }
+    }
+
+    this->mergeEdges();
+}
+
+
+void Foam::surfaceIntersection::mergeEdges()
+{
+    HashSet<edge, Hash<edge>> uniqEdges(2*cutEdges_.size());
+
+    label nUniqEdges = 0;
+    labelList edgeNumbering(cutEdges_.size(), -1);
+
+    forAll(cutEdges_, edgeI)
+    {
+        const edge& e = cutEdges_[edgeI];
+
+        // Remove degenerate and repeated edges
+        // - reordering (e[0] < e[1]) is not really necessary
+        if (e[0] != e[1] && uniqEdges.insert(e))
+        {
+            edgeNumbering[edgeI] = nUniqEdges;
+            if (nUniqEdges != edgeI)
+            {
+                cutEdges_[nUniqEdges] = e;
+            }
+            cutEdges_[nUniqEdges].sort();
+            ++nUniqEdges;
+        }
+    }
+
+    // if (nUniqEdges < cutEdges_.size())
+    // {
+    //     // Additional safety, in case the edge was replaced?
+    //     forAllIters(facePairToEdge_, iter)
+    //     {
+    //         iter.object() = edgeNumbering[iter.object()];
+    //     }
+    // }
+
+    cutEdges_.setSize(nUniqEdges);  // truncate
+}
+
+
 // ************************************************************************* //
diff --git a/src/meshTools/triSurface/booleanOps/surfaceIntersection/surfaceIntersection.H b/src/meshTools/triSurface/booleanOps/surfaceIntersection/surfaceIntersection.H
index 99265c9b35..d91ef507dd 100644
--- a/src/meshTools/triSurface/booleanOps/surfaceIntersection/surfaceIntersection.H
+++ b/src/meshTools/triSurface/booleanOps/surfaceIntersection/surfaceIntersection.H
@@ -3,7 +3,7 @@
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
     \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
-     \\/     M anipulation  |
+     \\/     M anipulation  | Copyright (C) 2017 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -41,11 +41,20 @@ Description
     hit of both faces and an edge is created between the retrieved vertex and
     the new one.
 
-    Note: when doing intersecting itself uses intersection::planarTol() as a
-    fraction of
+    Note: when doing intersecting itself uses 'tolerance' as a fraction of
     current edge length to determine if intersection is a point-touching one
     instead of an edge-piercing action.
 
+    Some constructors allow a dictionary of intersection controls:
+    \table
+        Property       | Description                    | Type   | Default value
+        tolerance      | Edge-length tolerance          | scalar | 1e-3
+        allowEdgeHits  | Edge-end cuts another edge     | bool   | true
+        snap           | Snap near end-points           | bool   | true
+        warnDegenerate | Number of warnings about degenerate edges | label | 0
+        intersectionMethod | Control for self intersection | (self,region,none)
+    \endtable
+
 SourceFiles
     surfaceIntersection.C
     surfaceIntersectionFuncs.C
@@ -58,11 +67,12 @@ SourceFiles
 
 #include "DynamicList.H"
 #include "point.H"
-#include "edge.H"
-#include "labelPairHashes.H"
-#include "typeInfo.H"
+#include "edgeHashes.H"
 #include "edgeList.H"
+#include "labelPairHashes.H"
 #include "pointIndexHit.H"
+#include "typeInfo.H"
+#include "Enum.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -74,50 +84,88 @@ class triSurfaceSearch;
 class triSurface;
 class edgeIntersections;
 
+
+//- Key is non-commutative pair of labels. Value is commutative pair of labels
+typedef LabelPairMap<edge> labelPairEdgeLookup;
+
+//- Map from edge back to all parents (pairs of faces)
+typedef EdgeMap<labelPairHashSet> edgelabelPairHashLookup;
+
+
 /*---------------------------------------------------------------------------*\
-                    Class surfaceIntersection Declaration
+                     Class surfaceIntersection Declaration
 \*---------------------------------------------------------------------------*/
 
 class surfaceIntersection
 {
+public:
+
+    //- Surface intersection types for classify, doCutEdges
+    enum intersectionType
+    {
+        FIRST,          //!< First surface
+        SECOND,         //!< Second surface
+        SELF,           //!< Self-intersection
+        SELF_REGION,    //!< Self-intersection, region-wise only
+        NONE            //!< None = invalid (for input only)
+    };
+
+    //- The user-selectable self-intersection enumeration names
+    static const Enum<intersectionType> selfIntersectionNames;
+
+
+private:
+
     // Private data
 
+        //- Tolerance for intersections
+        scalar tolerance_;
+
+        //- Allow edge-ends to cut another edge.
+        bool allowEdgeHits_;
+
+        //- Snap cut points near edge ends (default: true)
+        bool snapToEnd_;
+
+        //- Maximum number of warnings about degenerate edges
+        label warnDegenerate_;
+
         //- Newly introduced points.
         pointField cutPoints_;
 
-        //- Newly introduced edges (are on both surfaces). Reference into
-        //  cutPoints.
+        //- Newly introduced edges (are on both surfaces).
+        //  Reference into cutPoints.
         edgeList cutEdges_;
 
-        //- From face on surf1 and face on surf2 to intersection point
-        // (label in cutPoints)
-        labelPairLookup facePairToVertex_;
-
         //- From face on surf1 and face on surf2 to intersection edge
-        //  (label in cutEdges)
-        labelPairLookup facePairToEdge_;
+        labelPairEdgeLookup facePairToEdge_;
 
-        //- Edges on surf1 that are cut. From edge on surf1 to label in cutPoint
-        //  If multiple cuts:sorted from edge.start to edge.end
+        //- From face on surf1 and face on surf2 to intersection edgeId
+        //  (label in cutEdges)
+        labelPairLookup facePairToEdgeId_;
+
+        //- Edges on surf1 that are cut.
+        //  From edgeId on surf1 to location in cutPoint
         labelListList surf1EdgeCuts_;
 
-        //- Edges on surf2 that are cut. From edge on surf2 to label in cutPoint
-        //  If multiple cuts:sorted from edge.start to edge.end
+        //- Edges on surf2 that are cut.
+        //  From edgeId on surf2 to location in cutPoint
         labelListList surf2EdgeCuts_;
 
+        //- Temporary storage to manage edge-edge self-intersections.
+        edgeHashSet edgeEdgeIntersection_;
+
+        //- Temporary storage to manage cuts/intersections from the edge ends
+        Map<label> snappedEnds_;
+
+        //- Temporary storage
+        EdgeMap<label> edgeToId_;
+
 
     // Private Member Functions
 
-        //- Write point in obj format.
-        static void writeOBJ(const point& pt, Ostream& os);
-
-        //- Write points and edges in obj format
-        static void writeOBJ
-        (
-            const List<point>&,
-            const List<edge>&,
-            Ostream&
-        );
+        //- Adjust intersection options according to the dictionary entries
+        void setOptions(const dictionary& dict);
 
         //- Transfer contents of List<DynamicList<..>> to List<List<..>>
         template<class T>
@@ -138,9 +186,6 @@ class surfaceIntersection
         //  to new (-1 if element removed)
         static void removeDuplicates(const labelList& map, labelList& labels);
 
-        //- Apply map to elements of a labelList
-        static void inlineRemap(const labelList& map, labelList& elems);
-
         // Remove all duplicate and degenerate elements. Return unique elements
         // and map from old to new.
         static edgeList filterEdges(const edgeList&, labelList& map);
@@ -148,30 +193,6 @@ class surfaceIntersection
         //- Remove all duplicate elements.
         static labelList filterLabels(const labelList& elems, labelList& map);
 
-        //- Do some checks if edge and face (resulting from hit)
-        //  should not be considered. Returns true if can be discarded.
-        static bool excludeEdgeHit
-        (
-            const triSurface& surf,
-            const label edgeI,
-            const label facei,
-            const scalar tol
-        );
-
-        ////- Given edge (eStart - eEnd) and normal direction construct plane
-        ////  and intersect all edges of hitFace with it.
-        ////  Return the edge and coordinate of hit.
-        //static pointIndexHit faceEdgeIntersection
-        //(
-        //    const triSurface&,
-        //    const label hitFacei,
-        //
-        //    const vector& n,
-        //    const point& eStart,
-        //    const point& eEnd
-        //);
-
-
         //- Debugging: Dump intersected edges to stream
         void writeIntersectedEdges
         (
@@ -188,18 +209,19 @@ class surfaceIntersection
             const scalar endTol,
             const point& p,
             const edge& e,
-            const pointField& points
+            const UList<point>& points
         );
 
-        //- Update reference between faceA and faceB. Updates facePairToVertex_
-        //  (first occurrence of face pair) and facePairToEdge_ (second occ.)
+        //- Update reference between faceA and faceB.
+        //  Updates facePairToEdge_ and facePairToEdgeId_ (on the second hit)
         void storeIntersection
         (
-            const bool isFirstSurf,
+            const enum intersectionType cutFrom,
             const labelList& facesA,
             const label faceB,
-            DynamicList<edge>&,
-            DynamicList<point>&
+            const UList<point>& allCutPoints,
+            const label cutPointId,
+            DynamicList<edge>& allCutEdges
         );
 
         //- Investigate pHit to whether is case of point hits point,
@@ -209,13 +231,12 @@ class surfaceIntersection
             const triSurface& surf1,
             const scalarField& surf1PointTol,
             const triSurface& surf2,
-            const bool isFirstSurf,
+            const enum intersectionType cutFrom,
             const label edgeI,
-            const scalar tolDim,
             const pointIndexHit& pHit,
 
-            DynamicList<edge>& allCutEdges,
             DynamicList<point>& allCutPoints,
+            DynamicList<edge>& allCutEdges,
             List<DynamicList<label>>& surfEdgeCuts
         );
 
@@ -224,17 +245,21 @@ class surfaceIntersection
         (
             const triSurface& surf1,
             const triSurfaceSearch& querySurf2,
-            const bool isFirstSurf,
-            const bool isSelfIntersection,
+            const enum intersectionType cutFrom,
 
-            DynamicList<edge>& allCutEdges,
             DynamicList<point>& allCutPoints,
+            DynamicList<edge>& allCutEdges,
             List<DynamicList<label>>& surfEdgeCuts
         );
 
+        //- Join disconnected intersection points
+        void joinDisconnected(DynamicList<edge>& allCutEdges);
+
 
 public:
 
+    // Public Data, Declarations
+
     ClassName("surfaceIntersection");
 
 
@@ -243,6 +268,23 @@ public:
         //- Construct null
         surfaceIntersection();
 
+        //- Construct from two surfaces.
+        //  Does its own cutting. Has problems with degenerate cuts
+        surfaceIntersection
+        (
+            const triSurfaceSearch& querySurf1,
+            const triSurfaceSearch& querySurf2,
+            const dictionary& dict = dictionary::null
+        );
+
+        //- Construct from self-intersections.
+        //  Does its own cutting, but has problems with degenerate cuts
+        surfaceIntersection
+        (
+            const triSurfaceSearch& querySurf1,
+            const dictionary& dict = dictionary::null
+        );
+
         //- Construct from precalculated intersection information.
         //  Advantage: intersection information is guaranteed to have no
         //  degenerate cuts.
@@ -254,36 +296,36 @@ public:
             const edgeIntersections& intersections2
         );
 
-        //- Construct from two surfaces. Does all its own cutting.
-        //  Has problems with degenerate cuts
-        surfaceIntersection
-        (
-            const triSurfaceSearch& querySurf1,
-            const triSurfaceSearch& querySurf2
-        );
-
-        //- Special: intersect surface with itself. Used to check for
-        //  self-intersection.
-        surfaceIntersection(const triSurfaceSearch& querySurf1);
-
 
     // Member Functions
 
+        //- The list of cut points
         const pointField& cutPoints() const;
 
+        //- The list of created edges
         const edgeList& cutEdges() const;
 
-        const labelPairLookup& facePairToVertex() const;
-
-        const labelPairLookup& facePairToEdge() const;
+        //- Lookup of pairs of faces to created edges
+        const labelPairLookup& facePairToEdgeId() const;
 
         //- Access either surf1EdgeCuts (isFirstSurface = true) or
         //  surf2EdgeCuts
-        const labelListList& edgeCuts(const bool) const;
+        const labelListList& edgeCuts(const bool isFirstSurf) const;
 
+        //- List of cut points on edges of surface1
         const labelListList& surf1EdgeCuts() const;
 
+        //- List of cut points on edges of surface2
         const labelListList& surf2EdgeCuts() const;
+
+
+        //- Geometric merge points (points within mergeDist) prior to
+        //  automatically calling mergeEdges().
+        void mergePoints(const scalar mergeDist);
+
+        //- Merge duplicate edges
+        void mergeEdges();
+
 };
 
 
diff --git a/src/meshTools/triSurface/booleanOps/surfaceIntersection/surfaceIntersectionFuncs.C b/src/meshTools/triSurface/booleanOps/surfaceIntersection/surfaceIntersectionFuncs.C
index cd3af9da0c..d8797736b0 100644
--- a/src/meshTools/triSurface/booleanOps/surfaceIntersection/surfaceIntersectionFuncs.C
+++ b/src/meshTools/triSurface/booleanOps/surfaceIntersection/surfaceIntersectionFuncs.C
@@ -24,41 +24,32 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "surfaceIntersection.H"
+#include "triSurface.H"
 #include "triSurfaceSearch.H"
 #include "labelPairHashes.H"
 #include "OFstream.H"
-#include "HashSet.H"
-#include "triSurface.H"
-#include "pointIndexHit.H"
-#include "meshTools.H"
 
-// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-void Foam::surfaceIntersection::writeOBJ(const point& pt, Ostream& os)
+namespace Foam
 {
-    os << "v " << pt.x() << ' ' << pt.y() << ' ' << pt.z() << endl;
-}
 
-
-void Foam::surfaceIntersection::writeOBJ
-(
-    const List<point>& pts,
-    const List<edge>& edges,
-    Ostream& os
-)
+// file-scope
+// Write points in obj format
+static void writeObjPoints(const UList<point>& pts, Ostream& os)
 {
     forAll(pts, i)
     {
-        writeOBJ(pts[i], os);
-    }
-    forAll(edges, i)
-    {
-        const edge& e = edges[i];
-
-        os << "l " << e.start()+1 << ' ' << e.end()+1 << endl;
+        const point& pt = pts[i];
+        os << "v " << pt.x() << ' ' << pt.y() << ' ' << pt.z() << nl;
     }
 }
 
+} // End namespace Foam
+
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
 
 // Get minimum length of all edges connected to point
 Foam::scalar Foam::surfaceIntersection::minEdgeLen
@@ -162,20 +153,6 @@ void Foam::surfaceIntersection::removeDuplicates
 }
 
 
-// Remap.
-void Foam::surfaceIntersection::inlineRemap
-(
-    const labelList& map,
-    labelList& elems
-)
-{
-    forAll(elems, elemI)
-    {
-        elems[elemI] = map[elems[elemI]];
-    }
-}
-
-
 // Remove all duplicate and degenerate elements. Return unique elements and
 // map from old to new.
 Foam::edgeList Foam::surfaceIntersection::filterEdges
@@ -265,14 +242,8 @@ void Foam::surfaceIntersection::writeIntersectedEdges
     // Dump all points (surface followed by cutPoints)
     const pointField& pts = surf.localPoints();
 
-    forAll(pts, pointi)
-    {
-        writeOBJ(pts[pointi], os);
-    }
-    forAll(cutPoints(), cutPointi)
-    {
-        writeOBJ(cutPoints()[cutPointi], os);
-    }
+    writeObjPoints(pts, os);
+    writeObjPoints(cutPoints(), os);
 
     forAll(edgeCutVerts, edgeI)
     {
@@ -284,16 +255,16 @@ void Foam::surfaceIntersection::writeIntersectedEdges
 
             // Start of original edge to first extra point
             os  << "l " << e.start()+1 << ' '
-                << extraVerts[0] + surf.nPoints() + 1 << endl;
+                << extraVerts[0] + surf.nPoints() + 1 << nl;
 
             for (label i = 1; i < extraVerts.size(); i++)
             {
                 os  << "l " << extraVerts[i-1] + surf.nPoints() + 1  << ' '
-                    << extraVerts[i] + surf.nPoints() + 1 << endl;
+                    << extraVerts[i] + surf.nPoints() + 1 << nl;
             }
 
             os  << "l " << extraVerts.last() + surf.nPoints() + 1
-                << ' ' << e.end()+1 << endl;
+                << ' ' << e.end()+1 << nl;
         }
     }
 }
@@ -306,7 +277,7 @@ Foam::label Foam::surfaceIntersection::classify
     const scalar endTol,
     const point& p,
     const edge& e,
-    const pointField& points
+    const UList<point>& points
 )
 {
     if (mag(p - points[e.start()]) < startTol)
diff --git a/src/meshTools/triSurface/surfaceFeatures/surfaceFeatures.C b/src/meshTools/triSurface/surfaceFeatures/surfaceFeatures.C
index 767b4bb7fa..c727121a60 100644
--- a/src/meshTools/triSurface/surfaceFeatures/surfaceFeatures.C
+++ b/src/meshTools/triSurface/surfaceFeatures/surfaceFeatures.C
@@ -3,7 +3,7 @@
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
     \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
-     \\/     M anipulation  |
+     \\/     M anipulation  | Copyright (C) 2017 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -42,7 +42,30 @@ namespace Foam
     defineTypeNameAndDebug(surfaceFeatures, 0);
 
     const scalar surfaceFeatures::parallelTolerance = sin(degToRad(1.0));
+
+
+//! \cond fileScope
+//  Check if the point is on the line
+static bool onLine(const Foam::point& p, const linePointRef& line)
+{
+    const point& a = line.start();
+    const point& b = line.end();
+
+    if
+    (
+        (p.x() < min(a.x(), b.x()) || p.x() > max(a.x(), b.x()))
+     || (p.y() < min(a.y(), b.y()) || p.y() > max(a.y(), b.y()))
+     || (p.z() < min(a.z(), b.z()) || p.z() > max(a.z(), b.z()))
+    )
+    {
+        return false;
+    }
+
+    return true;
 }
+//! \endcond
+
+} // End namespace Foam
 
 
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
@@ -442,6 +465,181 @@ Foam::surfaceFeatures::labelScalar Foam::surfaceFeatures::walkSegment
 }
 
 
+//- Divide into multiple normal bins
+//  - return REGION if != 2 normals
+//  - return REGION if 2 normals that make feature angle
+//  - otherwise return NONE and set normals,bins
+//
+// This has been relocated from surfaceFeatureExtract and could be cleaned
+// up some more.
+//
+Foam::surfaceFeatures::edgeStatus
+Foam::surfaceFeatures::surfaceFeatures::checkFlatRegionEdge
+(
+    const scalar tol,
+    const scalar includedAngle,
+    const label edgeI
+) const
+{
+    const triSurface& surf = surf_;
+
+    const edge& e = surf.edges()[edgeI];
+    const labelList& eFaces = surf.edgeFaces()[edgeI];
+
+    // Bin according to normal
+
+    DynamicList<vector> normals(2);
+    DynamicList<labelList> bins(2);
+
+    forAll(eFaces, eFacei)
+    {
+        const vector& n = surf.faceNormals()[eFaces[eFacei]];
+
+        // Find the normal in normals
+        label index = -1;
+        forAll(normals, normalI)
+        {
+            if (mag(n & normals[normalI]) > (1-tol))
+            {
+                index = normalI;
+                break;
+            }
+        }
+
+        if (index != -1)
+        {
+            bins[index].append(eFacei);
+        }
+        else if (normals.size() >= 2)
+        {
+            // Would be third normal. Mark as feature.
+            //Pout<< "** at edge:" << surf.localPoints()[e[0]]
+            //    << surf.localPoints()[e[1]]
+            //    << " have normals:" << normals
+            //    << " and " << n << endl;
+            return surfaceFeatures::REGION;
+        }
+        else
+        {
+            normals.append(n);
+            bins.append(labelList(1, eFacei));
+        }
+    }
+
+
+    // Check resulting number of bins
+    if (bins.size() == 1)
+    {
+        // Note: should check here whether they are two sets of faces
+        // that are planar or indeed 4 faces al coming together at an edge.
+        //Pout<< "** at edge:"
+        //    << surf.localPoints()[e[0]]
+        //    << surf.localPoints()[e[1]]
+        //    << " have single normal:" << normals[0]
+        //    << endl;
+        return surfaceFeatures::NONE;
+    }
+    else
+    {
+        // Two bins. Check if normals make an angle
+
+        //Pout<< "** at edge:"
+        //    << surf.localPoints()[e[0]]
+        //    << surf.localPoints()[e[1]] << nl
+        //    << "    normals:" << normals << nl
+        //    << "    bins   :" << bins << nl
+        //    << endl;
+
+        if (includedAngle >= 0)
+        {
+            scalar minCos = Foam::cos(degToRad(180.0 - includedAngle));
+
+            forAll(eFaces, i)
+            {
+                const vector& ni = surf.faceNormals()[eFaces[i]];
+                for (label j=i+1; j<eFaces.size(); j++)
+                {
+                    const vector& nj = surf.faceNormals()[eFaces[j]];
+                    if (mag(ni & nj) < minCos)
+                    {
+                        //Pout<< "have sharp feature between normal:" << ni
+                        //    << " and " << nj << endl;
+
+                        // Is feature. Keep as region or convert to
+                        // feature angle? For now keep as region.
+                        return surfaceFeatures::REGION;
+                    }
+                }
+            }
+        }
+
+        // So now we have two normals bins but need to make sure both
+        // bins have the same regions in it.
+
+        // 1. store + or - region number depending
+        //    on orientation of triangle in bins[0]
+        const labelList& bin0 = bins[0];
+        labelList regionAndNormal(bin0.size());
+        forAll(bin0, i)
+        {
+            const labelledTri& t = surf.localFaces()[eFaces[bin0[i]]];
+            int dir = t.edgeDirection(e);
+
+            if (dir > 0)
+            {
+                regionAndNormal[i] = t.region()+1;
+            }
+            else if (dir == 0)
+            {
+                FatalErrorInFunction
+                    << exit(FatalError);
+            }
+            else
+            {
+                regionAndNormal[i] = -(t.region()+1);
+            }
+        }
+
+        // 2. check against bin1
+        const labelList& bin1 = bins[1];
+        labelList regionAndNormal1(bin1.size());
+        forAll(bin1, i)
+        {
+            const labelledTri& t = surf.localFaces()[eFaces[bin1[i]]];
+            int dir = t.edgeDirection(e);
+
+            label myRegionAndNormal;
+            if (dir > 0)
+            {
+                myRegionAndNormal = t.region()+1;
+            }
+            else
+            {
+                myRegionAndNormal = -(t.region()+1);
+            }
+
+            regionAndNormal1[i] = myRegionAndNormal;
+
+            label index = findIndex(regionAndNormal, -myRegionAndNormal);
+            if (index == -1)
+            {
+                // Not found.
+                //Pout<< "cannot find region " << myRegionAndNormal
+                //    << " in regions " << regionAndNormal << endl;
+
+                return surfaceFeatures::REGION;
+            }
+        }
+
+        // Passed all checks, two normal bins with the same contents.
+        //Pout<< "regionAndNormal:" << regionAndNormal << endl;
+        //Pout<< "myRegionAndNormal:" << regionAndNormal1 << endl;
+    }
+
+    return surfaceFeatures::NONE;
+}
+
+
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
 Foam::surfaceFeatures::surfaceFeatures(const triSurface& surf)
@@ -829,24 +1027,141 @@ Foam::labelList Foam::surfaceFeatures::trimFeatures
 }
 
 
-void Foam::surfaceFeatures::writeDict(Ostream& writeFile) const
+void Foam::surfaceFeatures::excludeBox
+(
+    List<edgeStatus>& edgeStat,
+    const treeBoundBox& bb
+) const
 {
+    deleteBox(edgeStat, bb, true);
+}
 
+
+void Foam::surfaceFeatures::subsetBox
+(
+    List<edgeStatus>& edgeStat,
+    const treeBoundBox& bb
+) const
+{
+    deleteBox(edgeStat, bb, false);
+}
+
+
+void Foam::surfaceFeatures::deleteBox
+(
+    List<edgeStatus>& edgeStat,
+    const treeBoundBox& bb,
+    const bool removeInside
+) const
+{
+    const edgeList& surfEdges = surf_.edges();
+    const pointField& surfLocalPoints = surf_.localPoints();
+
+    forAll(edgeStat, edgei)
+    {
+        const point eMid = surfEdges[edgei].centre(surfLocalPoints);
+
+        if (removeInside ? bb.contains(eMid) : !bb.contains(eMid))
+        {
+            edgeStat[edgei] = surfaceFeatures::NONE;
+        }
+    }
+}
+
+
+void Foam::surfaceFeatures::subsetPlane
+(
+    List<edgeStatus>& edgeStat,
+    const plane& cutPlane
+) const
+{
+    const edgeList& surfEdges = surf_.edges();
+    const pointField& pts = surf_.points();
+    const labelList& meshPoints = surf_.meshPoints();
+
+    forAll(edgeStat, edgei)
+    {
+        const edge& e = surfEdges[edgei];
+
+        const point& p0 = pts[meshPoints[e.start()]];
+        const point& p1 = pts[meshPoints[e.end()]];
+        const linePointRef line(p0, p1);
+
+        // If edge does not intersect the plane, delete.
+        scalar intersect = cutPlane.lineIntersect(line);
+
+        point featPoint = intersect * (p1 - p0) + p0;
+
+        if (!onLine(featPoint, line))
+        {
+            edgeStat[edgei] = surfaceFeatures::NONE;
+        }
+    }
+}
+
+
+void Foam::surfaceFeatures::excludeOpen
+(
+    List<edgeStatus>& edgeStat
+) const
+{
+    forAll(edgeStat, edgei)
+    {
+        if (surf_.edgeFaces()[edgei].size() == 1)
+        {
+            edgeStat[edgei] = surfaceFeatures::NONE;
+        }
+    }
+}
+
+
+//- Divide into multiple normal bins
+//  - return REGION if != 2 normals
+//  - return REGION if 2 normals that make feature angle
+//  - otherwise return NONE and set normals,bins
+void Foam::surfaceFeatures::checkFlatRegionEdge
+(
+    List<edgeStatus>& edgeStat,
+    const scalar tol,
+    const scalar includedAngle
+) const
+{
+    forAll(edgeStat, edgei)
+    {
+        if (edgeStat[edgei] == surfaceFeatures::REGION)
+        {
+            const labelList& eFaces = surf_.edgeFaces()[edgei];
+
+            if (eFaces.size() > 2 && (eFaces.size() % 2) == 0)
+            {
+                edgeStat[edgei] = checkFlatRegionEdge
+                (
+                    tol,
+                    includedAngle,
+                    edgei
+                );
+            }
+        }
+    }
+}
+
+
+void Foam::surfaceFeatures::writeDict(Ostream& os) const
+{
     dictionary featInfoDict;
     featInfoDict.add("externalStart", externalStart_);
     featInfoDict.add("internalStart", internalStart_);
     featInfoDict.add("featureEdges", featureEdges_);
     featInfoDict.add("featurePoints", featurePoints_);
 
-    featInfoDict.write(writeFile);
+    featInfoDict.write(os);
 }
 
 
 void Foam::surfaceFeatures::write(const fileName& fName) const
 {
-    OFstream str(fName);
-
-    writeDict(str);
+    OFstream os(fName);
+    writeDict(os);
 }
 
 
@@ -904,6 +1219,18 @@ void Foam::surfaceFeatures::writeObj(const fileName& prefix) const
 }
 
 
+void Foam::surfaceFeatures::writeStats(Ostream& os) const
+{
+    os  << "Feature set:" << nl
+        << "    points : " << this->featurePoints().size() << nl
+        << "    edges  : " << this->featureEdges().size() << nl
+        << "    of which" << nl
+        << "        region edges   : " << this->nRegionEdges() << nl
+        << "        external edges : " << this->nExternalEdges() << nl
+        << "        internal edges : " << this->nInternalEdges() << endl;
+}
+
+
 // Get nearest vertex on patch for every point of surf in pointSet.
 Foam::Map<Foam::label> Foam::surfaceFeatures::nearestSamples
 (
diff --git a/src/meshTools/triSurface/surfaceFeatures/surfaceFeatures.H b/src/meshTools/triSurface/surfaceFeatures/surfaceFeatures.H
index 3eb4e6f025..a4a3083f1a 100644
--- a/src/meshTools/triSurface/surfaceFeatures/surfaceFeatures.H
+++ b/src/meshTools/triSurface/surfaceFeatures/surfaceFeatures.H
@@ -3,7 +3,7 @@
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
     \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
-     \\/     M anipulation  |
+     \\/     M anipulation  | Copyright (C) 2017 OpenCFD Ltd.
 -------------------------------------------------------------------------------
 License
     This file is part of OpenFOAM.
@@ -60,7 +60,9 @@ namespace Foam
 {
 
 // Forward declaration of classes
+class plane;
 class triSurface;
+class treeBoundBox;
 
 /*---------------------------------------------------------------------------*\
                            Class surfaceFeatures Declaration
@@ -70,12 +72,13 @@ class surfaceFeatures
 {
 public:
 
+        //- Edge status
         enum edgeStatus
         {
-            NONE,
-            REGION,
-            EXTERNAL,
-            INTERNAL
+            NONE,       //!< Not a classified feature edge
+            REGION,     //
+            EXTERNAL,   //!< "Convex" edge
+            INTERNAL    //!< "Concave" edge
         };
 
 
@@ -169,6 +172,17 @@ private:
             labelList& featVisited
         );
 
+        //- Divide into multiple normal bins
+        //  - set REGION if != 2 normals
+        //  - set REGION if 2 normals that make feature angle
+        //  - otherwise set NONE and set normals,bins
+        edgeStatus checkFlatRegionEdge
+        (
+            const scalar tol,
+            const scalar includedAngle,
+            const label edgeI
+        ) const;
+
 public:
 
     ClassName("surfaceFeatures");
@@ -176,12 +190,12 @@ public:
     // Constructors
 
         //- Construct from surface
-        surfaceFeatures(const triSurface&);
+        surfaceFeatures(const triSurface& surf);
 
         //- Construct from components
         surfaceFeatures
         (
-            const triSurface&,
+            const triSurface& surf,
             const labelList& featurePoints,
             const labelList& featureEdges,
             const label externalStart,
@@ -194,7 +208,7 @@ public:
         //  geometric criteria
         surfaceFeatures
         (
-            const triSurface&,
+            const triSurface& surf,
             const scalar includedAngle,
             const scalar minLen = 0,
             const label minElems = 0,
@@ -202,15 +216,15 @@ public:
         );
 
         //- Construct from dictionary
-        surfaceFeatures(const triSurface&, const dictionary& dict);
+        surfaceFeatures(const triSurface& surf, const dictionary& dict);
 
         //- Construct from file
-        surfaceFeatures(const triSurface&, const fileName& fName);
+        surfaceFeatures(const triSurface& surf, const fileName& fName);
 
         //- Construct from pointField and edgeList (edgeMesh)
         surfaceFeatures
         (
-            const triSurface&,
+            const triSurface& surf,
             const pointField& points,
             const edgeList& edges,
             const scalar mergeTol = 1e-6,
@@ -218,7 +232,7 @@ public:
         );
 
         //- Construct as copy
-        surfaceFeatures(const surfaceFeatures&);
+        surfaceFeatures(const surfaceFeatures& sf);
 
 
     // Member Functions
@@ -299,6 +313,50 @@ public:
                 const scalar includedAngle
             );
 
+            //- Mark edge status inside box as 'NONE'
+            void excludeBox
+            (
+                List<edgeStatus>& edgeStat,
+                const treeBoundBox& bb
+            ) const;
+
+            //- Mark edge status outside box as 'NONE'
+            void subsetBox
+            (
+                List<edgeStatus>& edgeStat,
+                const treeBoundBox& bb
+            ) const;
+
+            //- Mark edge status as 'NONE' for edges inside/outside box.
+            void deleteBox
+            (
+                List<edgeStatus>& edgeStat,
+                const treeBoundBox& bb,
+                const bool removeInside
+            ) const;
+
+            //- If edge does not intersect the plane, mark as 'NONE'
+            void subsetPlane
+            (
+                List<edgeStatus>& edgeStat,
+                const plane& cutPlane
+            ) const;
+
+            //- Mark edges with a single connected face as 'NONE'
+            void excludeOpen(List<edgeStatus>& edgeStat) const;
+
+            //- Divide into multiple normal bins
+            //  - set REGION if != 2 normals
+            //  - set REGION if 2 normals that make feature angle
+            //  - otherwise set NONE and set normals,bins
+            void checkFlatRegionEdge
+            (
+                List<edgeStatus>& edgeStat,
+                const scalar tol,
+                const scalar includedAngle
+            ) const;
+
+
             //- From member feature edges to status per edge.
             List<edgeStatus> toStatus() const;
 
@@ -404,7 +462,7 @@ public:
         // Write
 
             //- Write as dictionary
-            void writeDict(Ostream&) const;
+            void writeDict(Ostream& os) const;
 
             //- Write as dictionary to file
             void write(const fileName& fName) const;
@@ -413,11 +471,14 @@ public:
             //  feature points) for visualization
             void writeObj(const fileName& prefix) const;
 
+            //- Write some information
+            void writeStats(Ostream& os) const;
+
 
 
     // Member Operators
 
-        void operator=(const surfaceFeatures&);
+        void operator=(const surfaceFeatures& rhs);
 
 
 };
diff --git a/src/meshTools/triSurface/triSurfaceLoader/triSurfaceLoader.C b/src/meshTools/triSurface/triSurfaceLoader/triSurfaceLoader.C
index d5e6d4d8e7..d40c008776 100644
--- a/src/meshTools/triSurface/triSurfaceLoader/triSurfaceLoader.C
+++ b/src/meshTools/triSurface/triSurfaceLoader/triSurfaceLoader.C
@@ -28,6 +28,15 @@ License
 #include "Time.H"
 #include "OSspecific.H"
 
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+const Foam::Enum<Foam::triSurfaceLoader::loadingOption>
+Foam::triSurfaceLoader::loadingOptionNames
+(
+    SINGLE_REGION, { "single", "file", "offset", "merge" }
+);
+
+
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
 Foam::triSurfaceLoader::triSurfaceLoader(const fileName& directory)
@@ -201,24 +210,56 @@ Foam::label Foam::triSurfaceLoader::select(const wordReList& matcher)
 }
 
 
-Foam::autoPtr<Foam::triSurface> Foam::triSurfaceLoader::load() const
+Foam::autoPtr<Foam::triSurface> Foam::triSurfaceLoader::load
+(
+    const enum loadingOption opt
+) const
 {
+    autoPtr<triSurface> output;
+
     if (selected_.empty())
     {
-        return autoPtr<triSurface>();
+        return output;
     }
     else if (selected_.size() == 1)
     {
-        return autoPtr<triSurface>(new triSurface(directory_/selected_[0]));
+        output.set(new triSurface(directory_/selected_[0]));
+
+        triSurface& surf = output();
+
+        if
+        (
+            opt == loadingOption::SINGLE_REGION
+         || opt == loadingOption::FILE_REGION
+        )
+        {
+            for (labelledTri& f : surf)
+            {
+                f.region() = 0;
+            }
+
+            if (surf.patches().size())
+            {
+                surf.patches().setSize(1);
+            }
+            else
+            {
+                surf.patches().append
+                (
+                    geometricSurfacePatch(selected_[0].lessExt(), 0)
+                );
+            }
+        }
+
+        return output;
     }
 
+
     List<labelledTri> faces;
     pointField points;
-    label regoff = 0; // region offset
 
-    // collect all patches, preserving names.
-    // This will be horrible for output, but is good if we are relying on
-    // the names for defining baffles.
+    Map<label> oldToNew;
+    HashTable<label> patchNameLookup;
     DynamicList<geometricSurfacePatch> patches(16*selected_.size());
 
     forAll(selected_, surfi)
@@ -227,22 +268,114 @@ Foam::autoPtr<Foam::triSurface> Foam::triSurfaceLoader::load() const
 
         List<labelledTri> addfaces(addsurf.xferFaces());
         List<point> addpoints(addsurf.xferPoints());
-        patches.append(addsurf.patches());
 
+        // Offset the points for all additional surfaces
         if (surfi)
         {
-            const label ptoff = points.size(); // point offset
+            const label ptoff = points.size();
 
-            forAll(addfaces, facei)
+            for (labelledTri& f : addfaces)
             {
-                labelledTri& f = addfaces[facei];
                 forAll(f, fi)
                 {
                     f[fi] += ptoff;
                 }
-                f.region() += regoff;
+            }
+        }
+
+        switch (opt)
+        {
+            case loadingOption::SINGLE_REGION:
+            {
+                for (labelledTri& f : addfaces)
+                {
+                    f.region() = 0;
+                }
+
+                if (patches.empty() && !addsurf.patches().empty())
+                {
+                    patches.append(addsurf.patches().first());
+                }
+
+                break;
             }
 
+            case loadingOption::FILE_REGION:
+            {
+                for (labelledTri& f : addfaces)
+                {
+                    f.region() = surfi;
+                }
+
+                // Use surface name for region
+                patches.append
+                (
+                    geometricSurfacePatch(selected_[surfi].lessExt(), surfi)
+                );
+
+                break;
+            }
+
+            case loadingOption::OFFSET_REGION:
+            {
+                // Collect all patches, preserving names.
+                // This will be horrible for output, but is good if we rely
+                // on the names for defining baffles.
+
+                // region offset
+                const label regoff = patches.size();
+                patches.append(addsurf.patches());
+
+                if (surfi)
+                {
+                    for (labelledTri& f : addfaces)
+                    {
+                        f.region() += regoff;
+                    }
+                }
+                break;
+            }
+
+            case loadingOption::MERGE_REGION:
+            {
+                // Merge by name
+                geometricSurfacePatchList& addpatches = addsurf.patches();
+
+                // Build lookup tables with name->id and localId -> mergedId
+                oldToNew.clear();
+                forAll(addpatches, patchi)
+                {
+                    geometricSurfacePatch& p = addpatches[patchi];
+                    const word& patchName = p.name();
+
+                    label patchId = patches.size();
+                    if (patchNameLookup.insert(patchName, patchId))
+                    {
+                        p.index() = patchId;
+                        patches.append(p);
+                    }
+                    else
+                    {
+                        patchId = patchNameLookup[patchName];
+                    }
+
+                    oldToNew.insert(patchi, patchId);
+                }
+
+                if (surfi)
+                {
+                    // Relabel regions accordingly
+                    for (labelledTri& f : addfaces)
+                    {
+                        f.region() = oldToNew[f.region()];
+                    }
+                }
+                break;
+            }
+        }
+
+        if (surfi)
+        {
             faces.append(addfaces);
             points.append(addpoints);
         }
@@ -251,11 +384,11 @@ Foam::autoPtr<Foam::triSurface> Foam::triSurfaceLoader::load() const
             faces.transfer(addfaces);
             points.transfer(addpoints);
         }
-
-        regoff += addsurf.patches().size();
     }
 
-    return autoPtr<triSurface>(new triSurface(faces, patches, points, true));
+    output.set(new triSurface(faces, patches, points, true));
+
+    return output;
 }
 
 
diff --git a/src/meshTools/triSurface/triSurfaceLoader/triSurfaceLoader.H b/src/meshTools/triSurface/triSurfaceLoader/triSurfaceLoader.H
index aec554ec52..7332026f76 100644
--- a/src/meshTools/triSurface/triSurfaceLoader/triSurfaceLoader.H
+++ b/src/meshTools/triSurface/triSurfaceLoader/triSurfaceLoader.H
@@ -42,6 +42,7 @@ SourceFiles
 
 #include "triSurface.H"
 #include "wordReList.H"
+#include "Enum.H"
 #include "hashedWordList.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@@ -59,6 +60,23 @@ class Time;
 
 class triSurfaceLoader
 {
+public:
+
+    //- The file loading options for triSurfaceLoader
+    enum loadingOption
+    {
+        SINGLE_REGION,  //!< "single" = One region for all files
+        FILE_REGION,    //!< "file"   = One region for each file
+        OFFSET_REGION,  //!< "offset" = Offset regions per file
+        MERGE_REGION    //!< "merge"  = Merge regions by name
+    };
+
+    //- The loading enumeration names
+    static const Enum<loadingOption> loadingOptionNames;
+
+
+private:
+
     // Private data
 
         //- The directory to load from (eg, case/constant/triSurface)
@@ -136,7 +154,10 @@ public:
         label select(const wordReList& matcher);
 
         //- Load a single file, or load and combine multiple selected files
-        autoPtr<triSurface> load() const;
+        autoPtr<triSurface> load
+        (
+            const enum loadingOption opt = loadingOption::OFFSET_REGION
+        ) const;
 
 };
 
diff --git a/src/meshTools/triSurface/triSurfaceTools/triSurfaceCloseness.C b/src/meshTools/triSurface/triSurfaceTools/triSurfaceCloseness.C
new file mode 100644
index 0000000000..3925950b73
--- /dev/null
+++ b/src/meshTools/triSurface/triSurfaceTools/triSurfaceCloseness.C
@@ -0,0 +1,360 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2017 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "triSurfaceTools.H"
+
+#include "triSurface.H"
+#include "triSurfaceMesh.H"
+#include "triSurfaceFields.H"
+#include "MeshedSurface.H"
+#include "OFstream.H"
+#include "unitConversion.H"
+#include "meshTools.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+static void drawHitProblem
+(
+    label fI,
+    const triSurface& surf,
+    const pointField& start,
+    const pointField& faceCentres,
+    const pointField& end,
+    const List<pointIndexHit>& hitInfo
+)
+{
+    Info<< nl << "# findLineAll did not hit its own face."
+        << nl << "# fI " << fI
+        << nl << "# start " << start[fI]
+        << nl << "# f centre " << faceCentres[fI]
+        << nl << "# end " << end[fI]
+        << nl << "# hitInfo " << hitInfo
+        << endl;
+
+    meshTools::writeOBJ(Info, start[fI]);
+    meshTools::writeOBJ(Info, faceCentres[fI]);
+    meshTools::writeOBJ(Info, end[fI]);
+
+    Info<< "l 1 2 3" << endl;
+
+    meshTools::writeOBJ(Info, surf.points()[surf[fI][0]]);
+    meshTools::writeOBJ(Info, surf.points()[surf[fI][1]]);
+    meshTools::writeOBJ(Info, surf.points()[surf[fI][2]]);
+
+    Info<< "f 4 5 6" << endl;
+
+    forAll(hitInfo, hI)
+    {
+        label hFI = hitInfo[hI].index();
+
+        meshTools::writeOBJ(Info, surf.points()[surf[hFI][0]]);
+        meshTools::writeOBJ(Info, surf.points()[surf[hFI][1]]);
+        meshTools::writeOBJ(Info, surf.points()[surf[hFI][2]]);
+
+        Info<< "f "
+            << 3*hI + 7 << " "
+            << 3*hI + 8 << " "
+            << 3*hI + 9
+            << endl;
+    }
+}
+
+} // End namespace Foam
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+Foam::Pair<Foam::tmp<Foam::scalarField>>
+Foam::triSurfaceTools::writeCloseness
+(
+    const Time& runTime,
+    const word& basename,
+    const triSurface& surf,
+    const scalar internalAngleTolerance,
+    const scalar externalAngleTolerance
+)
+{
+    Pair<tmp<scalarField>> tpair
+    (
+        tmp<scalarField>(new scalarField(surf.size(), GREAT)),
+        tmp<scalarField>(new scalarField(surf.size(), GREAT))
+    );
+
+    Info<< "Extracting internal and external closeness of surface." << endl;
+
+    triSurfaceMesh searchSurf
+    (
+        IOobject
+        (
+            basename + ".closeness",
+            runTime.constant(),
+            "triSurface",
+            runTime,
+            IOobject::NO_READ,
+            IOobject::NO_WRITE
+        ),
+        surf
+    );
+
+    // Prepare start and end points for intersection tests
+
+    const vectorField& normals = searchSurf.faceNormals();
+    const scalar span = searchSurf.bounds().mag();
+
+    const scalar externalToleranceCosAngle =
+        Foam::cos
+        (
+            degToRad(180 - externalAngleTolerance)
+        );
+
+    const scalar internalToleranceCosAngle =
+        Foam::cos
+        (
+            degToRad(180 - internalAngleTolerance)
+        );
+
+    Info<< "externalToleranceCosAngle: " << externalToleranceCosAngle << nl
+        << "internalToleranceCosAngle: " << internalToleranceCosAngle << endl;
+
+    // Info<< "span " << span << endl;
+
+    const pointField start(searchSurf.faceCentres() - span*normals);
+    const pointField end(searchSurf.faceCentres() + span*normals);
+    const pointField& faceCentres = searchSurf.faceCentres();
+
+    List<List<pointIndexHit>> allHitInfo;
+
+    // Find all intersections (in order)
+    searchSurf.findLineAll(start, end, allHitInfo);
+
+    scalarField& internalCloseness = tpair[0].ref();
+    scalarField& externalCloseness  = tpair[1].ref();
+
+    forAll(allHitInfo, fI)
+    {
+        const List<pointIndexHit>& hitInfo = allHitInfo[fI];
+
+        if (hitInfo.size() < 1)
+        {
+            drawHitProblem(fI, surf, start, faceCentres, end, hitInfo);
+
+            // FatalErrorInFunction
+            //     << "findLineAll did not hit its own face."
+            //     << exit(FatalError);
+        }
+        else if (hitInfo.size() == 1)
+        {
+            if (!hitInfo[0].hit())
+            {
+                // FatalErrorInFunction
+                //     << "findLineAll did not hit any face."
+                //     << exit(FatalError);
+            }
+            else if (hitInfo[0].index() != fI)
+            {
+                drawHitProblem
+                (
+                    fI,
+                    surf,
+                    start,
+                    faceCentres,
+                    end,
+                    hitInfo
+                );
+
+                // FatalErrorInFunction
+                //     << "findLineAll did not hit its own face."
+                //     << exit(FatalError);
+            }
+        }
+        else
+        {
+            label ownHitI = -1;
+
+            forAll(hitInfo, hI)
+            {
+                // Find the hit on the triangle that launched the ray
+
+                if (hitInfo[hI].index() == fI)
+                {
+                    ownHitI = hI;
+
+                    break;
+                }
+            }
+
+            if (ownHitI < 0)
+            {
+                drawHitProblem
+                (
+                    fI,
+                    surf,
+                    start,
+                    faceCentres,
+                    end,
+                    hitInfo
+                );
+
+                // FatalErrorInFunction
+                //     << "findLineAll did not hit its own face."
+                //     << exit(FatalError);
+            }
+            else if (ownHitI == 0)
+            {
+                // There are no internal hits, the first hit is the
+                // closest external hit
+
+                if
+                (
+                    (
+                        normals[fI]
+                      & normals[hitInfo[ownHitI + 1].index()]
+                    )
+                  < externalToleranceCosAngle
+                )
+                {
+                    externalCloseness[fI] =
+                        mag
+                        (
+                            faceCentres[fI]
+                          - hitInfo[ownHitI + 1].hitPoint()
+                        );
+                }
+            }
+            else if (ownHitI == hitInfo.size() - 1)
+            {
+                // There are no external hits, the last but one hit is
+                // the closest internal hit
+
+                if
+                (
+                    (
+                        normals[fI]
+                      & normals[hitInfo[ownHitI - 1].index()]
+                    )
+                  < internalToleranceCosAngle
+                )
+                {
+                    internalCloseness[fI] =
+                        mag
+                        (
+                            faceCentres[fI]
+                          - hitInfo[ownHitI - 1].hitPoint()
+                        );
+                }
+            }
+            else
+            {
+                if
+                (
+                    (
+                        normals[fI]
+                      & normals[hitInfo[ownHitI + 1].index()]
+                    )
+                  < externalToleranceCosAngle
+                )
+                {
+                    externalCloseness[fI] =
+                        mag
+                        (
+                            faceCentres[fI]
+                          - hitInfo[ownHitI + 1].hitPoint()
+                        );
+                }
+
+                if
+                (
+                    (
+                        normals[fI]
+                      & normals[hitInfo[ownHitI - 1].index()]
+                    )
+                  < internalToleranceCosAngle
+                )
+                {
+                    internalCloseness[fI] =
+                        mag
+                        (
+                            faceCentres[fI]
+                          - hitInfo[ownHitI - 1].hitPoint()
+                        );
+                }
+            }
+        }
+    }
+
+    // write as 'internalCloseness'
+    {
+        triSurfaceScalarField outputField
+        (
+            IOobject
+            (
+                basename + ".internalCloseness",
+                runTime.constant(),
+                "triSurface",
+                runTime,
+                IOobject::NO_READ,
+                IOobject::NO_WRITE
+            ),
+            surf,
+            dimLength,
+            scalarField()
+        );
+
+        outputField.swap(internalCloseness);
+        outputField.write();
+        outputField.swap(internalCloseness);
+    }
+
+    // write as 'externalCloseness'
+    {
+        triSurfaceScalarField outputField
+        (
+            IOobject
+            (
+                basename + ".externalCloseness",
+                runTime.constant(),
+                "triSurface",
+                runTime,
+                IOobject::NO_READ,
+                IOobject::NO_WRITE
+            ),
+            surf,
+            dimLength,
+            scalarField()
+        );
+
+        outputField.swap(externalCloseness);
+        outputField.write();
+        outputField.swap(externalCloseness);
+    }
+
+    return tpair;
+}
+
+
+// ************************************************************************* //
diff --git a/src/meshTools/triSurface/triSurfaceTools/triSurfaceCurvature.C b/src/meshTools/triSurface/triSurfaceTools/triSurfaceCurvature.C
new file mode 100644
index 0000000000..2518b09516
--- /dev/null
+++ b/src/meshTools/triSurface/triSurfaceTools/triSurfaceCurvature.C
@@ -0,0 +1,386 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2017 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "triSurfaceTools.H"
+
+#include "triSurface.H"
+#include "MeshedSurfaces.H"
+#include "triSurfaceFields.H"
+#include "OFstream.H"
+#include "plane.H"
+#include "tensor2D.H"
+#include "symmTensor2D.H"
+#include "scalarMatrices.H"
+#include "transform.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+Foam::scalar Foam::triSurfaceTools::vertexNormalWeight
+(
+    const triFace& f,
+    const label pI,
+    const vector& fN,
+    const UList<point>& points
+)
+{
+    label index = findIndex(f, pI);
+
+    if (index == -1)
+    {
+        FatalErrorInFunction
+            << "Point not in face" << abort(FatalError);
+    }
+
+    const vector e1 = points[f[index]] - points[f[f.fcIndex(index)]];
+    const vector e2 = points[f[index]] - points[f[f.rcIndex(index)]];
+
+    return mag(fN)/(magSqr(e1)*magSqr(e2) + VSMALL);
+}
+
+
+Foam::tmp<Foam::vectorField>
+Foam::triSurfaceTools::vertexNormals(const triSurface& surf)
+{
+    // Weighted average of normals of faces attached to the vertex
+    // Weight = fA / (mag(e0)^2 * mag(e1)^2);
+
+    Info<< "Calculating vertex normals" << endl;
+
+    tmp<vectorField> tfld(new vectorField(surf.nPoints(), Zero));
+    vectorField& pointNormals = tfld.ref();
+
+    const pointField& points = surf.points();
+    const labelListList& pointFaces = surf.pointFaces();
+    const labelList& meshPoints = surf.meshPoints();
+
+    forAll(pointFaces, pI)
+    {
+        const labelList& pFaces = pointFaces[pI];
+
+        forAll(pFaces, fI)
+        {
+            const label facei = pFaces[fI];
+            const triFace& f = surf[facei];
+
+            vector fN = f.normal(points);
+
+            const scalar weight = vertexNormalWeight
+            (
+                f,
+                meshPoints[pI],
+                fN,
+                points
+            );
+
+            pointNormals[pI] += weight*fN;
+        }
+
+        pointNormals[pI] /= mag(pointNormals[pI]) + VSMALL;
+    }
+
+    return tfld;
+}
+
+
+Foam::tmp<Foam::triadField>
+Foam::triSurfaceTools::vertexTriads
+(
+    const triSurface& surf,
+    const vectorField& pointNormals
+)
+{
+    const pointField& points = surf.points();
+    const Map<label>& meshPointMap = surf.meshPointMap();
+
+    tmp<triadField> tfld(new triadField(points.size()));
+    triadField& pointTriads = tfld.ref();
+
+    forAll(points, pI)
+    {
+        const point& pt = points[pI];
+        const vector& normal = pointNormals[meshPointMap[pI]];
+
+        if (mag(normal) < SMALL)
+        {
+            pointTriads[meshPointMap[pI]] = triad::unset;
+            continue;
+        }
+
+        plane p(pt, normal);
+
+        // Pick arbitrary point in plane
+        vector dir1 = pt - p.somePointInPlane(1e-3);
+        dir1 /= mag(dir1);
+
+        vector dir2 = dir1 ^ normal;
+        dir2 /= mag(dir2);
+
+        pointTriads[meshPointMap[pI]] = triad(dir1, dir2, normal);
+    }
+
+    return tfld;
+}
+
+
+Foam::tmp<Foam::scalarField>
+Foam::triSurfaceTools::curvatures
+(
+    const triSurface& surf,
+    const vectorField& pointNormals,
+    const triadField& pointTriads
+)
+{
+    Info<< "Calculating face curvature" << endl;
+
+    const pointField& points = surf.points();
+    const labelList& meshPoints = surf.meshPoints();
+    const Map<label>& meshPointMap = surf.meshPointMap();
+
+    List<symmTensor2D> pointFundamentalTensors
+    (
+        points.size(),
+        symmTensor2D::zero
+    );
+
+    scalarList accumulatedWeights(points.size(), 0.0);
+
+    forAll(surf, fI)
+    {
+        const triFace& f = surf[fI];
+        const edgeList fEdges = f.edges();
+
+        // Calculate the edge vectors and the normal differences
+        vectorField edgeVectors(f.size(), Zero);
+        vectorField normalDifferences(f.size(), Zero);
+
+        forAll(fEdges, feI)
+        {
+            const edge& e = fEdges[feI];
+
+            edgeVectors[feI] = e.vec(points);
+            normalDifferences[feI] =
+               pointNormals[meshPointMap[e[0]]]
+             - pointNormals[meshPointMap[e[1]]];
+        }
+
+        // Set up a local coordinate system for the face
+        const vector& e0 = edgeVectors[0];
+        const vector eN = f.normal(points);
+        const vector e1 = (e0 ^ eN);
+
+        if (magSqr(eN) < ROOTVSMALL)
+        {
+            continue;
+        }
+
+        triad faceCoordSys(e0, e1, eN);
+        faceCoordSys.normalize();
+
+        // Construct the matrix to solve
+        scalarSymmetricSquareMatrix T(3, 0);
+        scalarDiagonalMatrix Z(3, 0);
+
+        // Least Squares
+        for (label i = 0; i < 3; ++i)
+        {
+            scalar x = edgeVectors[i] & faceCoordSys[0];
+            scalar y = edgeVectors[i] & faceCoordSys[1];
+
+            T(0, 0) += sqr(x);
+            T(1, 0) += x*y;
+            T(1, 1) += sqr(x) + sqr(y);
+            T(2, 1) += x*y;
+            T(2, 2) += sqr(y);
+
+            scalar dndx = normalDifferences[i] & faceCoordSys[0];
+            scalar dndy = normalDifferences[i] & faceCoordSys[1];
+
+            Z[0] += dndx*x;
+            Z[1] += dndx*y + dndy*x;
+            Z[2] += dndy*y;
+        }
+
+        // Perform Cholesky decomposition and back substitution.
+        // Decomposed matrix is in T and solution is in Z.
+        LUsolve(T, Z);
+        symmTensor2D secondFundamentalTensor(Z[0], Z[1], Z[2]);
+
+        // Loop over the face points adding the contribution of the face
+        // curvature to the points.
+        forAll(f, fpI)
+        {
+            const label patchPointIndex = meshPointMap[f[fpI]];
+
+            const triad& ptCoordSys = pointTriads[patchPointIndex];
+
+            if (!ptCoordSys.set())
+            {
+                continue;
+            }
+
+            // Rotate faceCoordSys to ptCoordSys
+            tensor rotTensor = rotationTensor(ptCoordSys[2], faceCoordSys[2]);
+            triad rotatedFaceCoordSys = rotTensor & tensor(faceCoordSys);
+
+            // Project the face curvature onto the point plane
+
+            vector2D cmp1
+            (
+                ptCoordSys[0] & rotatedFaceCoordSys[0],
+                ptCoordSys[0] & rotatedFaceCoordSys[1]
+            );
+            vector2D cmp2
+            (
+                ptCoordSys[1] & rotatedFaceCoordSys[0],
+                ptCoordSys[1] & rotatedFaceCoordSys[1]
+            );
+
+            tensor2D projTensor
+            (
+                cmp1,
+                cmp2
+            );
+
+            symmTensor2D projectedFundamentalTensor
+            (
+                projTensor.x() & (secondFundamentalTensor & projTensor.x()),
+                projTensor.x() & (secondFundamentalTensor & projTensor.y()),
+                projTensor.y() & (secondFundamentalTensor & projTensor.y())
+            );
+
+            // Calculate weight
+            // TODO: Voronoi area weighting
+            scalar weight = triSurfaceTools::vertexNormalWeight
+            (
+                f,
+                meshPoints[patchPointIndex],
+                f.normal(points),
+                points
+            );
+
+            // Sum contribution of face to this point
+            pointFundamentalTensors[patchPointIndex] +=
+                weight*projectedFundamentalTensor;
+
+            accumulatedWeights[patchPointIndex] += weight;
+        }
+
+        if (false)
+        {
+            Info<< "Points = " << points[f[0]] << " "
+                << points[f[1]] << " "
+                << points[f[2]] << endl;
+            Info<< "edgeVecs = " << edgeVectors[0] << " "
+                << edgeVectors[1] << " "
+                << edgeVectors[2] << endl;
+            Info<< "normDiff = " << normalDifferences[0] << " "
+                << normalDifferences[1] << " "
+                << normalDifferences[2] << endl;
+            Info<< "faceCoordSys = " << faceCoordSys << endl;
+            Info<< "T = " << T << endl;
+            Info<< "Z = " << Z << endl;
+        }
+    }
+
+    tmp<scalarField> tfld(new scalarField(points.size(), Zero));
+    scalarField& curvatureAtPoints = tfld.ref();
+
+    forAll(curvatureAtPoints, pI)
+    {
+        pointFundamentalTensors[pI] /= (accumulatedWeights[pI] + SMALL);
+
+        vector2D principalCurvatures = eigenValues(pointFundamentalTensors[pI]);
+
+        //scalar curvature =
+        //    (principalCurvatures[0] + principalCurvatures[1])/2;
+        scalar curvature = max
+        (
+            mag(principalCurvatures[0]),
+            mag(principalCurvatures[1])
+        );
+        //scalar curvature = principalCurvatures[0]*principalCurvatures[1];
+
+        curvatureAtPoints[meshPoints[pI]] = curvature;
+    }
+
+    return tfld;
+}
+
+
+Foam::tmp<Foam::scalarField>
+Foam::triSurfaceTools::curvatures
+(
+    const triSurface& surf
+)
+{
+    tmp<vectorField> norms = triSurfaceTools::vertexNormals(surf);
+    tmp<triadField> triads = triSurfaceTools::vertexTriads(surf, norms());
+
+    tmp<scalarField> curv = curvatures(surf, norms(), triads());
+    norms.clear();
+    triads.clear();
+
+    return curv;
+}
+
+
+Foam::tmp<Foam::scalarField>
+Foam::triSurfaceTools::writeCurvature
+(
+    const Time& runTime,
+    const word& basename,
+    const triSurface& surf
+)
+{
+    Info<< "Extracting curvature of surface at the points." << endl;
+
+    tmp<scalarField> tfld = triSurfaceTools::curvatures(surf);
+    scalarField& curv = tfld.ref();
+
+    triSurfacePointScalarField outputField
+    (
+        IOobject
+        (
+            basename + ".curvature",
+            runTime.constant(),
+            "triSurface",
+            runTime,
+            IOobject::NO_READ,
+            IOobject::NO_WRITE
+        ),
+        surf,
+        dimLength,
+        scalarField()
+    );
+
+    outputField.swap(curv);
+    outputField.write();
+    outputField.swap(curv);
+
+    return tfld;
+}
+
+
+// ************************************************************************* //
diff --git a/src/meshTools/triSurface/triSurfaceTools/triSurfaceTools.C b/src/meshTools/triSurface/triSurfaceTools/triSurfaceTools.C
index aec02f8e06..d1da45a001 100644
--- a/src/meshTools/triSurface/triSurfaceTools/triSurfaceTools.C
+++ b/src/meshTools/triSurface/triSurfaceTools/triSurfaceTools.C
@@ -33,7 +33,6 @@ License
 #include "plane.H"
 #include "geompack.H"
 
-
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
 const Foam::label Foam::triSurfaceTools::ANYEDGE = -1;
@@ -1376,54 +1375,6 @@ Foam::labelList Foam::triSurfaceTools::getVertexVertices
 }
 
 
-//// Order vertices consistent with face
-//void Foam::triSurfaceTools::orderVertices
-//(
-//    const labelledTri& f,
-//    const label v1,
-//    const label v2,
-//    label& vA,
-//    label& vB
-//)
-//{
-//    // Order v1, v2 in anticlockwise order.
-//    bool reverse = false;
-//
-//    if (f[0] == v1)
-//    {
-//        if (f[1] != v2)
-//        {
-//            reverse = true;
-//        }
-//    }
-//    else if (f[1] == v1)
-//    {
-//        if (f[2] != v2)
-//        {
-//            reverse = true;
-//        }
-//    }
-//    else
-//    {
-//        if (f[0] != v2)
-//        {
-//            reverse = true;
-//        }
-//    }
-//
-//    if (reverse)
-//    {
-//        vA = v2;
-//        vB = v1;
-//    }
-//    else
-//    {
-//        vA = v1;
-//        vB = v2;
-//    }
-//}
-
-
 // Get the other face using edgeI
 Foam::label Foam::triSurfaceTools::otherFace
 (
@@ -2633,7 +2584,6 @@ void Foam::triSurfaceTools::calcInterpolationWeights
     {
         const point& samplePt = samplePts[i];
 
-
         FixedList<label, 3>& verts = allVerts[i];
         FixedList<scalar, 3>& weights = allWeights[i];
 
diff --git a/src/meshTools/triSurface/triSurfaceTools/triSurfaceTools.H b/src/meshTools/triSurface/triSurfaceTools/triSurfaceTools.H
index d90c862dc9..28960823db 100644
--- a/src/meshTools/triSurface/triSurfaceTools/triSurfaceTools.H
+++ b/src/meshTools/triSurface/triSurfaceTools/triSurfaceTools.H
@@ -27,8 +27,21 @@ Class
 Description
     A collection of tools for triSurface.
 
+Note
+    The curvature calculation is an implementation of the algorithm from:
+    \verbatim
+        "Estimating Curvatures and their Derivatives on Triangle Meshes"
+        by S. Rusinkiewicz
+        3DPVT'04 Proceedings of the 3D Data Processing,
+        Visualization, and Transmission, 2nd International Symposium
+        Pages 486-493
+        http://gfx.cs.princeton.edu/pubs/_2004_ECA/curvpaper.pdf
+    \endverbatim
+
 SourceFiles
     triSurfaceTools.C
+    triSurfaceCloseness.C
+    triSurfaceCurvature.C
 
 \*---------------------------------------------------------------------------*/
 
@@ -37,9 +50,12 @@ SourceFiles
 
 #include "boolList.H"
 #include "pointField.H"
+#include "vectorField.H"
+#include "triadFieldFwd.H"
 #include "DynamicList.H"
 #include "HashSet.H"
 #include "FixedList.H"
+#include "Pair.H"
 #include "vector2D.H"
 #include "triPointRef.H"
 #include "surfaceLocation.H"
@@ -56,6 +72,7 @@ class polyBoundaryMesh;
 class plane;
 class triSurface;
 class face;
+class Time;
 template<class Face> class MeshedSurface;
 
 
@@ -280,16 +297,6 @@ public:
             const edge& e
         );
 
-        ////- Order vertices consistent with face
-        //static void orderVertices
-        //(
-        //    const labelledTri& f,
-        //    const label v1,
-        //    const label v2,
-        //    label& vA,
-        //    label& vB
-        //);
-
         //- Get face connected to edge not facei
         static label otherFace
         (
@@ -490,12 +497,16 @@ public:
 
     // Triangulation and interpolation
 
+        //- Do unconstrained Delaunay of points. Returns triSurface with 3D
+        //  points with z=0. All triangles in region 0.
+        static triSurface delaunay2D(const List<vector2D>&);
+
         //- Calculate linear interpolation weights for point (guaranteed to be
         //  inside triangle)
         static void calcInterpolationWeights
         (
-            const triPointRef&,
-            const point&,
+            const triPointRef& tri,
+            const point& p,
             FixedList<scalar, 3>& weights
         );
 
@@ -510,13 +521,86 @@ public:
         (
             const triSurface& s,
             const pointField& samplePts,
-            List<FixedList<label, 3>>& verts,
-            List<FixedList<scalar, 3>>& weights
+            List<FixedList<label, 3>>& allVerts,
+            List<FixedList<scalar, 3>>& allWeights
         );
 
-        //- Do unconstrained Delaunay of points. Returns triSurface with 3D
-        //  points with z=0. All triangles in region 0.
-        static triSurface delaunay2D(const List<vector2D>&);
+
+    // Curvature
+
+        //- Weighting for normals of faces attached to vertex
+        static scalar vertexNormalWeight
+        (
+            const triFace& f,
+            const label pI,
+            const vector& fN,
+            const UList<point>& points
+        );
+
+        //- Weighted average of normals of attached faces
+        static tmp<vectorField> vertexNormals(const triSurface& surf);
+
+        //- Local coordinate-system for each point normal
+        static tmp<triadField> vertexTriads
+        (
+            const triSurface& surf,
+            const vectorField& pointNormals
+        );
+
+        //- Surface curvatures at the vertex points
+        static tmp<scalarField> curvatures
+        (
+            const triSurface& surf,
+            const vectorField& pointNormals,
+            const triadField& pointTriads
+        );
+
+        //- Surface curvatures at the vertex points
+        static tmp<scalarField> curvatures
+        (
+            const triSurface& surf
+        );
+
+        //- Write surface curvature at the vertex points and return the field
+        static tmp<scalarField> writeCurvature
+        (
+            const Time& runTime,
+            const word& basename,
+            const triSurface& surf
+        );
+
+
+    // Closeness
+
+        //- Check and write internal/external closeness fields
+        static Pair<tmp<scalarField>> writeCloseness
+        (
+            const Time& runTime,
+            const word& basename,
+            const triSurface& surf,
+            const scalar internalAngleTolerance = 45,
+            const scalar externalAngleTolerance = 10
+        );
+
+
+    // Feature Proximity
+
+        //- Calculate feature proximity
+        scalarField featureProximity
+        (
+            const triSurface& surf,
+            const scalar searchDistance
+        );
+
+        //- Check and write internal/external closeness fields
+        static void writeFeatureProximity
+        (
+            const Time& runTime,
+            const word& basename,
+            const triSurface& surf,
+            const bool writeVTK,
+            const scalar searchDistance
+        );
 
 
     // Surface checking functionality
diff --git a/src/randomProcesses/noise/noiseModels/noiseModel/noiseModel.C b/src/randomProcesses/noise/noiseModels/noiseModel/noiseModel.C
index b98f00c8bd..84ba84ca4b 100644
--- a/src/randomProcesses/noise/noiseModels/noiseModel/noiseModel.C
+++ b/src/randomProcesses/noise/noiseModels/noiseModel/noiseModel.C
@@ -92,6 +92,28 @@ Foam::scalar Foam::noiseModel::checkUniformTimeStep
 }
 
 
+bool Foam::noiseModel::validateBounds(const scalarList& p) const
+{
+    forAll(p, i)
+    {
+        if ((p[i] < minPressure_) || (p[i] > maxPressure_))
+        {
+            WarningInFunction
+                << "Pressure data at position " << i
+                << " is outside of permitted bounds:" << nl
+                << "    pressure: " << p[i] << nl
+                << "    minimum pressure: " << minPressure_ << nl
+                << "    maximum pressure: " << maxPressure_ << nl
+                << endl;
+
+            return false;
+        }
+    }
+
+    return true;
+}
+
+
 Foam::label Foam::noiseModel::findStartTimeIndex
 (
     const instantList& allTimes,
@@ -141,6 +163,8 @@ Foam::noiseModel::noiseModel(const dictionary& dict, const bool readFields)
     startTime_(0),
     windowModelPtr_(),
     graphFormat_("raw"),
+    minPressure_(-0.5*VGREAT),
+    maxPressure_(0.5*VGREAT),
     outputPrefix_(),
     writePrmsf_(true),
     writeSPL_(true),
@@ -178,6 +202,8 @@ bool Foam::noiseModel::read(const dictionary& dict)
     }
     dict.readIfPresent("startTime", startTime_);
     dict.readIfPresent("graphFormat", graphFormat_);
+    dict.readIfPresent("minPressure", minPressure_);
+    dict.readIfPresent("maxPressure", maxPressure_);
     dict.readIfPresent("outputPrefix", outputPrefix_);
 
     // Check number of samples  - must be a power of 2 for our FFT
@@ -225,6 +251,8 @@ bool Foam::noiseModel::read(const dictionary& dict)
 
     windowModelPtr_ = windowModel::New(dict, nSamples_);
 
+    Info<< nl << endl;
+
     return true;
 }
 
diff --git a/src/randomProcesses/noise/noiseModels/noiseModel/noiseModel.H b/src/randomProcesses/noise/noiseModels/noiseModel/noiseModel.H
index 7b625096ce..b74e053dd0 100644
--- a/src/randomProcesses/noise/noiseModels/noiseModel/noiseModel.H
+++ b/src/randomProcesses/noise/noiseModels/noiseModel/noiseModel.H
@@ -126,7 +126,7 @@ protected:
         //- Upper frequency limit, default = 10kHz
         scalar fUpper_;
 
-        //- Flag to indicate that custom frequenct bounds are being used
+        //- Flag to indicate that custom frequency bounds are being used
         bool customBounds_;
 
         //- Start time, default = 0s
@@ -139,6 +139,15 @@ protected:
         word graphFormat_;
 
 
+        // Data validation
+
+            //- Min pressure value
+            scalar minPressure_;
+
+            //- Min pressure value
+            scalar maxPressure_;
+
+
         // Write options
 
             //- Output  file prefix, default = ''
@@ -176,6 +185,9 @@ protected:
             const scalarList& times
         ) const;
 
+        //- Return true if all pressure data is within min/max bounds
+        bool validateBounds(const scalarList& p) const;
+
         //- Find and return start time index
         label findStartTimeIndex
         (
diff --git a/src/randomProcesses/noise/noiseModels/pointNoise/pointNoise.C b/src/randomProcesses/noise/noiseModels/pointNoise/pointNoise.C
index befb166061..209febd8c9 100644
--- a/src/randomProcesses/noise/noiseModels/pointNoise/pointNoise.C
+++ b/src/randomProcesses/noise/noiseModels/pointNoise/pointNoise.C
@@ -84,8 +84,16 @@ void pointNoise::processData
     Info<< "    read " << t.size() << " values" << nl << endl;
 
     Info<< "Creating noise FFT" << endl;
+
     const scalar deltaT = checkUniformTimeStep(t);
 
+    if (!validateBounds(p))
+    {
+        Info<< "No noise data generated" << endl;
+        return;
+    }
+
+
     // Determine the windowing
     windowModelPtr_->validate(t.size());
     const windowModel& win = windowModelPtr_();
diff --git a/src/regionCoupled/derivedFvPatchFields/energyRegionCoupled/energyRegionCoupledFvPatchScalarField.C b/src/regionCoupled/derivedFvPatchFields/energyRegionCoupled/energyRegionCoupledFvPatchScalarField.C
index 2935936e8b..72afb55582 100644
--- a/src/regionCoupled/derivedFvPatchFields/energyRegionCoupled/energyRegionCoupledFvPatchScalarField.C
+++ b/src/regionCoupled/derivedFvPatchFields/energyRegionCoupled/energyRegionCoupledFvPatchScalarField.C
@@ -134,7 +134,7 @@ kappa() const
                     << " on mesh " << this->db().name() << " patch "
                     << patch().name()
                     << " could not find a method in. Methods are:  "
-                    << methodTypeNames_.toc()
+                    << methodTypeNames_
                     << " Not turbulenceModel or thermophysicalProperties"
                     << " were found"
                     << exit(FatalError);
diff --git a/src/regionModels/pyrolysisModels/noPyrolysis/noPyrolysis.H b/src/regionModels/pyrolysisModels/noPyrolysis/noPyrolysis.H
index b7220ce97d..67cec6fdc0 100644
--- a/src/regionModels/pyrolysisModels/noPyrolysis/noPyrolysis.H
+++ b/src/regionModels/pyrolysisModels/noPyrolysis/noPyrolysis.H
@@ -22,7 +22,7 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Class
-    Foam::noPyrolysis
+    Foam::regionModels::pyrolysisModels::noPyrolysis
 
 Description
     Dummy surface pyrolysis model for 'none'
diff --git a/src/regionModels/pyrolysisModels/pyrolysisModel/pyrolysisModelCollection.H b/src/regionModels/pyrolysisModels/pyrolysisModel/pyrolysisModelCollection.H
index 06d3597c62..c91e727bf4 100644
--- a/src/regionModels/pyrolysisModels/pyrolysisModel/pyrolysisModelCollection.H
+++ b/src/regionModels/pyrolysisModels/pyrolysisModel/pyrolysisModelCollection.H
@@ -22,7 +22,7 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Class
-    Foam::pyrolysisModelCollection
+    Foam::regionModels::pyrolysisModels::pyrolysisModelCollection
 
 Description
     A centralized pyrolysis collection.
diff --git a/src/regionModels/pyrolysisModels/reactingOneDim/reactingOneDim.H b/src/regionModels/pyrolysisModels/reactingOneDim/reactingOneDim.H
index 5a6afe07eb..ed25394608 100644
--- a/src/regionModels/pyrolysisModels/reactingOneDim/reactingOneDim.H
+++ b/src/regionModels/pyrolysisModels/reactingOneDim/reactingOneDim.H
@@ -22,7 +22,7 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Class
-    Foam::reactingOneDim
+    Foam::regionModels::pyrolysisModels::reactingOneDim
 
 Description
     Reacting, 1-D pyrolysis model
diff --git a/src/regionModels/pyrolysisModels/thermo/thermo.H b/src/regionModels/pyrolysisModels/thermo/thermo.H
index 82489aa0cb..8efd72872a 100644
--- a/src/regionModels/pyrolysisModels/thermo/thermo.H
+++ b/src/regionModels/pyrolysisModels/thermo/thermo.H
@@ -22,7 +22,7 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Class
-    Foam::thermo
+    Foam::regionModels::pyrolysisModels::thermo
 
 Description
     Pyrolysis model which solves only the energy equation in the region.
diff --git a/src/regionModels/regionModel/regionModel/regionModel.H b/src/regionModels/regionModel/regionModel/regionModel.H
index 9fc179d082..3c30cb0f1c 100644
--- a/src/regionModels/regionModel/regionModel/regionModel.H
+++ b/src/regionModels/regionModel/regionModel/regionModel.H
@@ -22,7 +22,7 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Class
-    Foam::regionModel
+    Foam::regionModels::regionModel
 
 Description
     Base class for region models
diff --git a/src/regionModels/regionModel/regionModel1D/regionModel1D.H b/src/regionModels/regionModel/regionModel1D/regionModel1D.H
index 3663a94648..1a54526962 100644
--- a/src/regionModels/regionModel/regionModel1D/regionModel1D.H
+++ b/src/regionModels/regionModel/regionModel1D/regionModel1D.H
@@ -22,7 +22,7 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Class
-    Foam::regionModel1D
+    Foam::regionModels::regionModel1D
 
 Description
     Base class for 1-D region models
diff --git a/src/regionModels/regionModel/regionModelFunctionObject/regionModelFunctionObject/regionModelFunctionObject.H b/src/regionModels/regionModel/regionModelFunctionObject/regionModelFunctionObject/regionModelFunctionObject.H
index 2f96d310ca..e39918ed61 100644
--- a/src/regionModels/regionModel/regionModelFunctionObject/regionModelFunctionObject/regionModelFunctionObject.H
+++ b/src/regionModels/regionModel/regionModelFunctionObject/regionModelFunctionObject/regionModelFunctionObject.H
@@ -22,7 +22,7 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Class
-    Foam::regionModelFunctionObject
+    Foam::regionModels::regionModelFunctionObject
 
 Description
     Region model function object base class
diff --git a/src/regionModels/regionModel/regionModelFunctionObject/regionModelFunctionObject/regionModelFunctionObjectList.H b/src/regionModels/regionModel/regionModelFunctionObject/regionModelFunctionObject/regionModelFunctionObjectList.H
index 159ee4714d..0e292b8b9e 100644
--- a/src/regionModels/regionModel/regionModelFunctionObject/regionModelFunctionObject/regionModelFunctionObjectList.H
+++ b/src/regionModels/regionModel/regionModelFunctionObject/regionModelFunctionObject/regionModelFunctionObjectList.H
@@ -22,7 +22,7 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Class
-    Foam::regionModelFunctionObjectList
+    Foam::regionModels::regionModelFunctionObjectList
 
 Description
     List of cloud function objects
diff --git a/src/regionModels/regionModel/singleLayerRegion/singleLayerRegion.H b/src/regionModels/regionModel/singleLayerRegion/singleLayerRegion.H
index ccababa272..4dbb1eda97 100644
--- a/src/regionModels/regionModel/singleLayerRegion/singleLayerRegion.H
+++ b/src/regionModels/regionModel/singleLayerRegion/singleLayerRegion.H
@@ -22,7 +22,7 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Class
-    Foam::singleLayerRegion
+    Foam::regionModels::singleLayerRegion
 
 Description
     Base class for single layer region models
diff --git a/src/regionModels/surfaceFilmModels/kinematicSingleLayer/kinematicSingleLayer.H b/src/regionModels/surfaceFilmModels/kinematicSingleLayer/kinematicSingleLayer.H
index bedb0957d7..8c3325b7af 100644
--- a/src/regionModels/surfaceFilmModels/kinematicSingleLayer/kinematicSingleLayer.H
+++ b/src/regionModels/surfaceFilmModels/kinematicSingleLayer/kinematicSingleLayer.H
@@ -22,7 +22,7 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Class
-    Foam::kinematicSingleLayer
+    Foam::regionModels::surfaceFilmModels::kinematicSingleLayer
 
 Description
     Kinematic form of single-cell layer surface film model
diff --git a/src/regionModels/surfaceFilmModels/noFilm/noFilm.H b/src/regionModels/surfaceFilmModels/noFilm/noFilm.H
index 20e115fecf..7421b64ac9 100644
--- a/src/regionModels/surfaceFilmModels/noFilm/noFilm.H
+++ b/src/regionModels/surfaceFilmModels/noFilm/noFilm.H
@@ -22,7 +22,7 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Class
-    Foam::noFilm
+    Foam::regionModels::surfaceFilmModels::noFilm
 
 Description
     Dummy surface film model for 'none'
diff --git a/src/regionModels/surfaceFilmModels/submodels/filmSubModelBase.H b/src/regionModels/surfaceFilmModels/submodels/filmSubModelBase.H
index 9160fa2469..8d4cfd54c5 100644
--- a/src/regionModels/surfaceFilmModels/submodels/filmSubModelBase.H
+++ b/src/regionModels/surfaceFilmModels/submodels/filmSubModelBase.H
@@ -22,7 +22,7 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Class
-    Foam::subModelBase
+    Foam::regionModels::surfaceFilmModels::filmSubModelBase
 
 Description
     Base class for surface film sub-models
diff --git a/src/regionModels/surfaceFilmModels/submodels/kinematic/filmThermoModel/constantFilmThermo/constantFilmThermo.H b/src/regionModels/surfaceFilmModels/submodels/kinematic/filmThermoModel/constantFilmThermo/constantFilmThermo.H
index e5ef5baf90..eed60f09e0 100644
--- a/src/regionModels/surfaceFilmModels/submodels/kinematic/filmThermoModel/constantFilmThermo/constantFilmThermo.H
+++ b/src/regionModels/surfaceFilmModels/submodels/kinematic/filmThermoModel/constantFilmThermo/constantFilmThermo.H
@@ -22,7 +22,7 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Class
-    Foam::constantFilmThermo
+    Foam::regionModels::surfaceFilmModels::constantFilmThermo
 
 Description
     Constant thermo model
diff --git a/src/regionModels/surfaceFilmModels/submodels/kinematic/filmThermoModel/filmThermoModel/filmThermoModel.H b/src/regionModels/surfaceFilmModels/submodels/kinematic/filmThermoModel/filmThermoModel/filmThermoModel.H
index d6a4c296a1..efa1de6517 100644
--- a/src/regionModels/surfaceFilmModels/submodels/kinematic/filmThermoModel/filmThermoModel/filmThermoModel.H
+++ b/src/regionModels/surfaceFilmModels/submodels/kinematic/filmThermoModel/filmThermoModel/filmThermoModel.H
@@ -22,7 +22,7 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Class
-    Foam::filmThermoModel
+    Foam::regionModels::surfaceFilmModels::filmThermoModel
 
 Description
     Base class for film thermo models
diff --git a/src/regionModels/surfaceFilmModels/submodels/kinematic/filmThermoModel/liquidFilmThermo/liquidFilmThermo.H b/src/regionModels/surfaceFilmModels/submodels/kinematic/filmThermoModel/liquidFilmThermo/liquidFilmThermo.H
index 20863e6fda..4b3b2b9ae6 100644
--- a/src/regionModels/surfaceFilmModels/submodels/kinematic/filmThermoModel/liquidFilmThermo/liquidFilmThermo.H
+++ b/src/regionModels/surfaceFilmModels/submodels/kinematic/filmThermoModel/liquidFilmThermo/liquidFilmThermo.H
@@ -22,7 +22,7 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Class
-    Foam::liquidFilmThermo
+    Foam::regionModels::surfaceFilmModels::liquidFilmThermo
 
 Description
     Liquid thermo model
diff --git a/src/regionModels/surfaceFilmModels/submodels/kinematic/force/forceList/forceList.H b/src/regionModels/surfaceFilmModels/submodels/kinematic/force/forceList/forceList.H
index bc6c28c1e2..55ae056d3f 100644
--- a/src/regionModels/surfaceFilmModels/submodels/kinematic/force/forceList/forceList.H
+++ b/src/regionModels/surfaceFilmModels/submodels/kinematic/force/forceList/forceList.H
@@ -22,7 +22,7 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Class
-    Foam::forceList
+    Foam::regionModels::surfaceFilmModels::forceList
 
 Description
     List container for film sources
diff --git a/src/regionModels/surfaceFilmModels/submodels/kinematic/force/thermocapillaryForce/thermocapillaryForce.H b/src/regionModels/surfaceFilmModels/submodels/kinematic/force/thermocapillaryForce/thermocapillaryForce.H
index ee2f1a0b54..283ebbf9b1 100644
--- a/src/regionModels/surfaceFilmModels/submodels/kinematic/force/thermocapillaryForce/thermocapillaryForce.H
+++ b/src/regionModels/surfaceFilmModels/submodels/kinematic/force/thermocapillaryForce/thermocapillaryForce.H
@@ -22,7 +22,7 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Class
-    Foam::thermocapillaryForce
+    Foam::regionModels::surfaceFilmModels::thermocapillaryForce
 
 Description
     Thermocapillary force
diff --git a/src/regionModels/surfaceFilmModels/submodels/kinematic/injectionModel/BrunDrippingInjection/BrunDrippingInjection.H b/src/regionModels/surfaceFilmModels/submodels/kinematic/injectionModel/BrunDrippingInjection/BrunDrippingInjection.H
index 91ba6a84ec..6c08188bb0 100644
--- a/src/regionModels/surfaceFilmModels/submodels/kinematic/injectionModel/BrunDrippingInjection/BrunDrippingInjection.H
+++ b/src/regionModels/surfaceFilmModels/submodels/kinematic/injectionModel/BrunDrippingInjection/BrunDrippingInjection.H
@@ -22,7 +22,7 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Class
-    Foam::BrunDrippingInjection
+    Foam::regionModels::surfaceFilmModels::BrunDrippingInjection
 
 Description
     Film Dripping mass transfer model.
diff --git a/src/regionModels/surfaceFilmModels/submodels/kinematic/injectionModel/curvatureSeparation/curvatureSeparation.H b/src/regionModels/surfaceFilmModels/submodels/kinematic/injectionModel/curvatureSeparation/curvatureSeparation.H
index 8d788ede24..9ee2cd0a4c 100644
--- a/src/regionModels/surfaceFilmModels/submodels/kinematic/injectionModel/curvatureSeparation/curvatureSeparation.H
+++ b/src/regionModels/surfaceFilmModels/submodels/kinematic/injectionModel/curvatureSeparation/curvatureSeparation.H
@@ -22,7 +22,7 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Class
-    Foam::curvatureSeparation
+    Foam::regionModels::surfaceFilmModels::curvatureSeparation
 
 Description
     Curvature film separation model
diff --git a/src/regionModels/surfaceFilmModels/submodels/kinematic/injectionModel/drippingInjection/drippingInjection.H b/src/regionModels/surfaceFilmModels/submodels/kinematic/injectionModel/drippingInjection/drippingInjection.H
index 27525a2dd6..46476c822b 100644
--- a/src/regionModels/surfaceFilmModels/submodels/kinematic/injectionModel/drippingInjection/drippingInjection.H
+++ b/src/regionModels/surfaceFilmModels/submodels/kinematic/injectionModel/drippingInjection/drippingInjection.H
@@ -22,10 +22,10 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Class
-    Foam::drippingInjection
+    Foam::regionModels::surfaceFilmModels::drippingInjection
 
 Description
-    Film Dripping mass transfer model.
+    Film dripping mass transfer model.
 
     If the film mass exceeds that needed to generate a valid parcel, the
     equivalent mass is removed from the film.
diff --git a/src/regionModels/surfaceFilmModels/submodels/kinematic/injectionModel/injectionModelList/injectionModelList.H b/src/regionModels/surfaceFilmModels/submodels/kinematic/injectionModel/injectionModelList/injectionModelList.H
index ce98fac5c2..4976743206 100644
--- a/src/regionModels/surfaceFilmModels/submodels/kinematic/injectionModel/injectionModelList/injectionModelList.H
+++ b/src/regionModels/surfaceFilmModels/submodels/kinematic/injectionModel/injectionModelList/injectionModelList.H
@@ -22,7 +22,7 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Class
-    Foam::injectionModelList
+    Foam::regionModels::surfaceFilmModels::injectionModelList
 
 Description
     List container for film injection models
diff --git a/src/regionModels/surfaceFilmModels/submodels/thermo/filmRadiationModel/constantRadiation/constantRadiation.H b/src/regionModels/surfaceFilmModels/submodels/thermo/filmRadiationModel/constantRadiation/constantRadiation.H
index f33dc1dbe8..e342bd880c 100644
--- a/src/regionModels/surfaceFilmModels/submodels/thermo/filmRadiationModel/constantRadiation/constantRadiation.H
+++ b/src/regionModels/surfaceFilmModels/submodels/thermo/filmRadiationModel/constantRadiation/constantRadiation.H
@@ -22,7 +22,7 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Class
-    Foam::constantRadiation
+    Foam::regionModels::surfaceFilmModels::constantRadiation
 
 Description
     Film constant radiation model.  The constant radiative flux is specified
diff --git a/src/regionModels/surfaceFilmModels/submodels/thermo/filmRadiationModel/filmRadiationModel/filmRadiationModel.H b/src/regionModels/surfaceFilmModels/submodels/thermo/filmRadiationModel/filmRadiationModel/filmRadiationModel.H
index b73e91cf23..eccd964c62 100644
--- a/src/regionModels/surfaceFilmModels/submodels/thermo/filmRadiationModel/filmRadiationModel/filmRadiationModel.H
+++ b/src/regionModels/surfaceFilmModels/submodels/thermo/filmRadiationModel/filmRadiationModel/filmRadiationModel.H
@@ -22,7 +22,7 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Class
-    Foam::filmRadiationModel
+    Foam::regionModels::surfaceFilmModels::filmRadiationModel
 
 Description
     Base class for film radiation models
diff --git a/src/regionModels/surfaceFilmModels/submodels/thermo/filmRadiationModel/noRadiation/noRadiation.H b/src/regionModels/surfaceFilmModels/submodels/thermo/filmRadiationModel/noRadiation/noRadiation.H
index fa24e18c25..605104320f 100644
--- a/src/regionModels/surfaceFilmModels/submodels/thermo/filmRadiationModel/noRadiation/noRadiation.H
+++ b/src/regionModels/surfaceFilmModels/submodels/thermo/filmRadiationModel/noRadiation/noRadiation.H
@@ -22,7 +22,7 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Class
-    Foam::noRadiation
+    Foam::regionModels::surfaceFilmModels::noRadiation
 
 Description
     Dummy radiation model for 'none' option
diff --git a/src/regionModels/surfaceFilmModels/submodels/thermo/filmRadiationModel/primaryRadiation/primaryRadiation.H b/src/regionModels/surfaceFilmModels/submodels/thermo/filmRadiationModel/primaryRadiation/primaryRadiation.H
index d2b9da585c..b93561d49e 100644
--- a/src/regionModels/surfaceFilmModels/submodels/thermo/filmRadiationModel/primaryRadiation/primaryRadiation.H
+++ b/src/regionModels/surfaceFilmModels/submodels/thermo/filmRadiationModel/primaryRadiation/primaryRadiation.H
@@ -22,7 +22,7 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Class
-    Foam::primaryRadiation
+    Foam::regionModels::surfaceFilmModels::primaryRadiation
 
 Description
     Radiation model whereby the radiative heat flux is mapped from the primary
diff --git a/src/regionModels/surfaceFilmModels/submodels/thermo/filmRadiationModel/standardRadiation/standardRadiation.H b/src/regionModels/surfaceFilmModels/submodels/thermo/filmRadiationModel/standardRadiation/standardRadiation.H
index 191f1dab9d..7375ef79ec 100644
--- a/src/regionModels/surfaceFilmModels/submodels/thermo/filmRadiationModel/standardRadiation/standardRadiation.H
+++ b/src/regionModels/surfaceFilmModels/submodels/thermo/filmRadiationModel/standardRadiation/standardRadiation.H
@@ -22,7 +22,7 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Class
-    Foam::standardRadiation
+    Foam::regionModels::surfaceFilmModels::standardRadiation
 
 Description
     Standard radiation model
diff --git a/src/regionModels/surfaceFilmModels/submodels/thermo/filmViscosityModel/ArrheniusViscosity/ArrheniusViscosity.H b/src/regionModels/surfaceFilmModels/submodels/thermo/filmViscosityModel/ArrheniusViscosity/ArrheniusViscosity.H
index 94d726c314..079cfd588a 100644
--- a/src/regionModels/surfaceFilmModels/submodels/thermo/filmViscosityModel/ArrheniusViscosity/ArrheniusViscosity.H
+++ b/src/regionModels/surfaceFilmModels/submodels/thermo/filmViscosityModel/ArrheniusViscosity/ArrheniusViscosity.H
@@ -22,7 +22,7 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Class
-    Foam::ArrheniusViscosity
+    Foam::regionModels::surfaceFilmModels::ArrheniusViscosity
 
 Description
     The Arrhenius temperature-dependent viscosity model multiplies the viscosity
diff --git a/src/regionModels/surfaceFilmModels/submodels/thermo/filmViscosityModel/constantViscosity/constantViscosity.H b/src/regionModels/surfaceFilmModels/submodels/thermo/filmViscosityModel/constantViscosity/constantViscosity.H
index 4b9f1aad40..c93d0dddb1 100644
--- a/src/regionModels/surfaceFilmModels/submodels/thermo/filmViscosityModel/constantViscosity/constantViscosity.H
+++ b/src/regionModels/surfaceFilmModels/submodels/thermo/filmViscosityModel/constantViscosity/constantViscosity.H
@@ -22,7 +22,7 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Class
-    Foam::constantViscosity
+    Foam::regionModels::surfaceFilmModels::constantViscosity
 
 Description
     Constant viscosity model
diff --git a/src/regionModels/surfaceFilmModels/submodels/thermo/filmViscosityModel/filmViscosityModel/filmViscosityModel.H b/src/regionModels/surfaceFilmModels/submodels/thermo/filmViscosityModel/filmViscosityModel/filmViscosityModel.H
index e7bf66ea0a..042ea759bd 100644
--- a/src/regionModels/surfaceFilmModels/submodels/thermo/filmViscosityModel/filmViscosityModel/filmViscosityModel.H
+++ b/src/regionModels/surfaceFilmModels/submodels/thermo/filmViscosityModel/filmViscosityModel/filmViscosityModel.H
@@ -22,7 +22,7 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Class
-    Foam::filmViscosityModel
+    Foam::regionModels::surfaceFilmModels::filmViscosityModel
 
 Description
     Base class for surface film viscosity models
diff --git a/src/regionModels/surfaceFilmModels/submodels/thermo/filmViscosityModel/liquidViscosity/liquidViscosity.H b/src/regionModels/surfaceFilmModels/submodels/thermo/filmViscosityModel/liquidViscosity/liquidViscosity.H
index 5b9e5d3ab0..1614fade8e 100644
--- a/src/regionModels/surfaceFilmModels/submodels/thermo/filmViscosityModel/liquidViscosity/liquidViscosity.H
+++ b/src/regionModels/surfaceFilmModels/submodels/thermo/filmViscosityModel/liquidViscosity/liquidViscosity.H
@@ -22,7 +22,7 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Class
-    Foam::liquidViscosity
+    Foam::regionModels::surfaceFilmModels::liquidViscosity
 
 Description
     liquidViscosity viscosity model
diff --git a/src/regionModels/surfaceFilmModels/submodels/thermo/filmViscosityModel/thixotropicViscosity/thixotropicViscosity.H b/src/regionModels/surfaceFilmModels/submodels/thermo/filmViscosityModel/thixotropicViscosity/thixotropicViscosity.H
index a25f75f8b5..ff2b3d0c3b 100644
--- a/src/regionModels/surfaceFilmModels/submodels/thermo/filmViscosityModel/thixotropicViscosity/thixotropicViscosity.H
+++ b/src/regionModels/surfaceFilmModels/submodels/thermo/filmViscosityModel/thixotropicViscosity/thixotropicViscosity.H
@@ -22,7 +22,7 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Class
-    Foam::thixotropicViscosity
+    Foam::regionModels::surfaceFilmModels::thixotropicViscosity
 
 Description
     Thixotropic viscosity model based on the evolution of the structural
diff --git a/src/regionModels/surfaceFilmModels/submodels/thermo/heatTransferModel/constantHeatTransfer/constantHeatTransfer.H b/src/regionModels/surfaceFilmModels/submodels/thermo/heatTransferModel/constantHeatTransfer/constantHeatTransfer.H
index b36eeb9a67..6fc13fbf5e 100644
--- a/src/regionModels/surfaceFilmModels/submodels/thermo/heatTransferModel/constantHeatTransfer/constantHeatTransfer.H
+++ b/src/regionModels/surfaceFilmModels/submodels/thermo/heatTransferModel/constantHeatTransfer/constantHeatTransfer.H
@@ -22,7 +22,7 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Class
-    Foam::constantHeatTransfer
+    Foam::regionModels::surfaceFilmModels::constantHeatTransfer
 
 Description
     Constant heat transfer model
diff --git a/src/regionModels/surfaceFilmModels/submodels/thermo/heatTransferModel/heatTransferModel/heatTransferModel.H b/src/regionModels/surfaceFilmModels/submodels/thermo/heatTransferModel/heatTransferModel/heatTransferModel.H
index 31bf1207db..80d87b7e6d 100644
--- a/src/regionModels/surfaceFilmModels/submodels/thermo/heatTransferModel/heatTransferModel/heatTransferModel.H
+++ b/src/regionModels/surfaceFilmModels/submodels/thermo/heatTransferModel/heatTransferModel/heatTransferModel.H
@@ -22,7 +22,7 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Class
-    Foam::heatTransferModel
+    Foam::regionModels::surfaceFilmModels::heatTransferModel
 
 Description
     Base class for film heat transfer models
diff --git a/src/regionModels/surfaceFilmModels/submodels/thermo/heatTransferModel/mappedConvectiveHeatTransfer/mappedConvectiveHeatTransfer.H b/src/regionModels/surfaceFilmModels/submodels/thermo/heatTransferModel/mappedConvectiveHeatTransfer/mappedConvectiveHeatTransfer.H
index caf980bdf2..2016eb7b72 100644
--- a/src/regionModels/surfaceFilmModels/submodels/thermo/heatTransferModel/mappedConvectiveHeatTransfer/mappedConvectiveHeatTransfer.H
+++ b/src/regionModels/surfaceFilmModels/submodels/thermo/heatTransferModel/mappedConvectiveHeatTransfer/mappedConvectiveHeatTransfer.H
@@ -22,7 +22,7 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Class
-    Foam::mappedConvectiveHeatTransfer
+    Foam::regionModels::surfaceFilmModels::mappedConvectiveHeatTransfer
 
 Description
     Convective heat transfer model based on a re-working of a Nusselt number
diff --git a/src/regionModels/surfaceFilmModels/submodels/thermo/phaseChangeModel/noPhaseChange/noPhaseChange.H b/src/regionModels/surfaceFilmModels/submodels/thermo/phaseChangeModel/noPhaseChange/noPhaseChange.H
index cbcd3d65e1..9fbe036bfc 100644
--- a/src/regionModels/surfaceFilmModels/submodels/thermo/phaseChangeModel/noPhaseChange/noPhaseChange.H
+++ b/src/regionModels/surfaceFilmModels/submodels/thermo/phaseChangeModel/noPhaseChange/noPhaseChange.H
@@ -22,7 +22,7 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Class
-    Foam::noPhaseChange
+    Foam::regionModels::surfaceFilmModels::noPhaseChange
 
 Description
     Dummy phase change model for 'none'
diff --git a/src/regionModels/surfaceFilmModels/submodels/thermo/phaseChangeModel/phaseChangeModel/phaseChangeModel.H b/src/regionModels/surfaceFilmModels/submodels/thermo/phaseChangeModel/phaseChangeModel/phaseChangeModel.H
index bf87c33281..7a59ad4d47 100644
--- a/src/regionModels/surfaceFilmModels/submodels/thermo/phaseChangeModel/phaseChangeModel/phaseChangeModel.H
+++ b/src/regionModels/surfaceFilmModels/submodels/thermo/phaseChangeModel/phaseChangeModel/phaseChangeModel.H
@@ -22,7 +22,7 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Class
-    Foam::phaseChangeModel
+    Foam::regionModels::surfaceFilmModels::phaseChangeModel
 
 Description
     Base class for surface film phase change models
diff --git a/src/regionModels/surfaceFilmModels/submodels/thermo/phaseChangeModel/solidification/solidification.H b/src/regionModels/surfaceFilmModels/submodels/thermo/phaseChangeModel/solidification/solidification.H
index 6ceeba82f4..e355cd3736 100644
--- a/src/regionModels/surfaceFilmModels/submodels/thermo/phaseChangeModel/solidification/solidification.H
+++ b/src/regionModels/surfaceFilmModels/submodels/thermo/phaseChangeModel/solidification/solidification.H
@@ -22,7 +22,7 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Class
-    Foam::solidification
+    Foam::regionModels::surfaceFilmModels::solidification
 
 Description
     Solidification phase change model where all film mass is converted when the
diff --git a/src/regionModels/surfaceFilmModels/submodels/thermo/phaseChangeModel/standardPhaseChange/standardPhaseChange.H b/src/regionModels/surfaceFilmModels/submodels/thermo/phaseChangeModel/standardPhaseChange/standardPhaseChange.H
index ae28ae4b50..5c9cbfc369 100644
--- a/src/regionModels/surfaceFilmModels/submodels/thermo/phaseChangeModel/standardPhaseChange/standardPhaseChange.H
+++ b/src/regionModels/surfaceFilmModels/submodels/thermo/phaseChangeModel/standardPhaseChange/standardPhaseChange.H
@@ -22,7 +22,7 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Class
-    Foam::standardPhaseChange
+    Foam::regionModels::surfaceFilmModels::standardPhaseChange
 
 Description
     Standard phase change model with modification for boiling
diff --git a/src/regionModels/surfaceFilmModels/thermoSingleLayer/thermoSingleLayer.H b/src/regionModels/surfaceFilmModels/thermoSingleLayer/thermoSingleLayer.H
index 941aa73145..e770d8b56c 100644
--- a/src/regionModels/surfaceFilmModels/thermoSingleLayer/thermoSingleLayer.H
+++ b/src/regionModels/surfaceFilmModels/thermoSingleLayer/thermoSingleLayer.H
@@ -22,7 +22,7 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Class
-    Foam::thermoSingleLayer
+    Foam::regionModels::surfaceFilmModels::thermoSingleLayer
 
 Description
     Thermodynamic form of single-cell layer surface film model
diff --git a/src/regionModels/thermalBaffleModels/noThermo/noThermo.H b/src/regionModels/thermalBaffleModels/noThermo/noThermo.H
index 9fed26466a..85e4396a37 100644
--- a/src/regionModels/thermalBaffleModels/noThermo/noThermo.H
+++ b/src/regionModels/thermalBaffleModels/noThermo/noThermo.H
@@ -22,7 +22,7 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Class
-    Foam::noThermo
+    Foam::regionModels::thermalBaffleModels::noThermo
 
 Description
     Dummy surface pyrolysis model for 'none'
diff --git a/src/regionModels/thermalBaffleModels/thermalBaffle/thermalBaffle.H b/src/regionModels/thermalBaffleModels/thermalBaffle/thermalBaffle.H
index c96cf9cf73..48768dca93 100644
--- a/src/regionModels/thermalBaffleModels/thermalBaffle/thermalBaffle.H
+++ b/src/regionModels/thermalBaffleModels/thermalBaffle/thermalBaffle.H
@@ -22,7 +22,7 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Class
-    Foam::thermalBaffle
+    Foam::regionModels::thermalBaffleModels::thermalBaffle
 
 Description
     2D thermal baffle
diff --git a/src/regionModels/thermalBaffleModels/thermalBaffleModel/thermalBaffleModel.H b/src/regionModels/thermalBaffleModels/thermalBaffleModel/thermalBaffleModel.H
index 01c3cbe559..2084de8b02 100644
--- a/src/regionModels/thermalBaffleModels/thermalBaffleModel/thermalBaffleModel.H
+++ b/src/regionModels/thermalBaffleModels/thermalBaffleModel/thermalBaffleModel.H
@@ -22,7 +22,7 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Class
-    Foam::thermalBaffleModel
+    Foam::regionModels::thermalBaffleModels::thermalBaffleModel
 
 Description
 
diff --git a/src/thermophysicalModels/radiation/submodels/boundaryRadiationProperties/boundaryRadiationPropertiesPatch.C b/src/thermophysicalModels/radiation/submodels/boundaryRadiationProperties/boundaryRadiationPropertiesPatch.C
index d5785cbbd9..369c9788a2 100644
--- a/src/thermophysicalModels/radiation/submodels/boundaryRadiationProperties/boundaryRadiationPropertiesPatch.C
+++ b/src/thermophysicalModels/radiation/submodels/boundaryRadiationProperties/boundaryRadiationPropertiesPatch.C
@@ -222,7 +222,8 @@ Foam::radiation::boundaryRadiationPropertiesPatch::emissivity
         default:
         {
             FatalErrorInFunction
-                << "Please set 'mode' to one of " << methodTypeNames_.toc()
+                << "Please set 'mode' to one of "
+                << methodTypeNames_
                 << exit(FatalError);
         }
         break;
@@ -302,7 +303,7 @@ Foam::radiation::boundaryRadiationPropertiesPatch::absorptivity
             FatalErrorInFunction
                 << "Unimplemented method " << method_ << endl
                 << "Please set 'mode' to one of "
-                << methodTypeNames_.toc()
+                << methodTypeNames_
                 << exit(FatalError);
         }
         break;
@@ -382,7 +383,7 @@ Foam::radiation::boundaryRadiationPropertiesPatch::transmissivity
             FatalErrorInFunction
                 << "Unimplemented method " << method_ << endl
                 << "Please set 'mode' to one of "
-                << methodTypeNames_.toc()
+                << methodTypeNames_
                 << exit(FatalError);
         }
         break;
diff --git a/wmake/rules/General/general b/wmake/rules/General/general
index 4dffa627e3..bd57f37e2f 100644
--- a/wmake/rules/General/general
+++ b/wmake/rules/General/general
@@ -1,5 +1,5 @@
 #-------------------------------*- makefile -*---------------------------------
-WM_VERSION = OPENFOAM_PLUS=1612
+WM_VERSION = OPENFOAM_PLUS=1706
 
 AR         = ar
 ARFLAGS    = cr