diff --git a/etc/caseDicts/postProcessing/graphs/sampleDict.cfg b/etc/caseDicts/postProcessing/graphs/sampleDict.cfg
index e1a67308bb..0062a22848 100644
--- a/etc/caseDicts/postProcessing/graphs/sampleDict.cfg
+++ b/etc/caseDicts/postProcessing/graphs/sampleDict.cfg
@@ -12,8 +12,8 @@ setFormat   raw;
 
 setConfig
 {
-    type    uniform;   // midPoint, midPointAndFace
-    axis    distance;  // x, y, z, xyz
+    type    lineUniform; // lineCell, lineCellFace
+    axis    distance;    // x, y, z, xyz
     nPoints 100;
 }
 
diff --git a/etc/caseDicts/postProcessing/graphs/singleGraph b/etc/caseDicts/postProcessing/graphs/singleGraph
index 76389e6881..8b8b416cc8 100644
--- a/etc/caseDicts/postProcessing/graphs/singleGraph
+++ b/etc/caseDicts/postProcessing/graphs/singleGraph
@@ -19,7 +19,7 @@ fields  (U p);
 #includeEtc "caseDicts/postProcessing/graphs/sampleDict.cfg"
 
 // Override settings here, e.g.
-// setConfig { type midPoint; }
+// setConfig { type lineCell; }
 
 // Must be last entry
 #includeEtc "caseDicts/postProcessing/graphs/graph.cfg"
diff --git a/etc/caseDicts/postProcessing/probes/boundaryCloud b/etc/caseDicts/postProcessing/probes/boundaryPoints
similarity index 82%
rename from etc/caseDicts/postProcessing/probes/boundaryCloud
rename to etc/caseDicts/postProcessing/probes/boundaryPoints
index 5847972f15..8ca75c9938 100644
--- a/etc/caseDicts/postProcessing/probes/boundaryCloud
+++ b/etc/caseDicts/postProcessing/probes/boundaryPoints
@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 Description
-    Writes out values of fields at a cloud of points, interpolated to
+    Writes out values of fields at a specified list of points, interpolated to
     specified boundary patches.
 
 \*---------------------------------------------------------------------------*/
@@ -22,6 +22,6 @@ maxDistance 0.1;
 
 patches     (".*");
 
-#includeEtc "caseDicts/postProcessing/probes/boundaryCloud.cfg"
+#includeEtc "caseDicts/postProcessing/probes/boundaryPoints.cfg"
 
 // ************************************************************************* //
diff --git a/etc/caseDicts/postProcessing/probes/boundaryCloud.cfg b/etc/caseDicts/postProcessing/probes/boundaryPoints.cfg
similarity index 88%
rename from etc/caseDicts/postProcessing/probes/boundaryCloud.cfg
rename to etc/caseDicts/postProcessing/probes/boundaryPoints.cfg
index d90c94122b..7993a883ea 100644
--- a/etc/caseDicts/postProcessing/probes/boundaryCloud.cfg
+++ b/etc/caseDicts/postProcessing/probes/boundaryPoints.cfg
@@ -6,13 +6,13 @@
 |    \\/     M anipulation  |                                                 |
 \*---------------------------------------------------------------------------*/
 
-#includeEtc "caseDicts/postProcessing/probes/cloud.cfg"
+#includeEtc "caseDicts/postProcessing/probes/points.cfg"
 
 sets
 (
-    cloud
+    points
     {
-        type        patchCloud;
+        type        boundaryPoints;
         axis        xyz;
         points      $points;
         maxDistance $maxDistance;
diff --git a/etc/caseDicts/postProcessing/probes/internalCloud b/etc/caseDicts/postProcessing/probes/internalPoints
similarity index 80%
rename from etc/caseDicts/postProcessing/probes/internalCloud
rename to etc/caseDicts/postProcessing/probes/internalPoints
index a2f8794f44..ed2d56f6f7 100644
--- a/etc/caseDicts/postProcessing/probes/internalCloud
+++ b/etc/caseDicts/postProcessing/probes/internalPoints
@@ -6,7 +6,7 @@
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 Description
-    Writes out values of fields interpolated to a specified cloud of points.
+    Writes out values of fields interpolated to a specified list of points.
 
 \*---------------------------------------------------------------------------*/
 
@@ -16,6 +16,6 @@ points
     (0 0 0)
 );
 
-#includeEtc "caseDicts/postProcessing/probes/internalCloud.cfg"
+#includeEtc "caseDicts/postProcessing/probes/internalPoints.cfg"
 
 // ************************************************************************* //
diff --git a/etc/caseDicts/postProcessing/probes/internalCloud.cfg b/etc/caseDicts/postProcessing/probes/internalPoints.cfg
similarity index 88%
rename from etc/caseDicts/postProcessing/probes/internalCloud.cfg
rename to etc/caseDicts/postProcessing/probes/internalPoints.cfg
index 19bf54f898..557dbe3286 100644
--- a/etc/caseDicts/postProcessing/probes/internalCloud.cfg
+++ b/etc/caseDicts/postProcessing/probes/internalPoints.cfg
@@ -6,13 +6,13 @@
 |    \\/     M anipulation  |                                                 |
 \*---------------------------------------------------------------------------*/
 
-#includeEtc "caseDicts/postProcessing/probes/cloud.cfg"
+#includeEtc "caseDicts/postProcessing/probes/points.cfg"
 
 sets
 (
-    cloud
+    points
     {
-        type    cloud;
+        type    points;
         axis    xyz;
         points  $points;
     }
diff --git a/etc/caseDicts/postProcessing/probes/cloud.cfg b/etc/caseDicts/postProcessing/probes/points.cfg
similarity index 100%
rename from etc/caseDicts/postProcessing/probes/cloud.cfg
rename to etc/caseDicts/postProcessing/probes/points.cfg
diff --git a/etc/caseDicts/postProcessing/visualization/streamlines.cfg b/etc/caseDicts/postProcessing/visualization/streamlines.cfg
index e352ad963d..94a1c149a9 100644
--- a/etc/caseDicts/postProcessing/visualization/streamlines.cfg
+++ b/etc/caseDicts/postProcessing/visualization/streamlines.cfg
@@ -22,7 +22,7 @@ cloudName       particleTracks;
 
 seedSampleSet
 {
-    type            uniform;
+    type            lineUniform;
     axis            x;
     start           $start;
     end             $end;
diff --git a/etc/templates/axisymmetricJet/system/graph b/etc/templates/axisymmetricJet/system/graph
index 72b4d2b3cf..94de0e4bc8 100644
--- a/etc/templates/axisymmetricJet/system/graph
+++ b/etc/templates/axisymmetricJet/system/graph
@@ -28,7 +28,7 @@ graph
     (
         centreline
         {
-            type    uniform;
+            type    lineUniform;
             axis    x;
             start   ( 0  1e-6 0);
             end     (25  1e-6 0);
diff --git a/src/functionObjects/field/interfaceHeight/interfaceHeight.C b/src/functionObjects/field/interfaceHeight/interfaceHeight.C
index 325d47ebe9..1ec9c3dc0e 100644
--- a/src/functionObjects/field/interfaceHeight/interfaceHeight.C
+++ b/src/functionObjects/field/interfaceHeight/interfaceHeight.C
@@ -28,7 +28,7 @@ License
 #include "interpolation.H"
 #include "IOmanip.H"
 #include "meshSearch.H"
-#include "midPointAndFaceSet.H"
+#include "lineCellFaceSet.H"
 #include "Time.H"
 #include "uniformDimensionedFields.H"
 #include "volFields.H"
@@ -72,7 +72,7 @@ void Foam::functionObjects::interfaceHeight::writePositions()
     forAll(locations_, li)
     {
         // Create a set along a ray projected in the direction of gravity
-        const midPointAndFaceSet set
+        const lineCellFaceSet set
         (
             "",
             mesh_,
diff --git a/src/functionObjects/field/interfaceHeight/interfaceHeight.H b/src/functionObjects/field/interfaceHeight/interfaceHeight.H
index d443e1f03b..41e35c02d4 100644
--- a/src/functionObjects/field/interfaceHeight/interfaceHeight.H
+++ b/src/functionObjects/field/interfaceHeight/interfaceHeight.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2017 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2017-2018 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -61,8 +61,8 @@ SourceFiles
 #define interfaceHeight_H
 
 #include "fvMeshFunctionObject.H"
-#include "midPointAndFaceSet.H"
 #include "logFiles.H"
+#include "point.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
diff --git a/src/sampling/Make/files b/src/sampling/Make/files
index 433f174105..60c824d7c7 100644
--- a/src/sampling/Make/files
+++ b/src/sampling/Make/files
@@ -2,20 +2,21 @@ probes/probes.C
 probes/patchProbes.C
 probes/probesGrouping.C
 
-sampledSet/circle/circleSet.C
-sampledSet/cloud/cloudSet.C
-sampledSet/patchCloud/patchCloudSet.C
-sampledSet/polyLine/polyLineSet.C
-sampledSet/face/faceOnlySet.C
-sampledSet/midPoint/midPointSet.C
-sampledSet/midPointAndFace/midPointAndFaceSet.C
-sampledSet/patchSeed/patchSeedSet.C
 sampledSet/sampledSet/sampledSet.C
 sampledSet/sampledSets/sampledSets.C
 sampledSet/sampledSets/sampledSetsGrouping.C
-sampledSet/triSurfaceMeshPointSet/triSurfaceMeshPointSet.C
-sampledSet/uniform/uniformSet.C
-sampledSet/array/arraySet.C
+sampledSet/arcUniform/arcUniformSet.C
+sampledSet/boxUniform/boxUniformSet.C
+sampledSet/circleRandom/circleRandomSet.C
+sampledSet/lineCell/lineCellSet.C
+sampledSet/lineCellFace/lineCellFaceSet.C
+sampledSet/lineFace/lineFaceSet.C
+sampledSet/lineUniform/lineUniformSet.C
+sampledSet/boundaryPoints/boundaryPointsSet.C
+sampledSet/boundaryRandom/boundaryRandomSet.C
+sampledSet/points/pointsSet.C
+sampledSet/sphereRandom/sphereRandomSet.C
+sampledSet/triSurfaceMesh/triSurfaceMeshSet.C
 
 cuttingPlane/cuttingPlane.C
 
diff --git a/src/sampling/sampledSet/arcUniform/arcUniformSet.C b/src/sampling/sampledSet/arcUniform/arcUniformSet.C
new file mode 100644
index 0000000000..0957f4f301
--- /dev/null
+++ b/src/sampling/sampledSet/arcUniform/arcUniformSet.C
@@ -0,0 +1,148 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2018 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "arcUniformSet.H"
+#include "sampledSet.H"
+#include "meshSearch.H"
+#include "DynamicList.H"
+#include "polyMesh.H"
+#include "addToRunTimeSelectionTable.H"
+#include "word.H"
+#include "unitConversion.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(arcUniformSet, 0);
+    addToRunTimeSelectionTable(sampledSet, arcUniformSet, word);
+}
+
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+void Foam::arcUniformSet::calcSamples
+(
+    DynamicList<point>& samplingPts,
+    DynamicList<label>& samplingCells,
+    DynamicList<label>& samplingFaces,
+    DynamicList<label>& samplingSegments,
+    DynamicList<scalar>& samplingCurveDist
+) const
+{
+    const vector axis1 = radial_ - (radial_ & normal_)*normal_;
+    const vector axis2 = normal_ ^ axis1;
+    const scalar radius = mag(axis1);
+
+    for (label i = 0; i < nPoints_; ++ i)
+    {
+        const scalar t = scalar(i)/(nPoints_ - 1);
+        const scalar theta = (1 - t)*startAngle_ + t*endAngle_;
+        const scalar c = cos(theta), s = sin(theta);
+
+        const point pt = centre_ + c*axis1 + s*axis2;
+        const label celli = searchEngine().findCell(pt);
+
+        if (celli != -1)
+        {
+            samplingPts.append(pt);
+            samplingCells.append(celli);
+            samplingFaces.append(-1);
+            samplingSegments.append(samplingSegments.size());
+            samplingCurveDist.append(radius*theta);
+        }
+    }
+}
+
+
+void Foam::arcUniformSet::genSamples()
+{
+    // Storage for sample points
+    DynamicList<point> samplingPts;
+    DynamicList<label> samplingCells;
+    DynamicList<label> samplingFaces;
+    DynamicList<label> samplingSegments;
+    DynamicList<scalar> samplingCurveDist;
+
+    calcSamples
+    (
+        samplingPts,
+        samplingCells,
+        samplingFaces,
+        samplingSegments,
+        samplingCurveDist
+    );
+
+    samplingPts.shrink();
+    samplingCells.shrink();
+    samplingFaces.shrink();
+    samplingSegments.shrink();
+    samplingCurveDist.shrink();
+
+    setSamples
+    (
+        samplingPts,
+        samplingCells,
+        samplingFaces,
+        samplingSegments,
+        samplingCurveDist
+    );
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::arcUniformSet::arcUniformSet
+(
+    const word& name,
+    const polyMesh& mesh,
+    const meshSearch& searchEngine,
+    const dictionary& dict
+)
+:
+    sampledSet(name, mesh, searchEngine, dict),
+    centre_(dict.lookup("centre")),
+    normal_(normalised(dict.lookupType<vector>("normal"))),
+    radial_(dict.lookupType<vector>("radial")),
+    startAngle_(readScalar(dict.lookup("startAngle"))),
+    endAngle_(readScalar(dict.lookup("endAngle"))),
+    nPoints_(dict.lookupType<scalar>("nPoints"))
+{
+    genSamples();
+
+    if (debug)
+    {
+        write(Info);
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::arcUniformSet::~arcUniformSet()
+{}
+
+
+// ************************************************************************* //
diff --git a/src/sampling/sampledSet/arcUniform/arcUniformSet.H b/src/sampling/sampledSet/arcUniform/arcUniformSet.H
new file mode 100644
index 0000000000..56c6ec4853
--- /dev/null
+++ b/src/sampling/sampledSet/arcUniform/arcUniformSet.H
@@ -0,0 +1,150 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2018 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::arcUniformSet
+
+Description
+    Uniform samples along an arc
+
+Usage
+    \table
+        Property    | Description                            | Req'd? | Default
+        centre      | Centre of the circle                   | yes    |
+        normal      | Direction normal to the plane of the circle  | yes |
+        radial      | Vector from the centre to a point on the arc | yes |
+        startAngle  | The angle of the start of the arc in radians | yes |
+        endAngle    | The angle of the end of the arc in radians | yes |
+        nPoints     | The number of points                   | yes    |
+        axis        | The coordinate axis that is written    | yes    |
+    \endtable
+
+    Example specification:
+    \verbatim
+    {
+        type        arcUniform;
+        centre      (0.95 0 0.25);
+        normal      (1 0 0);
+        radial      (0 0 0.25);
+        startAngle  -1.57079633;
+        endAngle    0.52359878;
+        nPoints     200;
+        axis        x;
+    }
+    \endverbatim
+
+SourceFiles
+    arcUniformSet.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef arcUniformSet_H
+#define arcUniformSet_H
+
+#include "sampledSet.H"
+#include "DynamicList.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                          Class arcUniformSet Declaration
+\*---------------------------------------------------------------------------*/
+
+class arcUniformSet
+:
+    public sampledSet
+{
+    // Private data
+
+        // Arc definition
+
+            //- Centre of the circle of which the arc is a part
+            const point centre_;
+
+            //- Normal direction to the circle of which the arc is a part
+            const vector normal_;
+
+            //- Radial vector from the centre to the point on the arc from
+            //  which the angles are measured
+            const vector radial_;
+
+            //- Start angle
+            const scalar startAngle_;
+
+            //- End angle
+            const scalar endAngle_;
+
+            //- Number of points spaced along the arc
+            const label nPoints_;
+
+
+    // Private Member Functions
+
+        //- Calculate all the sampling points
+        void calcSamples
+        (
+            DynamicList<point>& samplingPts,
+            DynamicList<label>& samplingCells,
+            DynamicList<label>& samplingFaces,
+            DynamicList<label>& samplingSegments,
+            DynamicList<scalar>& samplingCurveDist
+        ) const;
+
+        //- Uses calcSamples to obtain samples and copies them into *this
+        void genSamples();
+
+public:
+
+    //- Runtime type information
+    TypeName("arcUniform");
+
+
+    // Constructors
+
+        //- Construct from dictionary
+        arcUniformSet
+        (
+            const word& name,
+            const polyMesh& mesh,
+            const meshSearch& searchEngine,
+            const dictionary& dict
+        );
+
+
+    // Destructor
+    virtual ~arcUniformSet();
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/sampling/sampledSet/patchCloud/patchCloudSet.C b/src/sampling/sampledSet/boundaryPoints/boundaryPointsSet.C
similarity index 51%
rename from src/sampling/sampledSet/patchCloud/patchCloudSet.C
rename to src/sampling/sampledSet/boundaryPoints/boundaryPointsSet.C
index 8bbe49cb4c..61a25e1e86 100644
--- a/src/sampling/sampledSet/patchCloud/patchCloudSet.C
+++ b/src/sampling/sampledSet/boundaryPoints/boundaryPointsSet.C
@@ -23,28 +23,27 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-#include "patchCloudSet.H"
+#include "boundaryPointsSet.H"
 #include "polyMesh.H"
 #include "addToRunTimeSelectionTable.H"
 #include "treeBoundBox.H"
 #include "treeDataFace.H"
 #include "Time.H"
 #include "meshTools.H"
-// For 'nearInfo' helper class only
 #include "mappedPatchBase.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
 namespace Foam
 {
-    defineTypeNameAndDebug(patchCloudSet, 0);
-    addToRunTimeSelectionTable(sampledSet, patchCloudSet, word);
+    defineTypeNameAndDebug(boundaryPointsSet, 0);
+    addToRunTimeSelectionTable(sampledSet, boundaryPointsSet, word);
 }
 
 
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 
-void Foam::patchCloudSet::calcSamples
+void Foam::boundaryPointsSet::calcSamples
 (
     DynamicList<point>& samplingPts,
     DynamicList<label>& samplingCells,
@@ -53,174 +52,144 @@ void Foam::patchCloudSet::calcSamples
     DynamicList<scalar>& samplingCurveDist
 ) const
 {
-    if (debug)
-    {
-        Info<< "patchCloudSet : sampling on patches :" << endl;
-    }
-
-    // Construct search tree for all patch faces.
-    label sz = 0;
-    forAllConstIter(labelHashSet, patchSet_, iter)
+    // Construct a single list of all patch faces
+    label nPatchFaces = 0;
+    forAllConstIter(labelHashSet, patches_, iter)
     {
         const polyPatch& pp = mesh().boundaryMesh()[iter.key()];
-
-        sz += pp.size();
-
-        if (debug)
-        {
-            Info<< "    " << pp.name() << " size " << pp.size() << endl;
-        }
+        nPatchFaces += pp.size();
     }
-
-    labelList patchFaces(sz);
-    sz = 0;
-    treeBoundBox bb(point::max, point::min);
-    forAllConstIter(labelHashSet, patchSet_, iter)
+    labelList patchFaces(nPatchFaces);
+    nPatchFaces = 0;
+    forAllConstIter(labelHashSet, patches_, iter)
     {
         const polyPatch& pp = mesh().boundaryMesh()[iter.key()];
-
         forAll(pp, i)
         {
-            patchFaces[sz++] = pp.start()+i;
+            patchFaces[nPatchFaces++] = pp.start()+i;
         }
-
-        // Do not do reduction.
-        const boundBox patchBb(pp.points(), pp.meshPoints(), false);
-
-        bb.min() = min(bb.min(), patchBb.min());
-        bb.max() = max(bb.max(), patchBb.max());
     }
-    bb = bb.extend(1e-4);
 
+    // Construct a processor-local bound box
+    treeBoundBox patchBB(point::max, point::min);
+    forAllConstIter(labelHashSet, patches_, iter)
+    {
+        const polyPatch& pp = mesh().boundaryMesh()[iter.key()];
+        const boundBox patchBb(pp.points(), pp.meshPoints(), false);
+        patchBB.min() = min(patchBB.min(), patchBb.min());
+        patchBB.max() = max(patchBB.max(), patchBb.max());
+    }
+    patchBB = patchBB.extend(1e-4);
+
+    // Create a search tree
     indexedOctree<treeDataFace> patchTree
     (
         treeDataFace    // all information needed to search faces
         (
-            false,      // do not cache bb
+            false,      // do not cache the bound box
             mesh(),
-            patchFaces  // boundary faces only
+            patchFaces
         ),
-        bb,             // overall search domain
-        8,              // maxLevel
-        10,             // leafsize
-        3.0             // duplicity
+        patchBB,        // overall search box
+        8,              // maximum number of levels
+        10,             // how many elements per leaf
+        3.0             // in how many leaves is a shape on average
     );
 
     // Force calculation of face-diagonal decomposition
     (void)mesh().tetBasePtIs();
 
-
-    // All the info for nearest. Construct to miss
-    List<mappedPatchBase::nearInfo> nearest(sampleCoords_.size());
-
-    forAll(sampleCoords_, sampleI)
+    // Generate the nearest patch information for each sampling point
+    List<mappedPatchBase::nearInfo> nearest(points_.size());
+    forAll(points_, sampleI)
     {
-        const point& sample = sampleCoords_[sampleI];
+        const point& sample = points_[sampleI];
 
-        pointIndexHit& nearInfo = nearest[sampleI].first();
+        pointIndexHit& nearHit = nearest[sampleI].first();
+        scalar& nearDist = nearest[sampleI].second().first();
+        label& nearProc = nearest[sampleI].second().second();
 
-        // Find the nearest locally
+        // Find the nearest
         if (patchFaces.size())
         {
-            nearInfo = patchTree.findNearest(sample, sqr(searchDist_));
+            nearHit = patchTree.findNearest(sample, sqr(maxDistance_));
         }
         else
         {
-            nearInfo.setMiss();
+            nearHit.setMiss();
         }
 
-
-        // Fill in the distance field and the processor field
-        if (!nearInfo.hit())
+        // Fill in the information
+        if (nearHit.hit())
         {
-            nearest[sampleI].second().first() = Foam::sqr(great);
-            nearest[sampleI].second().second() = Pstream::myProcNo();
+            nearHit.setIndex(patchFaces[nearHit.index()]);
+            nearDist = magSqr(nearHit.hitPoint() - sample);
+            nearProc = Pstream::myProcNo();
         }
         else
         {
-            // Set nearest to mesh face label
-            nearInfo.setIndex(patchFaces[nearInfo.index()]);
-
-            nearest[sampleI].second().first() = magSqr
-            (
-                nearInfo.hitPoint()
-              - sample
-            );
-            nearest[sampleI].second().second() = Pstream::myProcNo();
+            nearHit.setIndex(-1);
+            nearDist = Foam::sqr(great);
+            nearProc = Pstream::myProcNo();
         }
     }
 
-
-    // Find nearest.
+    // Reduce to get the nearest patch locations globally
     Pstream::listCombineGather(nearest, mappedPatchBase::nearestEqOp());
     Pstream::listCombineScatter(nearest);
 
-
+    // Dump connecting lines from the sampling points to the hit locations
     if (debug && Pstream::master())
     {
-        OFstream str
-        (
-            mesh().time().path()
-          / name()
-          + "_nearest.obj"
-        );
-        Info<< "Dumping mapping as lines from supplied points to"
-            << " nearest patch face to file " << str.name() << endl;
+        OFstream str(mesh().time().path() / name() + "_nearest.obj");
 
-        label vertI = 0;
+        label verti = 0;
 
         forAll(nearest, i)
         {
             if (nearest[i].first().hit())
             {
-                meshTools::writeOBJ(str, sampleCoords_[i]);
-                vertI++;
+                meshTools::writeOBJ(str, points_[i]);
+                verti++;
                 meshTools::writeOBJ(str, nearest[i].first().hitPoint());
-                vertI++;
-                str << "l " << vertI-1 << ' ' << vertI << nl;
+                verti++;
+                str << "l " << verti - 1 << ' ' << verti << nl;
             }
         }
     }
 
-
     // Store the sampling locations on the nearest processor
     forAll(nearest, sampleI)
     {
-        const pointIndexHit& nearInfo = nearest[sampleI].first();
+        const pointIndexHit& nearHit = nearest[sampleI].first();
+        const label& nearProc = nearest[sampleI].second().second();
 
-        if (nearInfo.hit())
+        if (nearHit.hit())
         {
-            if (nearest[sampleI].second().second() == Pstream::myProcNo())
+            if (nearProc == Pstream::myProcNo())
             {
-                label facei = nearInfo.index();
+                label facei = nearHit.index();
 
-                samplingPts.append(nearInfo.hitPoint());
+                samplingPts.append(nearHit.hitPoint());
                 samplingCells.append(mesh().faceOwner()[facei]);
                 samplingFaces.append(facei);
                 samplingSegments.append(0);
-                samplingCurveDist.append(1.0 * sampleI);
+                samplingCurveDist.append(sampleI);
             }
         }
         else
         {
-            // No processor found point near enough. Mark with special value
-            // which is intercepted when interpolating
-            if (Pstream::master())
-            {
-                samplingPts.append(sampleCoords_[sampleI]);
-                samplingCells.append(-1);
-                samplingFaces.append(-1);
-                samplingSegments.append(0);
-                samplingCurveDist.append(1.0 * sampleI);
-            }
+            WarningInFunction
+                << "Unable to find location on patches " << patches_
+                << " for the point " << points_[sampleI]
+                << " within a distance of " << maxDistance_ << endl;
         }
     }
 }
 
 
-void Foam::patchCloudSet::genSamples()
+void Foam::boundaryPointsSet::genSamples()
 {
-    // Storage for sample points
     DynamicList<point> samplingPts;
     DynamicList<label> samplingCells;
     DynamicList<label> samplingFaces;
@@ -255,32 +224,7 @@ void Foam::patchCloudSet::genSamples()
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
-Foam::patchCloudSet::patchCloudSet
-(
-    const word& name,
-    const polyMesh& mesh,
-    const meshSearch& searchEngine,
-    const word& axis,
-    const List<point>& sampleCoords,
-    const labelHashSet& patchSet,
-    const scalar searchDist
-)
-:
-    sampledSet(name, mesh, searchEngine, axis),
-    sampleCoords_(sampleCoords),
-    patchSet_(patchSet),
-    searchDist_(searchDist)
-{
-    genSamples();
-
-    if (debug)
-    {
-        write(Info);
-    }
-}
-
-
-Foam::patchCloudSet::patchCloudSet
+Foam::boundaryPointsSet::boundaryPointsSet
 (
     const word& name,
     const polyMesh& mesh,
@@ -289,15 +233,15 @@ Foam::patchCloudSet::patchCloudSet
 )
 :
     sampledSet(name, mesh, searchEngine, dict),
-    sampleCoords_(dict.lookup("points")),
-    patchSet_
+    points_(dict.lookup("points")),
+    patches_
     (
         mesh.boundaryMesh().patchSet
         (
             wordReList(dict.lookup("patches"))
         )
     ),
-    searchDist_(readScalar(dict.lookup("maxDistance")))
+    maxDistance_(readScalar(dict.lookup("maxDistance")))
 {
     genSamples();
 
@@ -310,7 +254,7 @@ Foam::patchCloudSet::patchCloudSet
 
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 
-Foam::patchCloudSet::~patchCloudSet()
+Foam::boundaryPointsSet::~boundaryPointsSet()
 {}
 
 
diff --git a/src/sampling/sampledSet/patchSeed/patchSeedSet.H b/src/sampling/sampledSet/boundaryPoints/boundaryPointsSet.H
similarity index 64%
rename from src/sampling/sampledSet/patchSeed/patchSeedSet.H
rename to src/sampling/sampledSet/boundaryPoints/boundaryPointsSet.H
index a6e795ad2b..ef4c267a87 100644
--- a/src/sampling/sampledSet/patchSeed/patchSeedSet.H
+++ b/src/sampling/sampledSet/boundaryPoints/boundaryPointsSet.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2018 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -22,23 +22,48 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Class
-    Foam::patchSeedSet
+    Foam::boundaryPointsSet
 
 Description
-    Initialises points on or just off patch
+    Specified point samples within patches
+
+Usage
+    \table
+        Property    | Description                            | Req'd? | Default
+        patches     | The patches on which to sample         | yes    |
+        points      | The points to sample                   | yes    |
+        maxDistance | The maximum distance from patch to point | yes  |
+        axis        | The coordinate axis that is written    | yes    |
+    \endtable
+
+    Example specification:
+    \verbatim
+    {
+        type        boundaryPoints;
+        patches     (inlet1 inlet2);
+        points
+        (
+            (0 -0.05 0.05)
+            (0 -0.05 0.15)
+            (0 0.05 0.15)
+            (0 0.05 0.05)
+        );
+        maxDistance 0.01;
+        axis        x;
+    }
+    \endverbatim
 
 SourceFiles
-    patchSeedSet.C
+    boundaryPointsSet.C
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef patchSeedSet_H
-#define patchSeedSet_H
+#ifndef boundaryPointsSet_H
+#define boundaryPointsSet_H
 
 #include "sampledSet.H"
 #include "DynamicList.H"
 #include "HashSet.H"
-#include "Random.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -46,34 +71,28 @@ namespace Foam
 {
 
 /*---------------------------------------------------------------------------*\
-                           Class patchSeedSet Declaration
+                        Class boundaryPointsSet Declaration
 \*---------------------------------------------------------------------------*/
 
-class patchSeedSet
+class boundaryPointsSet
 :
     public sampledSet
 {
     // Private data
 
+        //- Sampling points
+        const List<point> points_;
+
         //- Patches to sample
-        const labelHashSet patchSet_;
+        const labelHashSet patches_;
 
-//        //- Maximum distance to look for nearest
-//        const scalar searchDist_;
-//
-//        //- Offset distance
-//        const scalar offsetDist_;
-
-        //- Maximum number of patch faces to seed
-        const label maxPoints_;
-
-        //- Random number generator (if maxPoints < num patch faces)
-        autoPtr<Random> rndGenPtr_;
+        //- Maximum distance to to search for a nearby patch
+        const scalar maxDistance_;
 
 
     // Private Member Functions
 
-        //- Samples all points in sampleCoords.
+        //- Samples all points in sampleCoords
         void calcSamples
         (
             DynamicList<point>& samplingPts,
@@ -81,7 +100,7 @@ class patchSeedSet
             DynamicList<label>& samplingFaces,
             DynamicList<label>& samplingSegments,
             DynamicList<scalar>& samplingCurveDist
-        );
+        ) const;
 
         //- Uses calcSamples to obtain samples. Copies them into *this.
         void genSamples();
@@ -90,13 +109,13 @@ class patchSeedSet
 public:
 
     //- Runtime type information
-    TypeName("patchSeed");
+    TypeName("boundaryPoints");
 
 
     // Constructors
 
         //- Construct from dictionary
-        patchSeedSet
+        boundaryPointsSet
         (
             const word& name,
             const polyMesh& mesh,
@@ -106,7 +125,7 @@ public:
 
 
     //- Destructor
-    virtual ~patchSeedSet();
+    virtual ~boundaryPointsSet();
 };
 
 
diff --git a/src/sampling/sampledSet/boundaryRandom/boundaryRandomSet.C b/src/sampling/sampledSet/boundaryRandom/boundaryRandomSet.C
new file mode 100644
index 0000000000..c26707c576
--- /dev/null
+++ b/src/sampling/sampledSet/boundaryRandom/boundaryRandomSet.C
@@ -0,0 +1,248 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2018 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "boundaryRandomSet.H"
+#include "sampledSet.H"
+#include "meshSearch.H"
+#include "DynamicList.H"
+#include "polyMesh.H"
+#include "addToRunTimeSelectionTable.H"
+#include "word.H"
+#include "Random.H"
+#include "SubField.H"
+#include "barycentric2D.H"
+#include "triPointRef.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(boundaryRandomSet, 0);
+    addToRunTimeSelectionTable(sampledSet, boundaryRandomSet, word);
+}
+
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+void Foam::boundaryRandomSet::calcSamples
+(
+    DynamicList<point>& samplingPts,
+    DynamicList<label>& samplingCells,
+    DynamicList<label>& samplingFaces,
+    DynamicList<label>& samplingSegments,
+    DynamicList<scalar>& samplingCurveDist
+) const
+{
+    // Triangulate the patches
+    List<DynamicList<face>> trisDyn(patches_.size());
+    List<DynamicList<label>> trisFaceiDyn(patches_.size());
+    forAll(patches_, patchi)
+    {
+        const polyPatch& patch = mesh().boundaryMesh()[patchi];
+
+        forAll(patch, patchFacei)
+        {
+            const face& f = patch[patchFacei];
+            const label facei = patchFacei + patch.start();
+
+            DynamicList<face> faceTris(f.nTriangles());
+            f.triangles(patch.points(), faceTris);
+
+            trisDyn[patchi].append(faceTris);
+            trisFaceiDyn[patchi].append(labelList(f.nTriangles(), facei));
+        }
+    }
+
+    List<faceList> tris(patches_.size());
+    List<labelList> trisFacei(patches_.size());
+    forAll(patches_, patchi)
+    {
+        tris[patchi].transfer(trisDyn[patchi]);
+        trisFacei[patchi].transfer(trisFaceiDyn[patchi]);
+    }
+
+    // Generate the fractions which select the processor, patch and triangle
+    List<scalarField> trisFraction(patches_.size());
+    forAll(patches_, patchi)
+    {
+        const polyPatch& patch = mesh().boundaryMesh()[patchi];
+        const pointField& points = patch.points();
+
+        trisFraction[patchi] = scalarField(tris[patchi].size() + 1, 0);
+        forAll(tris[patchi], patchTrii)
+        {
+            trisFraction[patchi][patchTrii + 1] =
+                trisFraction[patchi][patchTrii]
+              + tris[patchi][patchTrii].mag(points);
+        }
+    }
+
+    scalarField patchesFraction(patches_.size() + 1, 0);
+    forAll(patches_, patchi)
+    {
+        patchesFraction[patchi + 1] =
+            patchesFraction[patchi] + trisFraction[patchi].last();
+    }
+
+    scalarField procsArea(Pstream::nProcs(), 0);
+    procsArea[Pstream::myProcNo()] = patchesFraction.last();
+    Pstream::listCombineGather(procsArea, maxEqOp<scalar>());
+    Pstream::listCombineScatter(procsArea);
+    scalarField procsFraction(Pstream::nProcs() + 1, 0);
+    for(label proci = 0; proci < Pstream::nProcs(); ++ proci)
+    {
+        procsFraction[proci + 1] = procsFraction[proci] + procsArea[proci];
+    }
+
+    bool anyTris = false;
+    forAll(patches_, patchi)
+    {
+        if (tris[patchi].size())
+        {
+            trisFraction[patchi] /= trisFraction[patchi].last();
+            anyTris = true;
+        }
+    }
+
+    if (anyTris)
+    {
+        patchesFraction /= patchesFraction.last();
+    }
+
+    procsFraction /= procsFraction.last();
+
+    // Generate the samples
+    Random rndGen(261782);
+    const label proci = Pstream::myProcNo();
+    for (label i = 0; i < nPoints_; ++ i)
+    {
+        // Request all random numbers simultaneously on all processors so that
+        // the generator state stays consistent
+
+        const scalar rProc = rndGen.scalar01();
+        const scalar rPatch = rndGen.scalar01();
+        const scalar rTri = rndGen.scalar01();
+        const barycentric2D r = barycentric2D01(rndGen);
+
+        if (procsFraction[proci] < rProc && rProc <= procsFraction[proci + 1])
+        {
+            label patchi = 0;
+            while (rPatch > patchesFraction[patchi + 1])
+            {
+                ++ patchi;
+            }
+
+            label trii = 0;
+            while (rTri > trisFraction[patchi][trii + 1])
+            {
+                ++ trii;
+            }
+
+            const polyPatch& patch = mesh().boundaryMesh()[patchi];
+            const pointField& points = patch.points();
+            const face& tf = tris[patchi][trii];
+            const triPointRef tt(points[tf[0]], points[tf[1]], points[tf[2]]);
+
+            samplingPts.append(tt.barycentricToPoint(r));
+            samplingCells.append(mesh().faceOwner()[trisFacei[patchi][trii]]);
+            samplingFaces.append(trisFacei[patchi][trii]);
+            samplingSegments.append(0);
+            samplingCurveDist.append(scalar(i));
+        }
+    }
+}
+
+
+void Foam::boundaryRandomSet::genSamples()
+{
+    // Storage for sample points
+    DynamicList<point> samplingPts;
+    DynamicList<label> samplingCells;
+    DynamicList<label> samplingFaces;
+    DynamicList<label> samplingSegments;
+    DynamicList<scalar> samplingCurveDist;
+
+    calcSamples
+    (
+        samplingPts,
+        samplingCells,
+        samplingFaces,
+        samplingSegments,
+        samplingCurveDist
+    );
+
+    samplingPts.shrink();
+    samplingCells.shrink();
+    samplingFaces.shrink();
+    samplingSegments.shrink();
+    samplingCurveDist.shrink();
+
+    setSamples
+    (
+        samplingPts,
+        samplingCells,
+        samplingFaces,
+        samplingSegments,
+        samplingCurveDist
+    );
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::boundaryRandomSet::boundaryRandomSet
+(
+    const word& name,
+    const polyMesh& mesh,
+    const meshSearch& searchEngine,
+    const dictionary& dict
+)
+:
+    sampledSet(name, mesh, searchEngine, dict),
+    patches_
+    (
+        mesh.boundaryMesh().patchSet
+        (
+            wordReList(dict.lookup("patches"))
+        )
+    ),
+    nPoints_(readLabel(dict.lookup("nPoints")))
+{
+    genSamples();
+
+    if (debug)
+    {
+        write(Info);
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::boundaryRandomSet::~boundaryRandomSet()
+{}
+
+
+// ************************************************************************* //
diff --git a/src/sampling/sampledSet/patchCloud/patchCloudSet.H b/src/sampling/sampledSet/boundaryRandom/boundaryRandomSet.H
similarity index 69%
rename from src/sampling/sampledSet/patchCloud/patchCloudSet.H
rename to src/sampling/sampledSet/boundaryRandom/boundaryRandomSet.H
index 7fff04eafc..30e6e76584 100644
--- a/src/sampling/sampledSet/patchCloud/patchCloudSet.H
+++ b/src/sampling/sampledSet/boundaryRandom/boundaryRandomSet.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2018 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -22,19 +22,36 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Class
-    Foam::patchCloudSet
+    Foam::boundaryRandomSet
 
 Description
-    Like cloudSet but samples nearest patch face
+    Random samples within patches
 
+Usage
+    \table
+        Property    | Description                            | Req'd? | Default
+        patches     | The patches on which to sample         | yes    |
+        nPoints     | The number of points                   | yes    |
+        axis        | The coordinate axis that is written    | yes    |
+    \endtable
+
+    Example specification:
+    \verbatim
+    {
+        type        boundaryRandom;
+        patches     (inlet1 inlet2);
+        nPoints     1000;
+        axis        x;
+    }
+    \endverbatim
 
 SourceFiles
-    patchCloudSet.C
+    boundaryRandomSet.C
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef patchCloudSet_H
-#define patchCloudSet_H
+#ifndef boundaryRandomSet_H
+#define boundaryRandomSet_H
 
 #include "sampledSet.H"
 #include "DynamicList.H"
@@ -46,28 +63,25 @@ namespace Foam
 {
 
 /*---------------------------------------------------------------------------*\
-                           Class patchCloudSet Declaration
+                        Class boundaryRandomSet Declaration
 \*---------------------------------------------------------------------------*/
 
-class patchCloudSet
+class boundaryRandomSet
 :
     public sampledSet
 {
     // Private data
 
-        //- Sampling points
-        const List<point> sampleCoords_;
-
         //- Patches to sample
-        const labelHashSet patchSet_;
+        const labelHashSet patches_;
 
-        //- Maximum distance to look for nearest
-        const scalar searchDist_;
+        //- Number of points
+        const label nPoints_;
 
 
     // Private Member Functions
 
-        //- Samples all points in sampleCoords.
+        //- Sample all points
         void calcSamples
         (
             DynamicList<point>& samplingPts,
@@ -77,32 +91,20 @@ class patchCloudSet
             DynamicList<scalar>& samplingCurveDist
         ) const;
 
-        //- Uses calcSamples to obtain samples. Copies them into *this.
+        //- Use calcSamples to obtain samples and copy them into *this
         void genSamples();
 
 
 public:
 
     //- Runtime type information
-    TypeName("patchCloud");
+    TypeName("boundaryRandom");
 
 
     // Constructors
 
-        //- Construct from components
-        patchCloudSet
-        (
-            const word& name,
-            const polyMesh& mesh,
-            const meshSearch& searchEngine,
-            const word& axis,
-            const List<point>& sampleCoords,
-            const labelHashSet& patchSet,
-            const scalar searchDist
-        );
-
         //- Construct from dictionary
-        patchCloudSet
+        boundaryRandomSet
         (
             const word& name,
             const polyMesh& mesh,
@@ -112,7 +114,7 @@ public:
 
 
     //- Destructor
-    virtual ~patchCloudSet();
+    virtual ~boundaryRandomSet();
 };
 
 
diff --git a/src/sampling/sampledSet/boxUniform/boxUniformSet.C b/src/sampling/sampledSet/boxUniform/boxUniformSet.C
new file mode 100644
index 0000000000..2acd75c74a
--- /dev/null
+++ b/src/sampling/sampledSet/boxUniform/boxUniformSet.C
@@ -0,0 +1,148 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2018 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "boxUniformSet.H"
+#include "sampledSet.H"
+#include "meshSearch.H"
+#include "DynamicList.H"
+#include "polyMesh.H"
+#include "addToRunTimeSelectionTable.H"
+#include "word.H"
+#include "transform.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(boxUniformSet, 0);
+    addToRunTimeSelectionTable(sampledSet, boxUniformSet, word);
+}
+
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+void Foam::boxUniformSet::calcSamples
+(
+    DynamicList<point>& samplingPts,
+    DynamicList<label>& samplingCells,
+    DynamicList<label>& samplingFaces,
+    DynamicList<label>& samplingSegments,
+    DynamicList<scalar>& samplingCurveDist
+) const
+{
+    for (label k = 0; k < nPoints_.z(); ++ k)
+    {
+        for (label j = 0; j < nPoints_.y(); ++ j)
+        {
+            for (label i = 0; i < nPoints_.x(); ++ i)
+            {
+                const vector t =
+                    cmptDivide(vector(i, j, k), vector(nPoints_) - vector::one);
+
+                const point pt =
+                    cmptMultiply(vector::one - t, box_.min())
+                  + cmptMultiply(t, box_.max());
+
+                const label celli = searchEngine().findCell(pt);
+
+                if (celli != -1)
+                {
+                    samplingPts.append(pt);
+                    samplingCells.append(celli);
+                    samplingFaces.append(-1);
+                    samplingSegments.append(0);
+                    samplingCurveDist.append(scalar(i));
+                }
+            }
+        }
+    }
+}
+
+
+void Foam::boxUniformSet::genSamples()
+{
+    // Storage for sample points
+    DynamicList<point> samplingPts;
+    DynamicList<label> samplingCells;
+    DynamicList<label> samplingFaces;
+    DynamicList<label> samplingSegments;
+    DynamicList<scalar> samplingCurveDist;
+
+    calcSamples
+    (
+        samplingPts,
+        samplingCells,
+        samplingFaces,
+        samplingSegments,
+        samplingCurveDist
+    );
+
+    samplingPts.shrink();
+    samplingCells.shrink();
+    samplingFaces.shrink();
+    samplingSegments.shrink();
+    samplingCurveDist.shrink();
+
+    setSamples
+    (
+        samplingPts,
+        samplingCells,
+        samplingFaces,
+        samplingSegments,
+        samplingCurveDist
+    );
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::boxUniformSet::boxUniformSet
+(
+    const word& name,
+    const polyMesh& mesh,
+    const meshSearch& searchEngine,
+    const dictionary& dict
+)
+:
+    sampledSet(name, mesh, searchEngine, dict),
+    box_(dict.lookup("box")),
+    nPoints_(dict.lookup("nPoints"))
+{
+    genSamples();
+
+    if (debug)
+    {
+        write(Info);
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::boxUniformSet::~boxUniformSet()
+{}
+
+
+// ************************************************************************* //
diff --git a/src/sampling/sampledSet/array/arraySet.H b/src/sampling/sampledSet/boxUniform/boxUniformSet.H
similarity index 72%
rename from src/sampling/sampledSet/array/arraySet.H
rename to src/sampling/sampledSet/boxUniform/boxUniformSet.H
index 63ce993529..6e89f24619 100644
--- a/src/sampling/sampledSet/array/arraySet.H
+++ b/src/sampling/sampledSet/boxUniform/boxUniformSet.H
@@ -22,21 +22,41 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Class
-    Foam::arraySet
+    Foam::boxUniformSet
 
 Description
+    Uniform 3D-grid of samples
+
+Usage
+    \table
+        Property    | Description                            | Req'd? | Default
+        box         | The box which contains the samples     | yes    |
+        nPoints     | The number of points in each direction | yes    |
+        axis        | The coordinate axis that is written    | yes    |
+    \endtable
+
+    Example specification:
+    \verbatim
+    {
+        type        boxUniform;
+        box         (0.95 0 0.25) (1.2 0.25 0.5);
+        nPoints     (2 4 6);
+        axis        x;
+    }
+    \endverbatim
 
 SourceFiles
-    arraySet.C
+    boxUniformSet.C
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef arraySet_H
-#define arraySet_H
+#ifndef boxUniformSet_H
+#define boxUniformSet_H
 
 #include "sampledSet.H"
 #include "DynamicList.H"
-#include "coordinateSystem.H"
+#include "labelVector.H"
+#include "boundBox.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -48,23 +68,20 @@ class passiveParticle;
 template<class Type> class particle;
 
 /*---------------------------------------------------------------------------*\
-                           Class arraySet Declaration
+                           Class boxUniformSet Declaration
 \*---------------------------------------------------------------------------*/
 
-class arraySet
+class boxUniformSet
 :
     public sampledSet
 {
     // Private data
 
-        //- Coordinate system
-        coordinateSystem coordSys_;
+        //- Box
+        const boundBox box_;
 
-        //- Point density vector
-        Vector<label> pointsDensity_;
-
-        //- Span box
-        Vector<scalar> spanBox_;
+        //- The number of points across each direction of the box
+        const labelVector nPoints_;
 
 
     // Private Member Functions
@@ -86,25 +103,13 @@ class arraySet
 public:
 
     //- Runtime type information
-    TypeName("array");
+    TypeName("boxUniform");
 
 
     // Constructors
 
-        //- Construct from components
-        arraySet
-        (
-            const word& name,
-            const polyMesh& mesh,
-            const meshSearch& searchEngine,
-            const word& axis,
-            const coordinateSystem& coordSys,
-            const Vector<label>& pointsDensity,
-            const Vector<scalar>& spanBox
-        );
-
         //- Construct from dictionary
-        arraySet
+        boxUniformSet
         (
             const word& name,
             const polyMesh& mesh,
@@ -114,7 +119,7 @@ public:
 
 
     //- Destructor
-    virtual ~arraySet();
+    virtual ~boxUniformSet();
 };
 
 
diff --git a/src/sampling/sampledSet/circle/circleSet.C b/src/sampling/sampledSet/circle/circleSet.C
deleted file mode 100644
index c0558fec45..0000000000
--- a/src/sampling/sampledSet/circle/circleSet.C
+++ /dev/null
@@ -1,243 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2018 OpenFOAM Foundation
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-\*---------------------------------------------------------------------------*/
-
-#include "circleSet.H"
-#include "sampledSet.H"
-#include "meshSearch.H"
-#include "DynamicList.H"
-#include "polyMesh.H"
-#include "addToRunTimeSelectionTable.H"
-#include "word.H"
-#include "mathematicalConstants.H"
-
-// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
-
-namespace Foam
-{
-    defineTypeNameAndDebug(circleSet, 0);
-    addToRunTimeSelectionTable(sampledSet, circleSet, word);
-}
-
-
-// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
-
-void Foam::circleSet::calcSamples
-(
-    DynamicList<point>& samplingPts,
-    DynamicList<label>& samplingCells,
-    DynamicList<label>& samplingFaces,
-    DynamicList<label>& samplingSegments,
-    DynamicList<scalar>& samplingCurveDist
-) const
-{
-    static const string funcName =
-    (
-        "void circleSet::calcSamples"
-        "("
-            "DynamicList<point>&, "
-            "DynamicList<label>&, "
-            "DynamicList<label>&, "
-            "DynamicList<label>&, "
-            "DynamicList<scalar>&"
-        ") const"
-    );
-
-    // set start point
-    label celli = searchEngine().findCell(startPoint_);
-    if (celli != -1)
-    {
-        samplingPts.append(startPoint_);
-        samplingCells.append(celli);
-        samplingFaces.append(-1);
-        samplingSegments.append(0);
-        samplingCurveDist.append(0.0);
-    }
-    else
-    {
-        WarningInFunction
-            << "Unable to find cell at point id " << 0
-            << " at location " << startPoint_ << endl;
-    }
-
-    // add remaining points
-    const scalar alpha = constant::mathematical::pi/180.0*dTheta_;
-    const scalar sinAlpha = sin(alpha);
-    const scalar cosAlpha = cos(alpha);
-
-    // first axis
-    vector axis1 = startPoint_ - origin_;
-    const scalar radius = mag(axis1);
-
-    if (mag(axis1 & circleAxis_) > small)
-    {
-        WarningInFunction
-            << "Vector defined by (startPoint - origin) not orthogonal to "
-            << "circleAxis:" << nl
-            << "    startPoint - origin = " << axis1 << nl
-            << "    circleAxis          = " << circleAxis_ << nl
-            << endl;
-    }
-
-    axis1 /= mag(axis1);
-
-    scalar theta = dTheta_;
-    label nPoint = 1;
-    while (theta < 360)
-    {
-        axis1 = axis1*cosAlpha + (axis1^circleAxis_)*sinAlpha;
-        axis1 /= mag(axis1);
-        point pt = origin_ + radius*axis1;
-
-        label celli = searchEngine().findCell(pt);
-
-        if (celli != -1)
-        {
-            samplingPts.append(pt);
-            samplingCells.append(celli);
-            samplingFaces.append(-1);
-            samplingSegments.append(nPoint);
-            samplingCurveDist.append
-            (
-                radius*constant::mathematical::pi/180.0*theta
-            );
-
-            nPoint++;
-        }
-        else
-        {
-            WarningInFunction
-                << "Unable to find cell at point id " << nPoint
-                << " at location " << pt << endl;
-        }
-        theta += dTheta_;
-    }
-}
-
-
-void Foam::circleSet::genSamples()
-{
-    // Storage for sample points
-    DynamicList<point> samplingPts;
-    DynamicList<label> samplingCells;
-    DynamicList<label> samplingFaces;
-    DynamicList<label> samplingSegments;
-    DynamicList<scalar> samplingCurveDist;
-
-    calcSamples
-    (
-        samplingPts,
-        samplingCells,
-        samplingFaces,
-        samplingSegments,
-        samplingCurveDist
-    );
-
-    samplingPts.shrink();
-    samplingCells.shrink();
-    samplingFaces.shrink();
-    samplingSegments.shrink();
-    samplingCurveDist.shrink();
-
-    setSamples
-    (
-        samplingPts,
-        samplingCells,
-        samplingFaces,
-        samplingSegments,
-        samplingCurveDist
-    );
-}
-
-
-// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
-
-Foam::circleSet::circleSet
-(
-    const word& name,
-    const polyMesh& mesh,
-    const meshSearch& searchEngine,
-    const word& axis,
-    const point& origin,
-    const vector& circleAxis,
-    const point& startPoint,
-    const scalar dTheta
-)
-:
-    sampledSet(name, mesh, searchEngine, axis),
-    origin_(origin),
-    circleAxis_(circleAxis),
-    startPoint_(startPoint),
-    dTheta_(dTheta)
-{
-    genSamples();
-
-    if (debug)
-    {
-        write(Info);
-    }
-}
-
-
-Foam::circleSet::circleSet
-(
-    const word& name,
-    const polyMesh& mesh,
-    const meshSearch& searchEngine,
-    const dictionary& dict
-)
-:
-    sampledSet(name, mesh, searchEngine, dict),
-    origin_(dict.lookup("origin")),
-    circleAxis_(dict.lookup("circleAxis")),
-    startPoint_(dict.lookup("startPoint")),
-    dTheta_(readScalar(dict.lookup("dTheta")))
-{
-    // normalise circleAxis
-    circleAxis_ /= mag(circleAxis_);
-
-    genSamples();
-
-    if (debug)
-    {
-        write(Info);
-    }
-}
-
-
-// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
-
-Foam::circleSet::~circleSet()
-{}
-
-
-// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
-
-Foam::point Foam::circleSet::getRefPoint(const List<point>& pts) const
-{
-    return startPoint_;
-}
-
-
-// ************************************************************************* //
diff --git a/src/sampling/sampledSet/array/arraySet.C b/src/sampling/sampledSet/circleRandom/circleRandomSet.C
similarity index 60%
rename from src/sampling/sampledSet/array/arraySet.C
rename to src/sampling/sampledSet/circleRandom/circleRandomSet.C
index 1ff788d173..46376b6b2d 100644
--- a/src/sampling/sampledSet/array/arraySet.C
+++ b/src/sampling/sampledSet/circleRandom/circleRandomSet.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2018 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -23,27 +23,28 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-#include "arraySet.H"
+#include "circleRandomSet.H"
 #include "sampledSet.H"
 #include "meshSearch.H"
 #include "DynamicList.H"
 #include "polyMesh.H"
 #include "addToRunTimeSelectionTable.H"
 #include "word.H"
-#include "transform.H"
+#include "mathematicalConstants.H"
+#include "Random.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
 namespace Foam
 {
-    defineTypeNameAndDebug(arraySet, 0);
-    addToRunTimeSelectionTable(sampledSet, arraySet, word);
+    defineTypeNameAndDebug(circleRandomSet, 0);
+    addToRunTimeSelectionTable(sampledSet, circleRandomSet, word);
 }
 
 
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 
-void Foam::arraySet::calcSamples
+void Foam::circleRandomSet::calcSamples
 (
     DynamicList<point>& samplingPts,
     DynamicList<label>& samplingCells,
@@ -52,57 +53,36 @@ void Foam::arraySet::calcSamples
     DynamicList<scalar>& samplingCurveDist
 ) const
 {
-    const meshSearch& queryMesh = searchEngine();
+    Random rndGen(261782);
 
-    label nTotalSamples
-    (
-        pointsDensity_.x()
-       *pointsDensity_.y()
-       *pointsDensity_.z()
-    );
+    const vector radial1 = normalised(perpendicular(normal_));
+    const vector radial2 = normalised(normal_ ^ radial1);
 
-    List<point> sampleCoords(nTotalSamples);
-
-    const scalar deltax = spanBox_.x()/(pointsDensity_.x() + 1);
-    const scalar deltay = spanBox_.y()/(pointsDensity_.y() + 1);
-    const scalar deltaz = spanBox_.z()/(pointsDensity_.z() + 1);
-
-    label p(0);
-    for (label k=1; k<=pointsDensity_.z(); k++)
+    for (label i = 0; i < nPoints_; ++ i)
     {
-        for (label j=1; j<=pointsDensity_.y(); j++)
-        {
-            for (label i=1; i<=pointsDensity_.x(); i++)
-            {
-                vector t(deltax*i , deltay*j, deltaz*k);
-                sampleCoords[p] = coordSys_.origin() + t;
-                p++;
-            }
-        }
-    }
+        // Request all random numbers simultaneously on all processors so that
+        // the generator state stays consistent
 
-    forAll(sampleCoords, i)
-    {
-        sampleCoords[i] = transform(coordSys_.R().R(), sampleCoords[i]);
-    }
+        const scalar r = radius_*rndGen.scalar01();
+        const scalar theta = 2*constant::mathematical::pi*rndGen.scalar01();
+        const scalar c = cos(theta), s = sin(theta);
 
-    forAll(sampleCoords, sampleI)
-    {
-        label celli = queryMesh.findCell(sampleCoords[sampleI]);
+        const point pt = centre_ + r*(c*radial1 + s*radial2);
+        const label celli = searchEngine().findCell(pt);
 
         if (celli != -1)
         {
-            samplingPts.append(sampleCoords[sampleI]);
+            samplingPts.append(pt);
             samplingCells.append(celli);
             samplingFaces.append(-1);
             samplingSegments.append(0);
-            samplingCurveDist.append(1.0 * sampleI);
+            samplingCurveDist.append(scalar(i));
         }
     }
 }
 
 
-void Foam::arraySet::genSamples()
+void Foam::circleRandomSet::genSamples()
 {
     // Storage for sample points
     DynamicList<point> samplingPts;
@@ -139,32 +119,7 @@ void Foam::arraySet::genSamples()
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
-Foam::arraySet::arraySet
-(
-    const word& name,
-    const polyMesh& mesh,
-    const meshSearch& searchEngine,
-    const word& axis,
-    const coordinateSystem& origin,
-    const Vector<label>& pointsDensity,
-    const Vector<scalar>& spanBox
-)
-:
-    sampledSet(name, mesh, searchEngine, axis),
-    coordSys_(origin),
-    pointsDensity_(pointsDensity),
-    spanBox_(spanBox)
-{
-    genSamples();
-
-    if (debug)
-    {
-        write(Info);
-    }
-}
-
-
-Foam::arraySet::arraySet
+Foam::circleRandomSet::circleRandomSet
 (
     const word& name,
     const polyMesh& mesh,
@@ -173,9 +128,10 @@ Foam::arraySet::arraySet
 )
 :
     sampledSet(name, mesh, searchEngine, dict),
-    coordSys_(dict),
-    pointsDensity_(dict.lookup("pointsDensity")),
-    spanBox_(dict.lookup("spanBox"))
+    centre_(dict.lookup("centre")),
+    normal_(normalised(dict.lookupType<vector>("normal"))),
+    radius_(readScalar(dict.lookup("radius"))),
+    nPoints_(readLabel(dict.lookup("nPoints")))
 {
     genSamples();
 
@@ -188,7 +144,7 @@ Foam::arraySet::arraySet
 
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 
-Foam::arraySet::~arraySet()
+Foam::circleRandomSet::~circleRandomSet()
 {}
 
 
diff --git a/src/sampling/sampledSet/circleRandom/circleRandomSet.H b/src/sampling/sampledSet/circleRandom/circleRandomSet.H
new file mode 100644
index 0000000000..0baba8b90c
--- /dev/null
+++ b/src/sampling/sampledSet/circleRandom/circleRandomSet.H
@@ -0,0 +1,139 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2018 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::circleRandomSet
+
+Description
+    Random samples within a circle
+
+Usage
+    \table
+        Property    | Description                            | Req'd? | Default
+        centre      | Centre of the circle                   | yes    |
+        normal      | Direction normal to the plane of the circle | yes |
+        radius      | Radius of the circle                   | yes    |
+        nPoints     | The number of points                   | yes    |
+        axis        | The coordinate axis that is written    | yes    |
+    \endtable
+
+    Example specification:
+    \verbatim
+    {
+        type        circleRandom;
+        centre      (0.95 0 0.25);
+        normal      (1 0 0);
+        radius      0.25;
+        nPoints     200;
+        axis        x;
+    }
+    \endverbatim
+
+SourceFiles
+    circleRandomSet.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef circleRandomSet_H
+#define circleRandomSet_H
+
+#include "sampledSet.H"
+#include "DynamicList.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                          Class circleRandomSet Declaration
+\*---------------------------------------------------------------------------*/
+
+class circleRandomSet
+:
+    public sampledSet
+{
+    // Private data
+
+        //- Centre point
+        const point centre_;
+
+        //- Direction normal to the circle
+        const vector normal_;
+
+        //- Radius
+        const scalar radius_;
+
+        //- Number of points
+        const label nPoints_;
+
+
+    // Private Member Functions
+
+        //- Samples all points in sampleCoords
+        void calcSamples
+        (
+            DynamicList<point>& samplingPts,
+            DynamicList<label>& samplingCells,
+            DynamicList<label>& samplingFaces,
+            DynamicList<label>& samplingSegments,
+            DynamicList<scalar>& samplingCurveDist
+        ) const;
+
+        //- Uses calcSamples to obtain samples. Copies them into *this.
+        void genSamples();
+
+
+public:
+
+    //- Runtime type information
+    TypeName("circleRandom");
+
+
+    // Constructors
+
+        //- Construct from dictionary
+        circleRandomSet
+        (
+            const word& name,
+            const polyMesh& mesh,
+            const meshSearch& searchEngine,
+            const dictionary& dict
+        );
+
+
+    // Destructor
+
+        virtual ~circleRandomSet();
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/sampling/sampledSet/face/faceOnlySet.C b/src/sampling/sampledSet/face/faceOnlySet.C
deleted file mode 100644
index 51cf989e2c..0000000000
--- a/src/sampling/sampledSet/face/faceOnlySet.C
+++ /dev/null
@@ -1,378 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2018 OpenFOAM Foundation
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-\*---------------------------------------------------------------------------*/
-
-#include "faceOnlySet.H"
-#include "meshSearch.H"
-#include "DynamicList.H"
-#include "polyMesh.H"
-
-#include "addToRunTimeSelectionTable.H"
-
-// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
-
-namespace Foam
-{
-    defineTypeNameAndDebug(faceOnlySet, 0);
-    addToRunTimeSelectionTable(sampledSet, faceOnlySet, word);
-
-    const scalar faceOnlySet::tol = 1e-6;
-}
-
-
-// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
-
-bool Foam::faceOnlySet::trackToBoundary
-(
-    passiveParticleCloud& particleCloud,
-    passiveParticle& singleParticle,
-    const scalar smallDist,
-    DynamicList<point>& samplingPts,
-    DynamicList<label>& samplingCells,
-    DynamicList<label>& samplingFaces,
-    DynamicList<scalar>& samplingCurveDist
-) const
-{
-    particle::trackingData td(particleCloud);
-
-    point trackPt = singleParticle.position();
-
-    while(true)
-    {
-        point oldPoint = trackPt;
-
-        singleParticle.trackToAndHitFace(end_ - start_, 0, particleCloud, td);
-
-        trackPt = singleParticle.position();
-
-        if (singleParticle.face() != -1 && mag(oldPoint - trackPt) > smallDist)
-        {
-            // Reached face. Sample.
-            samplingPts.append(trackPt);
-            samplingCells.append(singleParticle.cell());
-            samplingFaces.append(singleParticle.face());
-            samplingCurveDist.append(mag(trackPt - start_));
-        }
-
-        if (mag(trackPt - end_) < smallDist)
-        {
-            // End reached
-            return false;
-        }
-        else if (singleParticle.onBoundaryFace())
-        {
-            // Boundary reached
-            return true;
-        }
-    }
-}
-
-
-void Foam::faceOnlySet::calcSamples
-(
-    DynamicList<point>& samplingPts,
-    DynamicList<label>& samplingCells,
-    DynamicList<label>& samplingFaces,
-    DynamicList<label>& samplingSegments,
-    DynamicList<scalar>& samplingCurveDist
-) const
-{
-    // Distance vector between sampling points
-    if (mag(end_ - start_) < small)
-    {
-        FatalErrorInFunction
-            << "Incorrect sample specification :"
-            << " start equals end point." << endl
-            << "  start:" << start_
-            << "  end:" << end_
-            << exit(FatalError);
-    }
-
-    const vector offset = (end_ - start_);
-    const vector normOffset = offset/mag(offset);
-    const vector smallVec = tol*offset;
-    const scalar smallDist = mag(smallVec);
-
-    // Force calculation of cloud addressing on all processors
-    const bool oldMoving = const_cast<polyMesh&>(mesh()).moving(false);
-    passiveParticleCloud particleCloud(mesh());
-
-    // Get all boundary intersections
-    List<pointIndexHit> bHits = searchEngine().intersections
-    (
-        start_ - smallVec,
-        end_ + smallVec
-    );
-
-    point bPoint(great, great, great);
-    label bFacei = -1;
-
-    if (bHits.size())
-    {
-        bPoint = bHits[0].hitPoint();
-        bFacei = bHits[0].index();
-    }
-
-    // Get first tracking point. Use bPoint, bFacei if provided.
-    point trackPt;
-    label trackCelli = -1;
-    label trackFacei = -1;
-
-    // Pout<< "before getTrackingPoint : bPoint:" << bPoint
-    //     << " bFacei:" << bFacei << endl;
-
-    getTrackingPoint
-    (
-        start_,
-        bPoint,
-        bFacei,
-        smallDist,
-        trackPt,
-        trackCelli,
-        trackFacei
-    );
-
-    // Pout<< "after getTrackingPoint : "
-    //     << " trackPt:" << trackPt
-    //     << " trackCelli:" << trackCelli
-    //     << " trackFacei:" << trackFacei
-    //     << endl;
-
-    if (trackCelli == -1)
-    {
-        // Line start_ - end_ does not intersect domain at all.
-        // (or is along edge)
-        // Set points and cell/face labels to empty lists
-
-        // Pout<< "calcSamples : Both start_ and end_ outside domain"
-        //     << endl;
-
-        const_cast<polyMesh&>(mesh()).moving(oldMoving);
-        return;
-    }
-
-    if (trackFacei == -1)
-    {
-        // No boundary face. Check for nearish internal face
-        trackFacei = findNearFace(trackCelli, trackPt, smallDist);
-    }
-
-    // Pout<< "calcSamples : got first point to track from :"
-    //     << "  trackPt:" << trackPt
-    //     << "  trackCell:" << trackCelli
-    //     << "  trackFace:" << trackFacei
-    //     << endl;
-
-    //
-    // Track until hit end of all boundary intersections
-    //
-
-    // current segment number
-    label segmentI = 0;
-
-    // starting index of current segment in samplePts
-    label startSegmentI = 0;
-
-    // index in bHits; current boundary intersection
-    label bHitI = 1;
-
-    while (true)
-    {
-        if (trackFacei != -1)
-        {
-            // Pout<< "trackPt:" << trackPt << " on face so use." << endl;
-            samplingPts.append(trackPt);
-            samplingCells.append(trackCelli);
-            samplingFaces.append(trackFacei);
-            samplingCurveDist.append(mag(trackPt - start_));
-        }
-
-        // Initialize tracking starting from trackPt
-        passiveParticle singleParticle
-        (
-            mesh(),
-            trackPt,
-            trackCelli
-        );
-
-        bool reachedBoundary = trackToBoundary
-        (
-            particleCloud,
-            singleParticle,
-            smallDist,
-            samplingPts,
-            samplingCells,
-            samplingFaces,
-            samplingCurveDist
-        );
-
-        // Fill sampleSegments
-        for (label i = samplingPts.size() - 1; i >= startSegmentI; --i)
-        {
-            samplingSegments.append(segmentI);
-        }
-
-        if (!reachedBoundary)
-        {
-            // Pout<< "calcSamples : Reached end of samples: "
-            //     << "  samplePt now:" << singleParticle.position()
-            //     << endl;
-            break;
-        }
-
-        bool foundValidB = false;
-
-        while (bHitI < bHits.size())
-        {
-            scalar dist =
-                (bHits[bHitI].hitPoint() - singleParticle.position())
-              & normOffset;
-
-            // Pout<< "Finding next boundary : "
-            //     << "bPoint:" << bHits[bHitI].hitPoint()
-            //     << "  tracking:" << singleParticle.position()
-            //     << "  dist:" << dist
-            //     << endl;
-
-            if (dist > smallDist)
-            {
-                // Hit-point is past tracking position
-                foundValidB = true;
-                break;
-            }
-            else
-            {
-                bHitI++;
-            }
-        }
-
-        if (!foundValidB || bHitI == bHits.size() - 1)
-        {
-            // No valid boundary intersection found beyond tracking position
-            break;
-        }
-
-        // Update starting point for tracking
-        trackFacei = bHits[bHitI].index();
-        trackPt = pushIn(bHits[bHitI].hitPoint(), trackFacei);
-        trackCelli = getBoundaryCell(trackFacei);
-
-        segmentI++;
-
-        startSegmentI = samplingPts.size();
-    }
-
-    const_cast<polyMesh&>(mesh()).moving(oldMoving);
-}
-
-
-void Foam::faceOnlySet::genSamples()
-{
-    // Storage for sample points
-    DynamicList<point> samplingPts;
-    DynamicList<label> samplingCells;
-    DynamicList<label> samplingFaces;
-    DynamicList<label> samplingSegments;
-    DynamicList<scalar> samplingCurveDist;
-
-    calcSamples
-    (
-        samplingPts,
-        samplingCells,
-        samplingFaces,
-        samplingSegments,
-        samplingCurveDist
-    );
-
-    samplingPts.shrink();
-    samplingCells.shrink();
-    samplingFaces.shrink();
-    samplingSegments.shrink();
-    samplingCurveDist.shrink();
-
-    // Copy into *this
-    setSamples
-    (
-        samplingPts,
-        samplingCells,
-        samplingFaces,
-        samplingSegments,
-        samplingCurveDist
-    );
-}
-
-
-// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
-
-Foam::faceOnlySet::faceOnlySet
-(
-    const word& name,
-    const polyMesh& mesh,
-    const meshSearch& searchEngine,
-    const word& axis,
-    const point& start,
-    const point& end
-)
-:
-    sampledSet(name, mesh, searchEngine, axis),
-    start_(start),
-    end_(end)
-{
-    genSamples();
-
-    if (debug)
-    {
-        write(Info);
-    }
-}
-
-
-Foam::faceOnlySet::faceOnlySet
-(
-    const word& name,
-    const polyMesh& mesh,
-    const meshSearch& searchEngine,
-    const dictionary& dict
-)
-:
-    sampledSet(name, mesh, searchEngine, dict),
-    start_(dict.lookup("start")),
-    end_(dict.lookup("end"))
-{
-    genSamples();
-
-    if (debug)
-    {
-        write(Info);
-    }
-}
-
-
-// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
-
-Foam::faceOnlySet::~faceOnlySet()
-{}
-
-
-// ************************************************************************* //
diff --git a/src/sampling/sampledSet/lineCell/lineCellSet.C b/src/sampling/sampledSet/lineCell/lineCellSet.C
new file mode 100644
index 0000000000..80c4734110
--- /dev/null
+++ b/src/sampling/sampledSet/lineCell/lineCellSet.C
@@ -0,0 +1,217 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2018 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "lineCellSet.H"
+#include "meshSearch.H"
+#include "DynamicList.H"
+#include "polyMesh.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(lineCellSet, 0);
+    addToRunTimeSelectionTable(sampledSet, lineCellSet, word);
+}
+
+
+// * * * * * * * * * * * * * Static Member Functions * * * * * * * * * * * * //
+
+void Foam::lineCellSet::calcMidPointSample
+(
+    const polyMesh& mesh,
+    const point& prevPt,
+    const label prevFace,
+    const label prevSegment,
+    const scalar prevCurveDist,
+    const point& nextPt,
+    const label nextFace,
+    const label nextSegment,
+    DynamicList<point>& samplingPts,
+    DynamicList<label>& samplingCells,
+    DynamicList<label>& samplingFaces,
+    DynamicList<label>& samplingSegments,
+    DynamicList<scalar>& samplingCurveDist
+)
+{
+    if (prevSegment == nextSegment)
+    {
+        const point pt = (prevPt + nextPt)/2;
+        const vector delta = nextPt - prevPt;
+
+        const label prevOwner = mesh.faceOwner()[prevFace];
+        const label prevNeighbour =
+            prevFace < mesh.faceNeighbour().size()
+          ? mesh.faceNeighbour()[prevFace]
+          : -1;
+        const label nextOwner = mesh.faceOwner()[nextFace];
+        const label nextNeighbour =
+            nextFace < mesh.faceNeighbour().size()
+          ? mesh.faceNeighbour()[nextFace]
+          : -2;
+
+        label celli = -1;
+        if (prevOwner == nextOwner || prevOwner == nextNeighbour)
+        {
+            celli = prevOwner;
+        }
+        else if (prevNeighbour == nextOwner || prevNeighbour == nextNeighbour)
+        {
+            celli = prevNeighbour;
+        }
+        else
+        {
+            FatalErrorInFunction
+                << "Adjacent faces in the same segment do not share a cell. "
+                << "This is a bug." << exit(FatalError);
+        }
+
+        samplingPts.append(pt);
+        samplingCells.append(celli);
+        samplingFaces.append(-1);
+        samplingCurveDist.append(prevCurveDist + mag(delta)/2);
+        samplingSegments.append(prevSegment);
+    }
+}
+
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+void Foam::lineCellSet::calcSamples
+(
+    DynamicList<point>& samplingPts,
+    DynamicList<label>& samplingCells,
+    DynamicList<label>& samplingFaces,
+    DynamicList<label>& samplingSegments,
+    DynamicList<scalar>& samplingCurveDist
+) const
+{
+    // Run the algorithm from lineFaceSet to get all the face intersections
+    DynamicList<point> facePts;
+    DynamicList<label> faceCells;
+    DynamicList<label> faceFaces;
+    DynamicList<label> faceSegments;
+    DynamicList<scalar> faceCurveDist;
+    lineFaceSet::calcSamples
+    (
+        mesh(),
+        searchEngine(),
+        start_,
+        end_,
+        facePts,
+        faceCells,
+        faceFaces,
+        faceSegments,
+        faceCurveDist
+    );
+
+    // Append all mid points to the set
+    for (label facei = 1; facei < facePts.size(); ++ facei)
+    {
+        calcMidPointSample
+        (
+            mesh(),
+            facePts[facei - 1],
+            faceFaces[facei - 1],
+            faceSegments[facei - 1],
+            faceCurveDist[facei - 1],
+            facePts[facei],
+            faceFaces[facei],
+            faceSegments[facei],
+            samplingPts,
+            samplingCells,
+            samplingFaces,
+            samplingSegments,
+            samplingCurveDist
+        );
+    }
+}
+
+
+void Foam::lineCellSet::genSamples()
+{
+    DynamicList<point> samplingPts;
+    DynamicList<label> samplingCells;
+    DynamicList<label> samplingFaces;
+    DynamicList<label> samplingSegments;
+    DynamicList<scalar> samplingCurveDist;
+
+    calcSamples
+    (
+        samplingPts,
+        samplingCells,
+        samplingFaces,
+        samplingSegments,
+        samplingCurveDist
+    );
+
+    samplingPts.shrink();
+    samplingCells.shrink();
+    samplingFaces.shrink();
+    samplingSegments.shrink();
+    samplingCurveDist.shrink();
+
+    setSamples
+    (
+        samplingPts,
+        samplingCells,
+        samplingFaces,
+        samplingSegments,
+        samplingCurveDist
+    );
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::lineCellSet::lineCellSet
+(
+    const word& name,
+    const polyMesh& mesh,
+    const meshSearch& searchEngine,
+    const dictionary& dict
+)
+:
+    sampledSet(name, mesh, searchEngine, dict),
+    start_(dict.lookup("start")),
+    end_(dict.lookup("end"))
+{
+    genSamples();
+
+    if (debug)
+    {
+        write(Info);
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::lineCellSet::~lineCellSet()
+{}
+
+
+// ************************************************************************* //
diff --git a/src/sampling/sampledSet/face/faceOnlySet.H b/src/sampling/sampledSet/lineCell/lineCellSet.H
similarity index 60%
rename from src/sampling/sampledSet/face/faceOnlySet.H
rename to src/sampling/sampledSet/lineCell/lineCellSet.H
index 39c1dcda59..b21255d9e8 100644
--- a/src/sampling/sampledSet/face/faceOnlySet.H
+++ b/src/sampling/sampledSet/lineCell/lineCellSet.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2018 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -22,21 +22,38 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Class
-    Foam::faceOnlySet
+    Foam::lineCellSet
 
 Description
+    Cell-samples along a line at the mid-points in-between face-intersections
+
+Usage
+    \table
+        Property    | Description                            | Req'd? | Default
+        start       | The start point of the line            | yes    |
+        end         | The end point of the line              | yes    |
+        axis        | The coordinate axis that is written    | yes    |
+    \endtable
+
+    Example specification:
+    \verbatim
+    {
+        type        lineCell;
+        start       (0.5 0.6 0.5);
+        end         (0.5 -0.3 -0.1);
+        axis        x;
+    }
+    \endverbatim
 
 SourceFiles
-    faceOnlySet.C
+    lineCellSet.C
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef faceOnlySet_H
-#define faceOnlySet_H
+#ifndef lineCellSet_H
+#define lineCellSet_H
 
-#include "sampledSet.H"
-#include "DynamicList.H"
-#include "passiveParticleCloud.H"
+#include "lineFaceSet.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -44,42 +61,26 @@ namespace Foam
 {
 
 /*---------------------------------------------------------------------------*\
-                         Class faceOnlySet Declaration
+                         Class lineCellSet Declaration
 \*---------------------------------------------------------------------------*/
 
-class faceOnlySet
+class lineCellSet
 :
     public sampledSet
 {
     // Private data
 
-        //- Starting point
-        point start_;
+        //- Start point
+        const point start_;
 
         //- End point
-        point end_;
+        const point end_;
 
 
     // Private Member Functions
 
-        //- Samples from startTrackPt/Celli. Updates particle/samplePt/sampleI
-        //  and puts
-        //  samples in the DynamicLists. Returns false if end of all samples
-        //  reached
-        bool trackToBoundary
-        (
-            passiveParticleCloud& particleCloud,
-            passiveParticle& singleParticle,
-            const scalar smallDist,
-            DynamicList<point>& samplingPts,
-            DynamicList<label>& samplingCells,
-            DynamicList<label>& samplingFaces,
-            DynamicList<scalar>& samplingCurve
-        ) const;
-
-        //- Samples from start_ to end_. samplingSegments contains segmentNo
-        //  for each sample.
-        void calcSamples
+        //- Calculate all the sampling points
+        virtual void calcSamples
         (
             DynamicList<point>& samplingPts,
             DynamicList<label>& samplingCells,
@@ -88,38 +89,41 @@ class faceOnlySet
             DynamicList<scalar>& samplingCurveDist
         ) const;
 
-        //- Uses calcSamples to obtain samples. Copies them into *this.
+        //- Uses calcSamples to obtain samples and copies them into *this
         void genSamples();
 
 
 public:
 
     //- Runtime type information
-    TypeName("face");
+    TypeName("lineCell");
 
 
-    // Static data
+    // Static Member Functions
 
-        //- Tolerance when comparing points relative to difference between
-        //  start_ and end_
-        static const scalar tol;
+        //- Calculate the next mid point sample
+        static void calcMidPointSample
+        (
+            const polyMesh& mesh,
+            const point& prevPt,
+            const label prevFace,
+            const label prevSegment,
+            const scalar prevCurveDist,
+            const point& nextPt,
+            const label nextFace,
+            const label nextSegment,
+            DynamicList<point>& samplingPts,
+            DynamicList<label>& samplingCells,
+            DynamicList<label>& samplingFaces,
+            DynamicList<label>& samplingSegments,
+            DynamicList<scalar>& samplingCurveDist
+        );
 
 
     // Constructors
 
-        //- Construct from components
-        faceOnlySet
-        (
-            const word& name,
-            const polyMesh& mesh,
-            const meshSearch& searchEngine,
-            const word& axis,
-            const point& start,
-            const point& end
-        );
-
         //- Construct from dictionary
-        faceOnlySet
+        lineCellSet
         (
             const word& name,
             const polyMesh& mesh,
@@ -129,20 +133,7 @@ public:
 
 
     //- Destructor
-    virtual ~faceOnlySet();
-
-
-    // Member Functions
-
-        const point& start() const
-        {
-            return start_;
-        }
-
-        const point& end() const
-        {
-            return end_;
-        }
+    virtual ~lineCellSet();
 };
 
 
diff --git a/src/sampling/sampledSet/lineCellFace/lineCellFaceSet.C b/src/sampling/sampledSet/lineCellFace/lineCellFaceSet.C
new file mode 100644
index 0000000000..5b07efcf72
--- /dev/null
+++ b/src/sampling/sampledSet/lineCellFace/lineCellFaceSet.C
@@ -0,0 +1,199 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2018 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "lineCellFaceSet.H"
+#include "meshSearch.H"
+#include "DynamicList.H"
+#include "polyMesh.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(lineCellFaceSet, 0);
+    addToRunTimeSelectionTable(sampledSet, lineCellFaceSet, word);
+}
+
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+void Foam::lineCellFaceSet::calcSamples
+(
+    DynamicList<point>& samplingPts,
+    DynamicList<label>& samplingCells,
+    DynamicList<label>& samplingFaces,
+    DynamicList<label>& samplingSegments,
+    DynamicList<scalar>& samplingCurveDist
+) const
+{
+    // Run the algorithm from lineFaceSet to get all the face intersections
+    DynamicList<point> facePts;
+    DynamicList<label> faceCells;
+    DynamicList<label> faceFaces;
+    DynamicList<label> faceSegments;
+    DynamicList<scalar> faceCurveDist;
+    lineFaceSet::calcSamples
+    (
+        mesh(),
+        searchEngine(),
+        start_,
+        end_,
+        facePts,
+        faceCells,
+        faceFaces,
+        faceSegments,
+        faceCurveDist
+    );
+
+    // If there are no intersections then quit
+    if (!facePts.size())
+    {
+        return;
+    }
+
+    // Append all the face intersections to the set, additionally adding mid
+    // points when the segment is the same
+    samplingPts.append(facePts[0]);
+    samplingCells.append(faceCells[0]);
+    samplingFaces.append(faceFaces[0]);
+    samplingSegments.append(faceSegments[0]);
+    samplingCurveDist.append(faceCurveDist[0]);
+
+    for (label facei = 1; facei < facePts.size(); ++ facei)
+    {
+        lineCellSet::calcMidPointSample
+        (
+            mesh(),
+            samplingPts.last(),
+            samplingFaces.last(),
+            samplingSegments.last(),
+            samplingCurveDist.last(),
+            facePts[facei],
+            faceFaces[facei],
+            faceSegments[facei],
+            samplingPts,
+            samplingCells,
+            samplingFaces,
+            samplingSegments,
+            samplingCurveDist
+        );
+
+        samplingPts.append(facePts[facei]);
+        samplingCells.append(faceCells[facei]);
+        samplingFaces.append(faceFaces[facei]);
+        samplingSegments.append(faceSegments[facei]);
+        samplingCurveDist.append(faceCurveDist[facei]);
+    }
+}
+
+
+void Foam::lineCellFaceSet::genSamples()
+{
+    DynamicList<point> samplingPts;
+    DynamicList<label> samplingCells;
+    DynamicList<label> samplingFaces;
+    DynamicList<label> samplingSegments;
+    DynamicList<scalar> samplingCurveDist;
+
+    calcSamples
+    (
+        samplingPts,
+        samplingCells,
+        samplingFaces,
+        samplingSegments,
+        samplingCurveDist
+    );
+
+    samplingPts.shrink();
+    samplingCells.shrink();
+    samplingFaces.shrink();
+    samplingSegments.shrink();
+    samplingCurveDist.shrink();
+
+    setSamples
+    (
+        samplingPts,
+        samplingCells,
+        samplingFaces,
+        samplingSegments,
+        samplingCurveDist
+    );
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::lineCellFaceSet::lineCellFaceSet
+(
+    const word& name,
+    const polyMesh& mesh,
+    const meshSearch& searchEngine,
+    const dictionary& dict
+)
+:
+    sampledSet(name, mesh, searchEngine, dict),
+    start_(dict.lookup("start")),
+    end_(dict.lookup("end"))
+{
+    genSamples();
+
+    if (debug)
+    {
+        write(Info);
+    }
+}
+
+
+Foam::lineCellFaceSet::lineCellFaceSet
+(
+    const word& name,
+    const polyMesh& mesh,
+    const meshSearch& searchEngine,
+    const word& axis,
+    const point& start,
+    const point& end
+)
+:
+    sampledSet(name, mesh, searchEngine, axis),
+    start_(start),
+    end_(end)
+{
+    genSamples();
+
+    if (debug)
+    {
+        write(Info);
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::lineCellFaceSet::~lineCellFaceSet()
+{}
+
+
+// ************************************************************************* //
diff --git a/src/sampling/sampledSet/circle/circleSet.H b/src/sampling/sampledSet/lineCellFace/lineCellFaceSet.H
similarity index 65%
rename from src/sampling/sampledSet/circle/circleSet.H
rename to src/sampling/sampledSet/lineCellFace/lineCellFaceSet.H
index b0e6ed1361..c5cfd47415 100644
--- a/src/sampling/sampledSet/circle/circleSet.H
+++ b/src/sampling/sampledSet/lineCellFace/lineCellFaceSet.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2018 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -22,63 +22,66 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Class
-    Foam::circleSet
+    Foam::lineCellFaceSet
 
 Description
-    Samples along a circular path
+    Face-intersections along a line, plus cell-samples at the mid-points
+    in-between
+
+Usage
+    \table
+        Property    | Description                            | Req'd? | Default
+        start       | The start point of the line            | yes    |
+        end         | The end point of the line              | yes    |
+        axis        | The coordinate axis that is written    | yes    |
+    \endtable
+
+    Example specification:
+    \verbatim
+    {
+        type        lineCellFace;
+        start       (0.55 0.6 0.5);
+        end         (0.55 -0.3 -0.1);
+        axis        x;
+    }
+    \endverbatim
 
 SourceFiles
-    circleSet.C
+    lineCellFaceSet.C
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef circleSet_H
-#define circleSet_H
+#ifndef lineCellFaceSet_H
+#define lineCellFaceSet_H
 
-#include "sampledSet.H"
-#include "DynamicList.H"
+#include "lineCellSet.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 namespace Foam
 {
 
-// Forward declaration of classes
-class meshSearch;
-
 /*---------------------------------------------------------------------------*\
-                          Class circleSet Declaration
+                         Class lineCellFaceSet Declaration
 \*---------------------------------------------------------------------------*/
 
-class circleSet
+class lineCellFaceSet
 :
     public sampledSet
 {
     // Private data
 
-        // Circle definition
+        //- Start point
+        const point start_;
 
-            //- Origin (x, y, z) in global cartesian co-ordinates
-            point origin_;
-
-            //- Axis of the circle
-            vector circleAxis_;
-
-            //- Point on circle (x, y, z) in global cartesian co-ordinates
-            //  Defines start point
-            point startPoint_;
-
-
-        // Sampling definition
-
-            //- Sampling interval in degrees about the origin
-            scalar dTheta_;
+        //- End point
+        const point end_;
 
 
     // Private Member Functions
 
-        //- Samples all points in sampleCoords.
-        void calcSamples
+        //- Calculate all the sampling points
+        virtual void calcSamples
         (
             DynamicList<point>& samplingPts,
             DynamicList<label>& samplingCells,
@@ -87,32 +90,20 @@ class circleSet
             DynamicList<scalar>& samplingCurveDist
         ) const;
 
-        //- Uses calcSamples to obtain samples. Copies them into *this.
+        //- Uses calcSamples to obtain samples and copies them into *this
         void genSamples();
 
+
 public:
 
     //- Runtime type information
-    TypeName("circle");
+    TypeName("lineCellFace");
 
 
     // Constructors
 
-        //- Construct from components
-        circleSet
-        (
-            const word& name,
-            const polyMesh& mesh,
-            const meshSearch& searchEngine,
-            const word& axis,
-            const point& origin,
-            const vector& circleAxis,
-            const point& startPoint,
-            const scalar dTheta
-        );
-
         //- Construct from dictionary
-        circleSet
+        lineCellFaceSet
         (
             const word& name,
             const polyMesh& mesh,
@@ -120,16 +111,20 @@ public:
             const dictionary& dict
         );
 
-
-    // Destructor
-
-        virtual ~circleSet();
+        //- Construct from components
+        lineCellFaceSet
+        (
+            const word& name,
+            const polyMesh& mesh,
+            const meshSearch& searchEngine,
+            const word& axis,
+            const point& start,
+            const point& end
+        );
 
 
-    // Member Functions
-
-        //- Get reference point
-        virtual point getRefPoint(const List<point>&) const;
+    //- Destructor
+    virtual ~lineCellFaceSet();
 };
 
 
diff --git a/src/sampling/sampledSet/lineFace/lineFaceSet.C b/src/sampling/sampledSet/lineFace/lineFaceSet.C
new file mode 100644
index 0000000000..6684daeb00
--- /dev/null
+++ b/src/sampling/sampledSet/lineFace/lineFaceSet.C
@@ -0,0 +1,251 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2018 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "lineFaceSet.H"
+#include "meshSearch.H"
+#include "DynamicList.H"
+#include "polyMesh.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(lineFaceSet, 0);
+    addToRunTimeSelectionTable(sampledSet, lineFaceSet, word);
+}
+
+
+// * * * * * * * * * * * * * Static Member Functions * * * * * * * * * * * * //
+
+void Foam::lineFaceSet::calcSamples
+(
+    const polyMesh& mesh,
+    const meshSearch& searchEngine,
+    const vector& start,
+    const vector& end,
+    DynamicList<point>& samplingPts,
+    DynamicList<label>& samplingCells,
+    DynamicList<label>& samplingFaces,
+    DynamicList<label>& samplingSegments,
+    DynamicList<scalar>& samplingCurveDist
+)
+{
+    // Test for an inward pointing first hit. If this exists, then the start
+    // point is outside, and the sampling should begin from the hit.
+    label bHitI = -1;
+    const List<pointIndexHit> bHits =
+        searchEngine.intersections(start, end);
+    if (bHits.size())
+    {
+        const label bFaceI = bHits[0].index();
+        const vector bNormal = normalised(mesh.faceAreas()[bFaceI]);
+        const scalar bDot = bNormal & (end - start);
+        if (bDot < 0)
+        {
+            bHitI = 0;
+        }
+    }
+
+    // If an initial inward pointing hit was not found then initialise the
+    // within the cell containing the start point
+    vector startPt = vector::max;
+    label startFaceI = -1, startCellI = -1;
+    if (bHitI == -1)
+    {
+        startPt = start;
+        startFaceI = -1;
+        startCellI = searchEngine.findCell(start);
+    }
+
+    // If neither hits nor a containing cell for the start point were found then
+    // the line is completely outside the mesh. Return without generating any
+    // sampling points.
+    if (bHits.size() == 0 && startCellI == -1)
+    {
+        return;
+    }
+
+    // If nothing is set by now then something has gone wrong
+    if (bHitI == -1 && startCellI == -1)
+    {
+        FatalErrorInFunction
+            << "The initial location for the line " << start << " to " << end
+            << "could not be found" << exit(FatalError);
+    }
+
+    // Loop over the hits, starting a new segment at every second hit
+    for
+    (
+        label sampleSegmentI = 0;
+        bHitI < bHits.size();
+        bHitI += 2, sampleSegmentI += 1
+    )
+    {
+        // Set the start point and topology, unless starting within a cell
+        if (bHitI != -1)
+        {
+            startPt = bHits[bHitI].hitPoint();
+            startFaceI = bHits[bHitI].index();
+            startCellI = mesh.faceOwner()[startFaceI];
+        }
+
+        // Create a particle. If we are starting on a boundary face, track
+        // backwards into it so that the particle has the correct topology.
+        passiveParticle sampleParticle(mesh, startPt, startCellI);
+        if (startFaceI != -1)
+        {
+            sampleParticle.track(start - end, 0);
+            if (!sampleParticle.onBoundaryFace())
+            {
+                FatalErrorInFunction
+                    << exit(FatalError);
+            }
+        }
+
+        // Track until a boundary is hit, appending the face intersections to
+        // the lists of samples
+        while (true)
+        {
+            const point pt = sampleParticle.position();
+            const scalar dist = mag(pt - start);
+            const bool first =
+                samplingSegments.size() == 0
+             || samplingSegments.last() != sampleSegmentI;
+
+            if (sampleParticle.onFace())
+            {
+                samplingPts.append(pt);
+                samplingCells.append(sampleParticle.cell());
+                samplingFaces.append(sampleParticle.face());
+                samplingSegments.append(sampleSegmentI);
+                samplingCurveDist.append(dist);
+            }
+
+            const vector s = (1 - dist/mag(end - start))*(end - start);
+
+            if
+            (
+                (!first && sampleParticle.onBoundaryFace())
+             || sampleParticle.trackToCell(s, 0) == 0
+            )
+            {
+                break;
+            }
+        }
+    }
+}
+
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+void Foam::lineFaceSet::calcSamples
+(
+    DynamicList<point>& samplingPts,
+    DynamicList<label>& samplingCells,
+    DynamicList<label>& samplingFaces,
+    DynamicList<label>& samplingSegments,
+    DynamicList<scalar>& samplingCurveDist
+) const
+{
+    calcSamples
+    (
+        mesh(),
+        searchEngine(),
+        start_,
+        end_,
+        samplingPts,
+        samplingCells,
+        samplingFaces,
+        samplingSegments,
+        samplingCurveDist
+    );
+}
+
+
+void Foam::lineFaceSet::genSamples()
+{
+    DynamicList<point> samplingPts;
+    DynamicList<label> samplingCells;
+    DynamicList<label> samplingFaces;
+    DynamicList<label> samplingSegments;
+    DynamicList<scalar> samplingCurveDist;
+
+    calcSamples
+    (
+        samplingPts,
+        samplingCells,
+        samplingFaces,
+        samplingSegments,
+        samplingCurveDist
+    );
+
+    samplingPts.shrink();
+    samplingCells.shrink();
+    samplingFaces.shrink();
+    samplingSegments.shrink();
+    samplingCurveDist.shrink();
+
+    setSamples
+    (
+        samplingPts,
+        samplingCells,
+        samplingFaces,
+        samplingSegments,
+        samplingCurveDist
+    );
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::lineFaceSet::lineFaceSet
+(
+    const word& name,
+    const polyMesh& mesh,
+    const meshSearch& searchEngine,
+    const dictionary& dict
+)
+:
+    sampledSet(name, mesh, searchEngine, dict),
+    start_(dict.lookup("start")),
+    end_(dict.lookup("end"))
+{
+    genSamples();
+
+    if (debug)
+    {
+        write(Info);
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::lineFaceSet::~lineFaceSet()
+{}
+
+
+// ************************************************************************* //
diff --git a/src/sampling/sampledSet/polyLine/polyLineSet.H b/src/sampling/sampledSet/lineFace/lineFaceSet.H
similarity index 68%
rename from src/sampling/sampledSet/polyLine/polyLineSet.H
rename to src/sampling/sampledSet/lineFace/lineFaceSet.H
index eedee44e10..d7fde88165 100644
--- a/src/sampling/sampledSet/polyLine/polyLineSet.H
+++ b/src/sampling/sampledSet/lineFace/lineFaceSet.H
@@ -22,18 +22,36 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Class
-    Foam::polyLineSet
+    Foam::lineFaceSet
 
 Description
-    Sample along poly line defined by a list of points (knots)
+    Face-intersections along a line
+
+Usage
+    \table
+        Property    | Description                            | Req'd? | Default
+        start       | The start point of the line            | yes    |
+        end         | The end point of the line              | yes    |
+        axis        | The coordinate axis that is written    | yes    |
+    \endtable
+
+    Example specification:
+    \verbatim
+    {
+        type        lineFace;
+        start       (0.6 0.6 0.5);
+        end         (0.6 -0.3 -0.1);
+        axis        x;
+    }
+    \endverbatim
 
 SourceFiles
-    polyLineSet.C
+    lineFaceSet.C
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef polyLineSet_H
-#define polyLineSet_H
+#ifndef lineFaceSet_H
+#define lineFaceSet_H
 
 #include "sampledSet.H"
 #include "DynamicList.H"
@@ -45,37 +63,25 @@ namespace Foam
 {
 
 /*---------------------------------------------------------------------------*\
-                        Class polyLineSet Declaration
+                         Class lineFaceSet Declaration
 \*---------------------------------------------------------------------------*/
 
-class polyLineSet
+class lineFaceSet
 :
     public sampledSet
 {
     // Private data
 
-        //- Sampling points
-        List<point> sampleCoords_;
+        //- Start point
+        const point start_;
+
+        //- End point
+        const point end_;
 
 
-    // Private Member Functions
+    // Protected Member Functions
 
-        //- Sample till hits boundary. Called with singleParticle at position
-        //  in between sampleCoords_[sampleI] and sampleCoords_[sampleI+1].
-        //  Returns false if end of samples reached.
-        bool trackToBoundary
-        (
-            passiveParticleCloud& particleCloud,
-            passiveParticle& singleParticle,
-            label& sampleI,
-            DynamicList<point>& samplingPts,
-            DynamicList<label>& samplingCells,
-            DynamicList<label>& samplingFaces,
-            DynamicList<scalar>& samplingCurveDist
-        ) const;
-
-        //- Samples all point in sampleCoords_
-        //  samplingSegments contains segmentNo for each sample.
+        //- Calculate all the sampling points
         void calcSamples
         (
             DynamicList<point>& samplingPts,
@@ -85,37 +91,37 @@ class polyLineSet
             DynamicList<scalar>& samplingCurveDist
         ) const;
 
-        //- Uses calcSamples to obtain samples. Copies them into *this.
+        //- Uses calcSamples to obtain samples and copies them into *this
         void genSamples();
 
 
 public:
 
     //- Runtime type information
-    TypeName("polyLine");
+    TypeName("lineFace");
 
 
-    // Static data
+    // Static Member Functions
 
-        //- Tolerance when comparing points relative to difference between
-        //  start_ and end_
-        static const scalar tol;
+        //- Calculate all the sampling points
+        static void calcSamples
+        (
+            const polyMesh& mesh,
+            const meshSearch& searchEngine,
+            const vector& start,
+            const vector& end,
+            DynamicList<point>& samplingPts,
+            DynamicList<label>& samplingCells,
+            DynamicList<label>& samplingFaces,
+            DynamicList<label>& samplingSegments,
+            DynamicList<scalar>& samplingCurveDist
+        );
 
 
     // Constructors
 
-        //- Construct from components
-        polyLineSet
-        (
-            const word& name,
-            const polyMesh& mesh,
-            const meshSearch& searchEngine,
-            const word& axis,
-            const List<point>& samplePoints
-        );
-
         //- Construct from dictionary
-        polyLineSet
+        lineFaceSet
         (
             const word& name,
             const polyMesh& mesh,
@@ -125,7 +131,7 @@ public:
 
 
     //- Destructor
-    virtual ~polyLineSet();
+    virtual ~lineFaceSet();
 };
 
 
diff --git a/src/sampling/sampledSet/lineUniform/lineUniformSet.C b/src/sampling/sampledSet/lineUniform/lineUniformSet.C
new file mode 100644
index 0000000000..f34a51839a
--- /dev/null
+++ b/src/sampling/sampledSet/lineUniform/lineUniformSet.C
@@ -0,0 +1,158 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2018 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "lineUniformSet.H"
+#include "meshSearch.H"
+#include "DynamicList.H"
+#include "polyMesh.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(lineUniformSet, 0);
+    addToRunTimeSelectionTable(sampledSet, lineUniformSet, word);
+}
+
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+void Foam::lineUniformSet::calcSamples
+(
+    DynamicList<point>& samplingPts,
+    DynamicList<label>& samplingCells,
+    DynamicList<label>& samplingFaces,
+    DynamicList<label>& samplingSegments,
+    DynamicList<scalar>& samplingCurveDist
+) const
+{
+    label sampleSegmentI = 0, sampleI = 0;
+    scalar sampleT = 0;
+
+    while (sampleI < nPoints_)
+    {
+        const point pt = (1 - sampleT)*start_ + sampleT*end_;
+
+        const label sampleCellI = searchEngine().findCell(pt);
+
+        if (sampleCellI == -1)
+        {
+            if (++ sampleI < nPoints_)
+            {
+                sampleT = scalar(sampleI)/(nPoints_ - 1);
+            }
+        }
+        else
+        {
+            passiveParticle sampleParticle(mesh(), pt, sampleCellI);
+
+            do
+            {
+                samplingPts.append(sampleParticle.position());
+                samplingCells.append(sampleParticle.cell());
+                samplingFaces.append(-1);
+                samplingSegments.append(sampleSegmentI);
+                samplingCurveDist.append(sampleT*mag(end_ - start_));
+
+                if (++ sampleI < nPoints_)
+                {
+                    sampleT = scalar(sampleI)/(nPoints_ - 1);
+                    sampleParticle.track((end_ - start_)/(nPoints_ - 1), 0);
+                }
+            }
+            while (sampleI < nPoints_ && !sampleParticle.onBoundaryFace());
+
+            ++ sampleSegmentI;
+        }
+    }
+}
+
+
+void Foam::lineUniformSet::genSamples()
+{
+    DynamicList<point> samplingPts;
+    DynamicList<label> samplingCells;
+    DynamicList<label> samplingFaces;
+    DynamicList<label> samplingSegments;
+    DynamicList<scalar> samplingCurveDist;
+
+    calcSamples
+    (
+        samplingPts,
+        samplingCells,
+        samplingFaces,
+        samplingSegments,
+        samplingCurveDist
+    );
+
+    samplingPts.shrink();
+    samplingCells.shrink();
+    samplingFaces.shrink();
+    samplingSegments.shrink();
+    samplingCurveDist.shrink();
+
+    setSamples
+    (
+        samplingPts,
+        samplingCells,
+        samplingFaces,
+        samplingSegments,
+        samplingCurveDist
+    );
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::lineUniformSet::lineUniformSet
+(
+    const word& name,
+    const polyMesh& mesh,
+    const meshSearch& searchEngine,
+    const dictionary& dict
+)
+:
+    sampledSet(name, mesh, searchEngine, dict),
+    start_(dict.lookup("start")),
+    end_(dict.lookup("end")),
+    nPoints_(readLabel(dict.lookup("nPoints")))
+{
+    genSamples();
+
+    if (debug)
+    {
+        write(Pout);
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::lineUniformSet::~lineUniformSet()
+{}
+
+
+// ************************************************************************* //
diff --git a/src/sampling/sampledSet/lineUniform/lineUniformSet.H b/src/sampling/sampledSet/lineUniform/lineUniformSet.H
new file mode 100644
index 0000000000..69ed798eff
--- /dev/null
+++ b/src/sampling/sampledSet/lineUniform/lineUniformSet.H
@@ -0,0 +1,135 @@
+/*---------------------------------------------------------------------------* \
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2018 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::lineUniformSet
+
+Description
+    Uniform samples along a line
+
+Usage
+    \table
+        Property    | Description                            | Req'd? | Default
+        start       | The start point of the line            | yes    |
+        end         | The end point of the line              | yes    |
+        nPoints     | The number of points                   | yes    |
+        axis        | The coordinate axis that is written    | yes    |
+    \endtable
+
+    Example specification:
+    \verbatim
+    {
+        type        lineUniform;
+        start       (0.65 0.3 0.3);
+        end         (0.65 -0.3 -0.1);
+        nPoints     200;
+        axis        x;
+    }
+    \endverbatim
+
+SourceFiles
+    lineUniformSet.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef lineUniformSet_H
+#define lineUniformSet_H
+
+#include "passiveParticleCloud.H"
+#include "sampledSet.H"
+#include "DynamicList.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                           Class lineUniformSet Declaration
+\*---------------------------------------------------------------------------*/
+
+class lineUniformSet
+:
+    public sampledSet
+{
+    // Private data
+
+        //- Starting point
+        const point start_;
+
+        //- End point
+        const point end_;
+
+        //- Number of points
+        const label nPoints_;
+
+
+    // Private Member Functions
+
+        //- Samples from start_ to end_. samplingSegments contains segmentNo
+        //  for each sample.
+        void calcSamples
+        (
+            DynamicList<point>& samplingPts,
+            DynamicList<label>& samplingCells,
+            DynamicList<label>& samplingFaces,
+            DynamicList<label>& samplingSegments,
+            DynamicList<scalar>& samplingCurveDist
+        ) const;
+
+        //- Uses calcSamples to obtain samples. Copies them into *this.
+        void genSamples();
+
+
+public:
+
+    //- Runtime type information
+    TypeName("lineUniform");
+
+
+    // Constructors
+
+        //- Construct from dictionary
+        lineUniformSet
+        (
+            const word& name,
+            const polyMesh& mesh,
+            const meshSearch& searchEngine,
+            const dictionary& dict
+        );
+
+
+    //- Destructor
+    virtual ~lineUniformSet();
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/sampling/sampledSet/midPoint/midPointSet.C b/src/sampling/sampledSet/midPoint/midPointSet.C
deleted file mode 100644
index 38031ee7b0..0000000000
--- a/src/sampling/sampledSet/midPoint/midPointSet.C
+++ /dev/null
@@ -1,150 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-\*---------------------------------------------------------------------------*/
-
-#include "midPointSet.H"
-#include "polyMesh.H"
-#include "meshSearch.H"
-#include "addToRunTimeSelectionTable.H"
-
-// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
-
-namespace Foam
-{
-    defineTypeNameAndDebug(midPointSet, 0);
-    addToRunTimeSelectionTable(sampledSet, midPointSet, word);
-}
-
-
-// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
-
-void Foam::midPointSet::genSamples()
-{
-    // Generate midpoints.
-
-    List<point> midPoints(2*size());
-    labelList midCells(2*size());
-    labelList midSegments(2*size());
-    scalarList midCurveDist(2*size());
-
-    label mSamplei = 0;
-    label samplei = 0;
-
-    while (size() > 0)
-    {
-        // Calculate midpoint between samplei and samplei+1 (if in same segment)
-        while
-        (
-            (samplei < size() - 1)
-         && (segments_[samplei] == segments_[samplei+1])
-        )
-        {
-            point midPoint(0.5*(operator[](samplei) + operator[](samplei+1)));
-            label cellm = pointInCell(midPoint, samplei);
-
-            if (cellm != -1)
-            {
-                midPoints[mSamplei] = midPoint;
-                midCells[mSamplei] = cellm;
-                midSegments[mSamplei] = segments_[samplei];
-                midCurveDist[mSamplei] = mag(midPoints[mSamplei] - start());
-                mSamplei++;
-            }
-
-            samplei++;
-        }
-
-        if (samplei == size() - 1)
-        {
-            break;
-        }
-
-        samplei++;
-    }
-
-    midPoints.setSize(mSamplei);
-    midCells.setSize(mSamplei);
-    midSegments.setSize(mSamplei);
-    midCurveDist.setSize(mSamplei);
-
-    setSamples
-    (
-        midPoints,
-        midCells,
-        labelList(midCells.size(), -1),
-        midSegments,
-        midCurveDist
-    );
-}
-
-
-// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
-
-Foam::midPointSet::midPointSet
-(
-    const word& name,
-    const polyMesh& mesh,
-    const meshSearch& searchEngine,
-    const word& axis,
-    const point& start,
-    const point& end
-)
-:
-    faceOnlySet(name, mesh, searchEngine, axis, start, end)
-{
-    genSamples();
-
-    if (debug)
-    {
-        write(Info);
-    }
-}
-
-
-Foam::midPointSet::midPointSet
-(
-    const word& name,
-    const polyMesh& mesh,
-    const meshSearch& searchEngine,
-    const dictionary& dict
-)
-:
-    faceOnlySet(name, mesh, searchEngine, dict)
-{
-    genSamples();
-
-    if (debug)
-    {
-        write(Info);
-    }
-}
-
-
-// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
-
-Foam::midPointSet::~midPointSet()
-{}
-
-
-// ************************************************************************* //
diff --git a/src/sampling/sampledSet/midPoint/midPointSet.H b/src/sampling/sampledSet/midPoint/midPointSet.H
deleted file mode 100644
index 679acbc8bf..0000000000
--- a/src/sampling/sampledSet/midPoint/midPointSet.H
+++ /dev/null
@@ -1,102 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-Class
-    Foam::midPointSet
-
-Description
-
-SourceFiles
-    midPointSet.C
-
-\*---------------------------------------------------------------------------*/
-
-#ifndef midPointSet_H
-#define midPointSet_H
-
-#include "faceOnlySet.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-namespace Foam
-{
-
-// Forward declaration of classes
-class meshSearch;
-
-/*---------------------------------------------------------------------------*\
-                           Class midPointSet Declaration
-\*---------------------------------------------------------------------------*/
-
-class midPointSet
-:
-    public faceOnlySet
-{
-    // Private Member Functions
-
-        void genSamples();
-
-
-public:
-
-    //- Runtime type information
-    TypeName("midPoint");
-
-
-    // Constructors
-
-        //- Construct from components
-        midPointSet
-        (
-            const word& name,
-            const polyMesh& mesh,
-            const meshSearch& searchEngine,
-            const word& axis,
-            const point& start,
-            const point& end
-        );
-
-        //- Construct from dictionary
-        midPointSet
-        (
-            const word& name,
-            const polyMesh& mesh,
-            const meshSearch& searchEngine,
-            const dictionary& dict
-        );
-
-
-    //- Destructor
-    virtual ~midPointSet();
-};
-
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#endif
-
-// ************************************************************************* //
diff --git a/src/sampling/sampledSet/midPointAndFace/midPointAndFaceSet.C b/src/sampling/sampledSet/midPointAndFace/midPointAndFaceSet.C
deleted file mode 100644
index 1628ca50ef..0000000000
--- a/src/sampling/sampledSet/midPointAndFace/midPointAndFaceSet.C
+++ /dev/null
@@ -1,170 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-\*---------------------------------------------------------------------------*/
-
-#include "midPointAndFaceSet.H"
-#include "polyMesh.H"
-#include "addToRunTimeSelectionTable.H"
-
-
-// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
-
-namespace Foam
-{
-    defineTypeNameAndDebug(midPointAndFaceSet, 0);
-    addToRunTimeSelectionTable(sampledSet, midPointAndFaceSet, word);
-}
-
-
-// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
-
-void Foam::midPointAndFaceSet::genSamples()
-{
-    // Generate midpoints and add to face points
-
-    List<point> mpfSamplePoints(3*size());
-    labelList mpfSampleCells(3*size());
-    labelList mpfSampleFaces(3*size());
-    labelList mpfSampleSegments(3*size());
-    scalarList mpfSampleCurveDist(3*size());
-
-    label mpfSamplei = 0;
-    label samplei = 0;
-
-    while (size() > 0)
-    {
-        // Add first face
-        mpfSamplePoints[mpfSamplei] = operator[](samplei);
-        mpfSampleCells[mpfSamplei] = cells_[samplei];
-        mpfSampleFaces[mpfSamplei] = faces_[samplei];
-        mpfSampleSegments[mpfSamplei] = segments_[samplei];
-        mpfSampleCurveDist[mpfSamplei] = curveDist_[samplei];
-        mpfSamplei++;
-
-        while
-        (
-            (samplei < size() - 1)
-         && (segments_[samplei] == segments_[samplei+1])
-        )
-        {
-            point midPoint(0.5*(operator[](samplei) + operator[](samplei+1)));
-            label cellm = pointInCell(midPoint, samplei);
-
-            if (cellm != -1)
-            {
-                mpfSamplePoints[mpfSamplei] = midPoint;
-                mpfSampleCells[mpfSamplei] = cellm;
-                mpfSampleFaces[mpfSamplei] = -1;
-                mpfSampleSegments[mpfSamplei] = segments_[samplei];
-                mpfSampleCurveDist[mpfSamplei] =
-                    mag(mpfSamplePoints[mpfSamplei] - start());
-
-                mpfSamplei++;
-            }
-
-            // Add second face
-            mpfSamplePoints[mpfSamplei] = operator[](samplei+1);
-            mpfSampleCells[mpfSamplei] = cells_[samplei+1];
-            mpfSampleFaces[mpfSamplei] = faces_[samplei+1];
-            mpfSampleSegments[mpfSamplei] = segments_[samplei+1];
-            mpfSampleCurveDist[mpfSamplei] =
-                mag(mpfSamplePoints[mpfSamplei] - start());
-
-            mpfSamplei++;
-
-            samplei++;
-        }
-
-        if (samplei == size() - 1)
-        {
-            break;
-        }
-        samplei++;
-    }
-
-    mpfSamplePoints.setSize(mpfSamplei);
-    mpfSampleCells.setSize(mpfSamplei);
-    mpfSampleFaces.setSize(mpfSamplei);
-    mpfSampleSegments.setSize(mpfSamplei);
-    mpfSampleCurveDist.setSize(mpfSamplei);
-
-    setSamples
-    (
-        mpfSamplePoints,
-        mpfSampleCells,
-        mpfSampleFaces,
-        mpfSampleSegments,
-        mpfSampleCurveDist
-    );
-}
-
-// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
-
-Foam::midPointAndFaceSet::midPointAndFaceSet
-(
-    const word& name,
-    const polyMesh& mesh,
-    const meshSearch& searchEngine,
-    const word& axis,
-    const point& start,
-    const point& end
-)
-:
-    faceOnlySet(name, mesh, searchEngine, axis, start, end)
-{
-    genSamples();
-
-    if (debug)
-    {
-        write(Info);
-    }
-}
-
-
-Foam::midPointAndFaceSet::midPointAndFaceSet
-(
-    const word& name,
-    const polyMesh& mesh,
-    const meshSearch& searchEngine,
-    const dictionary& dict
-)
-:
-    faceOnlySet(name, mesh, searchEngine, dict)
-{
-    genSamples();
-
-    if (debug)
-    {
-        write(Info);
-    }
-}
-
-
-// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
-
-Foam::midPointAndFaceSet::~midPointAndFaceSet()
-{}
-
-
-// ************************************************************************* //
diff --git a/src/sampling/sampledSet/midPointAndFace/midPointAndFaceSet.H b/src/sampling/sampledSet/midPointAndFace/midPointAndFaceSet.H
deleted file mode 100644
index ee2b13cc82..0000000000
--- a/src/sampling/sampledSet/midPointAndFace/midPointAndFaceSet.H
+++ /dev/null
@@ -1,103 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-Class
-    Foam::midPointAndFaceSet
-
-Description
-
-SourceFiles
-    midPointAndFaceSet.C
-
-\*---------------------------------------------------------------------------*/
-
-#ifndef midPointAndFaceSet_H
-#define midPointAndFaceSet_H
-
-#include "faceOnlySet.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-namespace Foam
-{
-
-// Forward declaration of classes
-class meshSearch;
-
-/*---------------------------------------------------------------------------*\
-                           Class midPointAndFaceSet Declaration
-\*---------------------------------------------------------------------------*/
-
-class midPointAndFaceSet
-:
-    public faceOnlySet
-{
-
-    // Private Member Functions
-
-        void genSamples();
-
-
-public:
-
-    //- Runtime type information
-    TypeName("midPointAndFace");
-
-
-    // Constructors
-
-        //- Construct from components
-        midPointAndFaceSet
-        (
-            const word& name,
-            const polyMesh& mesh,
-            const meshSearch& searchEngine,
-            const word& axis,
-            const point& start,
-            const point& end
-        );
-
-        //- Construct from dictionary
-        midPointAndFaceSet
-        (
-            const word& name,
-            const polyMesh& mesh,
-            const meshSearch& searchEngine,
-            const dictionary& dict
-        );
-
-
-    //- Destructor
-    virtual ~midPointAndFaceSet();
-};
-
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#endif
-
-// ************************************************************************* //
diff --git a/src/sampling/sampledSet/patchSeed/patchSeedSet.C b/src/sampling/sampledSet/patchSeed/patchSeedSet.C
deleted file mode 100644
index f5b6937a56..0000000000
--- a/src/sampling/sampledSet/patchSeed/patchSeedSet.C
+++ /dev/null
@@ -1,239 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2012-2018 OpenFOAM Foundation
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-\*---------------------------------------------------------------------------*/
-
-#include "patchSeedSet.H"
-#include "polyMesh.H"
-#include "addToRunTimeSelectionTable.H"
-#include "treeBoundBox.H"
-#include "treeDataFace.H"
-#include "Time.H"
-#include "meshTools.H"
-//#include "Random.H"
-// For 'facePoint' helper function only
-#include "mappedPatchBase.H"
-
-// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
-
-namespace Foam
-{
-    defineTypeNameAndDebug(patchSeedSet, 0);
-    addToRunTimeSelectionTable(sampledSet, patchSeedSet, word);
-}
-
-
-// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
-
-void Foam::patchSeedSet::calcSamples
-(
-    DynamicList<point>& samplingPts,
-    DynamicList<label>& samplingCells,
-    DynamicList<label>& samplingFaces,
-    DynamicList<label>& samplingSegments,
-    DynamicList<scalar>& samplingCurveDist
-)
-{
-    if (debug)
-    {
-        Info<< "patchSeedSet : sampling on patches :" << endl;
-    }
-
-    // Construct search tree for all patch faces.
-    label sz = 0;
-    forAllConstIter(labelHashSet, patchSet_, iter)
-    {
-        const polyPatch& pp = mesh().boundaryMesh()[iter.key()];
-
-        sz += pp.size();
-
-        if (debug)
-        {
-            Info<< "    " << pp.name() << " size " << pp.size() << endl;
-        }
-    }
-
-    labelList patchFaces(sz);
-    sz = 0;
-    forAllConstIter(labelHashSet, patchSet_, iter)
-    {
-        const polyPatch& pp = mesh().boundaryMesh()[iter.key()];
-        forAll(pp, i)
-        {
-            patchFaces[sz++] = pp.start()+i;
-        }
-    }
-
-
-    label totalSize = returnReduce(sz, sumOp<label>());
-
-
-    // Shuffle and truncate if in random mode
-    if (maxPoints_ < totalSize)
-    {
-        // Check what fraction of maxPoints_ I need to generate locally.
-        label myMaxPoints = label(scalar(sz)/totalSize*maxPoints_);
-
-        rndGenPtr_.reset(new Random(123456));
-        Random& rndGen = rndGenPtr_();
-
-        labelList subset = identity(sz);
-        for (label iter = 0; iter < 4; iter++)
-        {
-            forAll(subset, i)
-            {
-                label j = rndGen.sampleAB<label>(0, subset.size());
-                Swap(subset[i], subset[j]);
-            }
-        }
-        // Truncate
-        subset.setSize(myMaxPoints);
-
-        // Subset patchFaces
-        patchFaces = UIndirectList<label>(patchFaces, subset)();
-
-        if (debug)
-        {
-            Pout<< "In random mode : selected " << patchFaces.size()
-                << " faces out of " << sz << endl;
-        }
-    }
-
-
-    // Get points on patchFaces.
-    globalIndex globalSampleNumbers(patchFaces.size());
-
-    samplingPts.setCapacity(patchFaces.size());
-    samplingCells.setCapacity(patchFaces.size());
-    samplingFaces.setCapacity(patchFaces.size());
-    samplingSegments.setCapacity(patchFaces.size());
-    samplingCurveDist.setCapacity(patchFaces.size());
-
-    // For calculation of min-decomp tet base points
-    (void)mesh().tetBasePtIs();
-
-    forAll(patchFaces, i)
-    {
-        label facei = patchFaces[i];
-        pointIndexHit info = mappedPatchBase::facePoint
-        (
-            mesh(),
-            facei,
-            polyMesh::FACE_DIAG_TRIS
-        );
-        label celli = mesh().faceOwner()[facei];
-
-        if (info.hit())
-        {
-            // Move the point into the cell
-            const point& cc = mesh().cellCentres()[celli];
-            samplingPts.append
-            (
-                info.hitPoint() + 1e-1*(cc-info.hitPoint())
-            );
-        }
-        else
-        {
-            samplingPts.append(info.rawPoint());
-        }
-        samplingCells.append(celli);
-        samplingFaces.append(facei);
-        samplingSegments.append(0);
-        samplingCurveDist.append(globalSampleNumbers.toGlobal(i));
-    }
-}
-
-
-void Foam::patchSeedSet::genSamples()
-{
-    // Storage for sample points
-    DynamicList<point> samplingPts;
-    DynamicList<label> samplingCells;
-    DynamicList<label> samplingFaces;
-    DynamicList<label> samplingSegments;
-    DynamicList<scalar> samplingCurveDist;
-
-    calcSamples
-    (
-        samplingPts,
-        samplingCells,
-        samplingFaces,
-        samplingSegments,
-        samplingCurveDist
-    );
-
-    samplingPts.shrink();
-    samplingCells.shrink();
-    samplingFaces.shrink();
-    samplingSegments.shrink();
-    samplingCurveDist.shrink();
-
-    setSamples
-    (
-        samplingPts,
-        samplingCells,
-        samplingFaces,
-        samplingSegments,
-        samplingCurveDist
-    );
-}
-
-
-// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
-
-Foam::patchSeedSet::patchSeedSet
-(
-    const word& name,
-    const polyMesh& mesh,
-    const meshSearch& searchEngine,
-    const dictionary& dict
-)
-:
-    sampledSet(name, mesh, searchEngine, dict),
-    patchSet_
-    (
-        mesh.boundaryMesh().patchSet
-        (
-            wordReList(dict.lookup("patches"))
-        )
-    ),
-    // searchDist_(readScalar(dict.lookup("maxDistance"))),
-    // offsetDist_(readScalar(dict.lookup("offsetDist"))),
-    maxPoints_(readLabel(dict.lookup("maxPoints")))
-{
-    genSamples();
-
-    if (debug)
-    {
-        write(Info);
-    }
-}
-
-
-// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
-
-Foam::patchSeedSet::~patchSeedSet()
-{}
-
-
-// ************************************************************************* //
diff --git a/src/sampling/sampledSet/points/pointsSet.C b/src/sampling/sampledSet/points/pointsSet.C
new file mode 100644
index 0000000000..4cb9ca010e
--- /dev/null
+++ b/src/sampling/sampledSet/points/pointsSet.C
@@ -0,0 +1,200 @@
+/*---------------------------------------------------------------------------* \
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2018 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "pointsSet.H"
+#include "meshSearch.H"
+#include "DynamicList.H"
+#include "polyMesh.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(pointsSet, 0);
+    addToRunTimeSelectionTable(sampledSet, pointsSet, word);
+}
+
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+void Foam::pointsSet::calcSamplesUnordered
+(
+    DynamicList<point>& samplingPts,
+    DynamicList<label>& samplingCells,
+    DynamicList<label>& samplingFaces,
+    DynamicList<label>& samplingSegments,
+    DynamicList<scalar>& samplingCurveDist
+) const
+{
+    forAll(points_, i)
+    {
+        const point& pt = points_[i];
+        const label celli = searchEngine().findCell(pt);
+
+        if (celli != -1)
+        {
+            samplingPts.append(pt);
+            samplingCells.append(celli);
+            samplingFaces.append(-1);
+            samplingSegments.append(samplingSegments.size());
+            samplingCurveDist.append(scalar(i));
+        }
+    }
+}
+
+void Foam::pointsSet::calcSamplesOrdered
+(
+    DynamicList<point>& samplingPts,
+    DynamicList<label>& samplingCells,
+    DynamicList<label>& samplingFaces,
+    DynamicList<label>& samplingSegments,
+    DynamicList<scalar>& samplingCurveDist
+) const
+{
+    const label n = points_.size();
+
+    label sampleSegmentI = 0;
+    label sampleI = 0;
+    scalar sampleDist = 0;
+
+    while (sampleI < n)
+    {
+        const point pt = points_[sampleI];
+
+        const label sampleCellI = searchEngine().findCell(pt);
+
+        if (sampleCellI == -1)
+        {
+            if (++ sampleI < n)
+            {
+                sampleDist += mag(points_[sampleI] - points_[sampleI - 1]);
+            }
+        }
+        else
+        {
+            passiveParticle sampleParticle(mesh(), pt, sampleCellI);
+
+            do
+            {
+                samplingPts.append(sampleParticle.position());
+                samplingCells.append(sampleParticle.cell());
+                samplingFaces.append(-1);
+                samplingSegments.append(sampleSegmentI);
+                samplingCurveDist.append(sampleDist);
+
+                if (++ sampleI < n)
+                {
+                    const vector s = points_[sampleI] - points_[sampleI - 1];
+                    sampleDist += mag(s);
+                    sampleParticle.track(s, 0);
+                }
+            }
+            while (sampleI < n && !sampleParticle.onBoundaryFace());
+
+            ++ sampleSegmentI;
+        }
+    }
+}
+
+
+void Foam::pointsSet::genSamples()
+{
+    DynamicList<point> samplingPts;
+    DynamicList<label> samplingCells;
+    DynamicList<label> samplingFaces;
+    DynamicList<label> samplingSegments;
+    DynamicList<scalar> samplingCurveDist;
+
+    if (!ordered_)
+    {
+        calcSamplesUnordered
+        (
+            samplingPts,
+            samplingCells,
+            samplingFaces,
+            samplingSegments,
+            samplingCurveDist
+        );
+    }
+    else
+    {
+        calcSamplesOrdered
+        (
+            samplingPts,
+            samplingCells,
+            samplingFaces,
+            samplingSegments,
+            samplingCurveDist
+        );
+    }
+
+    samplingPts.shrink();
+    samplingCells.shrink();
+    samplingFaces.shrink();
+    samplingSegments.shrink();
+    samplingCurveDist.shrink();
+
+    setSamples
+    (
+        samplingPts,
+        samplingCells,
+        samplingFaces,
+        samplingSegments,
+        samplingCurveDist
+    );
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::pointsSet::pointsSet
+(
+    const word& name,
+    const polyMesh& mesh,
+    const meshSearch& searchEngine,
+    const dictionary& dict
+)
+:
+    sampledSet(name, mesh, searchEngine, dict),
+    points_(dict.lookup("points")),
+    ordered_(dict.lookup("ordered"))
+{
+    genSamples();
+
+    if (debug)
+    {
+        write(Info);
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::pointsSet::~pointsSet()
+{}
+
+
+// ************************************************************************* //
diff --git a/src/sampling/sampledSet/uniform/uniformSet.H b/src/sampling/sampledSet/points/pointsSet.H
similarity index 59%
rename from src/sampling/sampledSet/uniform/uniformSet.H
rename to src/sampling/sampledSet/points/pointsSet.H
index b3dbd8bfeb..e9c2bce0bb 100644
--- a/src/sampling/sampledSet/uniform/uniformSet.H
+++ b/src/sampling/sampledSet/points/pointsSet.H
@@ -22,21 +22,54 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Class
-    Foam::uniformSet
+    Foam::pointsSet
 
 Description
+    Specified point samples. Optionally ordered into a continuous path.
+    Ordering is an optimisation; it enables tracking from one point to the
+    next. If ordering is off, each point is searched for individually.
+
+Usage
+    \table
+        Property    | Description                            | Req'd? | Default
+        points      | The points to sample                   | yes    |
+        ordered     | Are the points in order?               | yes    |
+        axis        | The coordinate axis that is written    | yes    |
+    \endtable
+
+    Example specification:
+    \verbatim
+    {
+        type        points;
+        points
+        (
+            (0.95 0 0.25)
+            (0.951251 0 0.250119)
+            (0.952468 0 0.250473)
+            (0.953618 0 0.251057)
+            (0.954669 0 0.251859)
+            (0.95559 0 0.252865)
+            (0.956353 0 0.254057)
+            (0.956931 0 0.255413)
+            (0.9573 0 0.256908)
+            (0.957441 0 0.258513)
+        );
+        ordered     yes;
+        axis        x;
+    }
+    \endverbatim
 
 SourceFiles
-    uniformSet.C
+    pointsSet.C
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef uniformSet_H
-#define uniformSet_H
+#ifndef pointsSet_H
+#define pointsSet_H
 
-#include "passiveParticleCloud.H"
 #include "sampledSet.H"
 #include "DynamicList.H"
+#include "passiveParticleCloud.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -44,57 +77,26 @@ namespace Foam
 {
 
 /*---------------------------------------------------------------------------*\
-                           Class uniformSet Declaration
+                        Class pointsSet Declaration
 \*---------------------------------------------------------------------------*/
 
-class uniformSet
+class pointsSet
 :
     public sampledSet
 {
     // Private data
 
-        //- Starting point
-        point start_;
+        //- Sampling points
+        const List<point> points_;
 
-        //- End point
-        point end_;
+        //- Do the points form an ordered sequence?
+        const Switch ordered_;
 
-        //- Number of points
-        label nPoints_;
 
     // Private Member Functions
 
-        //- Calculates - starting at samplePt - the first sampling point
-        //  on or after currentPt. smallDist is the tolerance used to compare
-        //  positions. Returns false if end of samples reached.
-        bool nextSample
-        (
-            const point& currentPt,
-            const vector& offset,
-            const scalar smallDist,
-            point& samplePt,
-            label& sampleI
-        ) const;
-
-        //- Samples from startTrackPt/Celli. Updates particle/samplePt/sampleI
-        //  and puts
-        //  samples in the DynamicLists. Returns false if end of all samples
-        //  reached
-        bool trackToBoundary
-        (
-            passiveParticleCloud& particleCloud,
-            passiveParticle& singleParticle,
-            point& samplePt,
-            label& sampleI,
-            DynamicList<point>& samplingPts,
-            DynamicList<label>& samplingCells,
-            DynamicList<label>& samplingFaces,
-            DynamicList<scalar>& samplingCurveDist
-        ) const;
-
-        //- Samples from start_ to end_. samplingSegments contains segmentNo
-        //  for each sample.
-        void calcSamples
+        //- Calculate all the sampling points
+        void calcSamplesUnordered
         (
             DynamicList<point>& samplingPts,
             DynamicList<label>& samplingCells,
@@ -103,39 +105,30 @@ class uniformSet
             DynamicList<scalar>& samplingCurveDist
         ) const;
 
-        //- Uses calcSamples to obtain samples. Copies them into *this.
+        //- Calculate all the sampling points
+        void calcSamplesOrdered
+        (
+            DynamicList<point>& samplingPts,
+            DynamicList<label>& samplingCells,
+            DynamicList<label>& samplingFaces,
+            DynamicList<label>& samplingSegments,
+            DynamicList<scalar>& samplingCurveDist
+        ) const;
+
+        //- Uses calcSamples to obtain samples and copies them into *this
         void genSamples();
 
 
 public:
 
     //- Runtime type information
-    TypeName("uniform");
-
-
-    // Static data
-
-        //- Tolerance when comparing points relative to difference between
-        //  start_ and end_
-        static const scalar tol;
+    TypeName("points");
 
 
     // Constructors
 
-        //- Construct from components
-        uniformSet
-        (
-            const word& name,
-            const polyMesh& mesh,
-            const meshSearch& searchEngine,
-            const word& axis,
-            const point& start,
-            const point& end,
-            const label nPoints
-        );
-
         //- Construct from dictionary
-        uniformSet
+        pointsSet
         (
             const word& name,
             const polyMesh& mesh,
@@ -145,7 +138,7 @@ public:
 
 
     //- Destructor
-    virtual ~uniformSet();
+    virtual ~pointsSet();
 };
 
 
diff --git a/src/sampling/sampledSet/polyLine/polyLineSet.C b/src/sampling/sampledSet/polyLine/polyLineSet.C
deleted file mode 100644
index 843ffced4b..0000000000
--- a/src/sampling/sampledSet/polyLine/polyLineSet.C
+++ /dev/null
@@ -1,387 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2018 OpenFOAM Foundation
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-\*---------------------------------------------------------------------------*/
-
-#include "polyLineSet.H"
-#include "meshSearch.H"
-#include "DynamicList.H"
-#include "polyMesh.H"
-
-#include "addToRunTimeSelectionTable.H"
-
-// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
-
-namespace Foam
-{
-    defineTypeNameAndDebug(polyLineSet, 0);
-    addToRunTimeSelectionTable(sampledSet, polyLineSet, word);
-
-    const scalar polyLineSet::tol = 1e-6;
-}
-
-
-// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
-
-bool Foam::polyLineSet::trackToBoundary
-(
-    passiveParticleCloud& particleCloud,
-    passiveParticle& singleParticle,
-    label& sampleI,
-    DynamicList<point>& samplingPts,
-    DynamicList<label>& samplingCells,
-    DynamicList<label>& samplingFaces,
-    DynamicList<scalar>& samplingCurveDist
-) const
-{
-    while (true)
-    {
-        // Local geometry info
-        const vector offset = sampleCoords_[sampleI+1] - sampleCoords_[sampleI];
-        const scalar smallDist = mag(tol*offset);
-
-        singleParticle.track(offset, 0);
-        const point trackPt = singleParticle.position();
-
-        if (singleParticle.onBoundaryFace())
-        {
-            // Info<< "trackToBoundary : reached boundary"
-            //    << "  trackPt:" << trackPt << endl;
-            if
-            (
-                mag(trackPt - sampleCoords_[sampleI+1])
-              < smallDist
-            )
-            {
-                // Reached samplePt on boundary
-                // Info<< "trackToBoundary : boundary. also sampling."
-                //    << "  trackPt:" << trackPt << " sampleI+1:" << sampleI+1
-                //    << endl;
-                samplingPts.append(trackPt);
-                samplingCells.append(singleParticle.cell());
-                samplingFaces.append(singleParticle.face());
-
-                // trackPt is at sampleI+1
-                samplingCurveDist.append(1.0*(sampleI+1));
-            }
-            return true;
-        }
-
-        // Reached samplePt in cell
-        samplingPts.append(trackPt);
-        samplingCells.append(singleParticle.cell());
-        samplingFaces.append(-1);
-
-        // Convert trackPt to fraction in between sampleI and sampleI+1
-        scalar dist =
-            mag(trackPt - sampleCoords_[sampleI])
-          / mag(sampleCoords_[sampleI+1] - sampleCoords_[sampleI]);
-        samplingCurveDist.append(sampleI + dist);
-
-        // go to next samplePt
-        sampleI++;
-
-        if (sampleI == sampleCoords_.size() - 1)
-        {
-            // no more samples.
-            // Info<< "trackToBoundary : Reached end : sampleI now:" << sampleI
-            //    << endl;
-            return false;
-        }
-    }
-}
-
-
-void Foam::polyLineSet::calcSamples
-(
-    DynamicList<point>& samplingPts,
-    DynamicList<label>& samplingCells,
-    DynamicList<label>& samplingFaces,
-    DynamicList<label>& samplingSegments,
-    DynamicList<scalar>& samplingCurveDist
-) const
-{
-    // Check sampling points
-    if (sampleCoords_.size() < 2)
-    {
-        FatalErrorInFunction
-            << "Incorrect sample specification. Too few points:"
-            << sampleCoords_ << exit(FatalError);
-    }
-    point oldPoint = sampleCoords_[0];
-    for (label sampleI = 1; sampleI < sampleCoords_.size(); sampleI++)
-    {
-        if (mag(sampleCoords_[sampleI] - oldPoint) < small)
-        {
-            FatalErrorInFunction
-                << "Incorrect sample specification."
-                << " Point " << sampleCoords_[sampleI-1]
-                << " at position " << sampleI-1
-                << " and point " << sampleCoords_[sampleI]
-                << " at position " << sampleI
-                << " are too close" << exit(FatalError);
-        }
-        oldPoint = sampleCoords_[sampleI];
-    }
-
-    // Force calculation of cloud addressing on all processors
-    const bool oldMoving = const_cast<polyMesh&>(mesh()).moving(false);
-    passiveParticleCloud particleCloud(mesh());
-
-    // current segment number
-    label segmentI = 0;
-
-    // starting index of current segment in samplePts
-    label startSegmentI = 0;
-
-    label sampleI = 0;
-
-    point lastSample(great, great, great);
-    while (true)
-    {
-        // Get boundary intersection
-        point trackPt;
-        label trackCelli = -1;
-        label trackFacei = -1;
-
-        do
-        {
-            const vector offset =
-                sampleCoords_[sampleI+1] - sampleCoords_[sampleI];
-            const scalar smallDist = mag(tol*offset);
-
-
-            // Get all boundary intersections
-            List<pointIndexHit> bHits = searchEngine().intersections
-            (
-                sampleCoords_[sampleI],
-                sampleCoords_[sampleI+1]
-            );
-
-            point bPoint(great, great, great);
-            label bFacei = -1;
-
-            if (bHits.size())
-            {
-                bPoint = bHits[0].hitPoint();
-                bFacei = bHits[0].index();
-            }
-
-            // Get tracking point
-
-            bool isSample =
-                getTrackingPoint
-                (
-                    sampleCoords_[sampleI],
-                    bPoint,
-                    bFacei,
-                    smallDist,
-
-                    trackPt,
-                    trackCelli,
-                    trackFacei
-                );
-
-            if (isSample && (mag(lastSample - trackPt) > smallDist))
-            {
-                // Info<< "calcSamples : getTrackingPoint returned valid sample"
-                //     << "  trackPt:" << trackPt
-                //     << "  trackFacei:" << trackFacei
-                //     << "  trackCelli:" << trackCelli
-                //     << "  sampleI:" << sampleI
-                //     << "  dist:" << dist
-                //     << endl;
-
-                samplingPts.append(trackPt);
-                samplingCells.append(trackCelli);
-                samplingFaces.append(trackFacei);
-
-                // Convert sampling position to unique curve parameter. Get
-                // fraction of distance between sampleI and sampleI+1.
-                scalar dist =
-                    mag(trackPt - sampleCoords_[sampleI])
-                  / mag(sampleCoords_[sampleI+1] - sampleCoords_[sampleI]);
-                samplingCurveDist.append(sampleI + dist);
-
-                lastSample = trackPt;
-            }
-
-            if (trackCelli == -1)
-            {
-                // No intersection found. Go to next point
-                sampleI++;
-            }
-        } while ((trackCelli == -1) && (sampleI < sampleCoords_.size() - 1));
-
-        if (sampleI == sampleCoords_.size() - 1)
-        {
-            // Info<< "calcSamples : Reached end of samples: "
-            //    << "  sampleI now:" << sampleI
-            //    << endl;
-            break;
-        }
-
-        //
-        // Segment sampleI .. sampleI+1 intersected by domain
-        //
-
-        // Initialize tracking starting from sampleI
-        passiveParticle singleParticle
-        (
-            mesh(),
-            trackPt,
-            trackCelli
-        );
-
-        bool bReached = trackToBoundary
-        (
-            particleCloud,
-            singleParticle,
-            sampleI,
-            samplingPts,
-            samplingCells,
-            samplingFaces,
-            samplingCurveDist
-        );
-
-        // fill sampleSegments
-        for (label i = samplingPts.size() - 1; i >= startSegmentI; --i)
-        {
-            samplingSegments.append(segmentI);
-        }
-
-        if (!bReached)
-        {
-            // Info<< "calcSamples : Reached end of samples: "
-            //    << "  sampleI now:" << sampleI
-            //    << endl;
-            break;
-        }
-        lastSample = singleParticle.position();
-
-
-        // Find next boundary.
-        sampleI++;
-
-        if (sampleI == sampleCoords_.size() - 1)
-        {
-            // Info<< "calcSamples : Reached end of samples: "
-            //    << "  sampleI now:" << sampleI
-            //    << endl;
-            break;
-        }
-
-        segmentI++;
-
-        startSegmentI = samplingPts.size();
-    }
-
-    const_cast<polyMesh&>(mesh()).moving(oldMoving);
-}
-
-
-void Foam::polyLineSet::genSamples()
-{
-    // Storage for sample points
-    DynamicList<point> samplingPts;
-    DynamicList<label> samplingCells;
-    DynamicList<label> samplingFaces;
-    DynamicList<label> samplingSegments;
-    DynamicList<scalar> samplingCurveDist;
-
-    calcSamples
-    (
-        samplingPts,
-        samplingCells,
-        samplingFaces,
-        samplingSegments,
-        samplingCurveDist
-    );
-
-    samplingPts.shrink();
-    samplingCells.shrink();
-    samplingFaces.shrink();
-    samplingSegments.shrink();
-    samplingCurveDist.shrink();
-
-    setSamples
-    (
-        samplingPts,
-        samplingCells,
-        samplingFaces,
-        samplingSegments,
-        samplingCurveDist
-    );
-}
-
-
-// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
-
-Foam::polyLineSet::polyLineSet
-(
-    const word& name,
-    const polyMesh& mesh,
-    const meshSearch& searchEngine,
-    const word& axis,
-    const List<point>& sampleCoords
-)
-:
-    sampledSet(name, mesh, searchEngine, axis),
-    sampleCoords_(sampleCoords)
-{
-    genSamples();
-
-    if (debug)
-    {
-        write(Info);
-    }
-}
-
-
-Foam::polyLineSet::polyLineSet
-(
-    const word& name,
-    const polyMesh& mesh,
-    const meshSearch& searchEngine,
-    const dictionary& dict
-)
-:
-    sampledSet(name, mesh, searchEngine, dict),
-    sampleCoords_(dict.lookup("points"))
-{
-    genSamples();
-
-    if (debug)
-    {
-        write(Info);
-    }
-}
-
-
-// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
-
-Foam::polyLineSet::~polyLineSet()
-{}
-
-
-// ************************************************************************* //
diff --git a/src/sampling/sampledSet/sampledSet/sampledSet.C b/src/sampling/sampledSet/sampledSet/sampledSet.C
index 27da9d6fe7..c9fb2cbc12 100644
--- a/src/sampling/sampledSet/sampledSet/sampledSet.C
+++ b/src/sampling/sampledSet/sampledSet/sampledSet.C
@@ -25,10 +25,8 @@ License
 
 #include "sampledSet.H"
 #include "polyMesh.H"
-#include "primitiveMesh.H"
 #include "meshSearch.H"
 #include "writer.H"
-#include "particle.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
@@ -41,322 +39,6 @@ namespace Foam
 
 // * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
 
-Foam::label Foam::sampledSet::getBoundaryCell(const label facei) const
-{
-    return mesh().faceOwner()[facei];
-}
-
-
-Foam::label Foam::sampledSet::getNeighbourCell(const label facei) const
-{
-    if (facei >= mesh().nInternalFaces())
-    {
-        return mesh().faceOwner()[facei];
-    }
-    else
-    {
-        return mesh().faceNeighbour()[facei];
-    }
-}
-
-
-Foam::label Foam::sampledSet::pointInCell
-(
-    const point& p,
-    const label samplei
-) const
-{
-    // Collect the face owner and neighbour cells of the sample into an array
-    // for convenience
-    label cells[4] =
-    {
-        mesh().faceOwner()[faces_[samplei]],
-        getNeighbourCell(faces_[samplei]),
-        mesh().faceOwner()[faces_[samplei+1]],
-        getNeighbourCell(faces_[samplei+1])
-    };
-
-    // Find the sampled cell by checking the owners and neighbours of the
-    // sampled faces
-    label cellm =
-        (cells[0] == cells[2] || cells[0] == cells[3]) ? cells[0]
-      : (cells[1] == cells[2] || cells[1] == cells[3]) ? cells[1]
-      : -1;
-
-    if (cellm != -1)
-    {
-        // If found the sampled cell check the point is in the cell
-        // otherwise ignore
-        if (!mesh().pointInCell(p, cellm, searchEngine_.decompMode()))
-        {
-           cellm = -1;
-
-            if (debug)
-            {
-                WarningInFunction
-                    << "Could not find mid-point " << p
-                    << " cell " << cellm << endl;
-            }
-        }
-    }
-    else
-    {
-        // If the sample does not pass through a single cell check if the point
-        // is in any of the owners or neighbours otherwise ignore
-        for (label i=0; i<4; i++)
-        {
-            if (mesh().pointInCell(p, cells[i], searchEngine_.decompMode()))
-            {
-                return cells[i];
-            }
-        }
-
-        if (debug)
-        {
-            WarningInFunction
-                << "Could not find cell for mid-point" << nl
-                << "  samplei: " << samplei
-                << "  pts[samplei]: " << operator[](samplei)
-                << "  face[samplei]: " << faces_[samplei]
-                << "  pts[samplei+1]: " << operator[](samplei+1)
-                << "  face[samplei+1]: " << faces_[samplei+1]
-                << "  cellio: " << cells[0]
-                << "  cellin: " << cells[1]
-                << "  celljo: " << cells[2]
-                << "  celljn: " << cells[3]
-                << endl;
-        }
-    }
-
-    return cellm;
-}
-
-
-Foam::scalar Foam::sampledSet::calcSign
-(
-    const label facei,
-    const point& sample
-) const
-{
-    vector vec = sample - mesh().faceCentres()[facei];
-
-    scalar magVec = mag(vec);
-
-    if (magVec < vSmall)
-    {
-        // Sample on face centre. Regard as inside
-        return -1;
-    }
-
-    vec /= magVec;
-
-    vector n = mesh().faceAreas()[facei];
-
-    n /= mag(n) + vSmall;
-
-    return n & vec;
-}
-
-
-Foam::label Foam::sampledSet::findNearFace
-(
-    const label celli,
-    const point& sample,
-    const scalar smallDist
-) const
-{
-    const cell& myFaces = mesh().cells()[celli];
-
-    forAll(myFaces, myFacei)
-    {
-        const face& f = mesh().faces()[myFaces[myFacei]];
-
-        pointHit inter = f.nearestPoint(sample, mesh().points());
-
-        scalar dist;
-
-        if (inter.hit())
-        {
-            dist = mag(inter.hitPoint() - sample);
-        }
-        else
-        {
-            dist = mag(inter.missPoint() - sample);
-        }
-
-        if (dist < smallDist)
-        {
-            return myFaces[myFacei];
-        }
-    }
-    return -1;
-}
-
-
-Foam::point Foam::sampledSet::pushIn
-(
-    const point& facePt,
-    const label facei
-) const
-{
-    label celli = mesh().faceOwner()[facei];
-    const point& cC = mesh().cellCentres()[celli];
-
-    point newPosition = facePt;
-
-    // Taken from particle::initCellFacePt()
-    label tetFacei;
-    label tetPtI;
-    mesh().findTetFacePt(celli, facePt, tetFacei, tetPtI);
-
-    // This is the tolerance that was defined as a static constant of the
-    // particle class. It is no longer used by particle, following the switch to
-    // barycentric tracking. The only place in which the tolerance is now used
-    // is here. I'm not sure what the purpose of this code is, but it probably
-    // wants removing. It is doing tet-searches for a particle position. This
-    // should almost certainly be left to the particle class.
-    const scalar trackingCorrectionTol = 1e-5;
-
-    if (tetFacei == -1 || tetPtI == -1)
-    {
-        newPosition = facePt;
-
-        label trap(1.0/trackingCorrectionTol + 1);
-
-        label iterNo = 0;
-
-        do
-        {
-            newPosition += trackingCorrectionTol*(cC - facePt);
-
-            mesh().findTetFacePt
-            (
-                celli,
-                newPosition,
-                tetFacei,
-                tetPtI
-            );
-
-            iterNo++;
-
-        } while (tetFacei < 0  && iterNo <= trap);
-    }
-
-    if (tetFacei == -1)
-    {
-        FatalErrorInFunction
-            << "After pushing " << facePt << " to " << newPosition
-            << " it is still outside face " << facei
-            << " at " << mesh().faceCentres()[facei]
-            << " of cell " << celli
-            << " at " << cC << endl
-            << "Please change your starting point"
-            << abort(FatalError);
-    }
-
-    return newPosition;
-}
-
-
-bool Foam::sampledSet::getTrackingPoint
-(
-    const point& samplePt,
-    const point& bPoint,
-    const label bFacei,
-    const scalar smallDist,
-
-    point& trackPt,
-    label& trackCelli,
-    label& trackFacei
-) const
-{
-    bool isGoodSample = false;
-
-    if (bFacei == -1)
-    {
-        // No boundary intersection. Try and find cell samplePt is in
-        trackCelli = mesh().findCell(samplePt, searchEngine_.decompMode());
-
-        if
-        (
-            (trackCelli == -1)
-        || !mesh().pointInCell
-            (
-                samplePt,
-                trackCelli,
-                searchEngine_.decompMode()
-            )
-        )
-        {
-            // Line samplePt - end_ does not intersect domain at all.
-            // (or is along edge)
-
-            trackCelli = -1;
-            trackFacei = -1;
-
-            isGoodSample = false;
-        }
-        else
-        {
-            // Start is inside. Use it as tracking point
-
-            trackPt = samplePt;
-            trackFacei = -1;
-
-            isGoodSample = true;
-        }
-    }
-    else if (mag(samplePt - bPoint) < smallDist)
-    {
-        // samplePt close to bPoint. Snap to it
-        trackPt = pushIn(bPoint, bFacei);
-        trackFacei = bFacei;
-        trackCelli = getBoundaryCell(trackFacei);
-
-        isGoodSample = true;
-    }
-    else
-    {
-        scalar sign = calcSign(bFacei, samplePt);
-
-        if (sign < 0)
-        {
-            // samplePt inside or marginally outside.
-            trackPt = samplePt;
-            trackFacei = -1;
-            trackCelli = mesh().findCell(trackPt, searchEngine_.decompMode());
-
-            isGoodSample = true;
-        }
-        else
-        {
-            // samplePt outside. use bPoint
-            trackPt = pushIn(bPoint, bFacei);
-            trackFacei = bFacei;
-            trackCelli = getBoundaryCell(trackFacei);
-
-            isGoodSample = false;
-        }
-    }
-
-    if (debug)
-    {
-        InfoInFunction
-            << " samplePt:" << samplePt
-            << " bPoint:" << bPoint
-            << " bFacei:" << bFacei
-            << endl << "   Calculated first tracking point :"
-            << " trackPt:" << trackPt
-            << " trackCelli:" << trackCelli
-            << " trackFacei:" << trackFacei
-            << " isGoodSample:" << isGoodSample
-            << endl;
-    }
-
-    return isGoodSample;
-}
-
-
 void Foam::sampledSet::setSamples
 (
     const List<point>& samplingPts,
diff --git a/src/sampling/sampledSet/sampledSet/sampledSet.H b/src/sampling/sampledSet/sampledSet/sampledSet.H
index 59441808d6..119eb459a4 100644
--- a/src/sampling/sampledSet/sampledSet/sampledSet.H
+++ b/src/sampling/sampledSet/sampledSet/sampledSet.H
@@ -27,8 +27,8 @@ Class
 Description
     Holds list of sampling points which is filled at construction time.
     Various implementations of this base class to e.g. get sampling points
-    at uniform distance along a line (uniformSet) or directly specified
-    (cloudSet)
+    at uniform distance along a line (lineUniformSet) or directly specified
+    (pointsSet)
 
     Each 'sampledSet' has a name and a specifier of how the axis should be
     write (x/y/z component or all 3 components)
@@ -86,52 +86,6 @@ protected:
 
     // Protected Member Functions
 
-        //- Returns cell next to boundary face
-        label getBoundaryCell(const label) const;
-
-        //- Returns the neighbour cell or the owner if face in on the boundary
-        label getNeighbourCell(const label) const;
-
-        //- Return the cell in which the point on the sample line
-        //  resides if found otherwise return -1
-        label pointInCell(const point& p, const label samplei) const;
-
-        //- Calculates inproduct of face normal and vector sample-face centre
-        //  <0 if sample inside.
-        scalar calcSign(const label facei, const point& sample) const;
-
-        //- Returns face label (or -1) of face which is close to sample
-        label findNearFace
-        (
-            const label celli,
-            const point& sample,
-            const scalar smallDist
-        ) const;
-
-        //- Moves sample in direction of -n to it is 'inside' of facei
-        point pushIn
-        (
-            const point& sample,
-            const label facei
-        ) const;
-
-        //- Calculates start of tracking given samplePt and first boundary
-        //  intersection
-        //  (bPoint, bFacei) (bFacei == -1 if no boundary intersection)
-        //  Returns true if trackPt is valid sampling point. Sets trackPt,
-        //  trackFacei, trackCelli (-1 if no tracking point found)
-        bool getTrackingPoint
-        (
-            const point& samplePt,
-            const point& bPoint,
-            const label bFacei,
-            const scalar smallDist,
-
-            point& trackPt,
-            label& trackCelli,
-            label& trackFacei
-        ) const;
-
         //- Sets sample data
         void setSamples
         (
diff --git a/src/sampling/sampledSet/cloud/cloudSet.C b/src/sampling/sampledSet/sphereRandom/sphereRandomSet.C
similarity index 72%
rename from src/sampling/sampledSet/cloud/cloudSet.C
rename to src/sampling/sampledSet/sphereRandom/sphereRandomSet.C
index 43d7f11fe7..ce5696b1cf 100644
--- a/src/sampling/sampledSet/cloud/cloudSet.C
+++ b/src/sampling/sampledSet/sphereRandom/sphereRandomSet.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2018 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -23,26 +23,28 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-#include "cloudSet.H"
+#include "sphereRandomSet.H"
 #include "sampledSet.H"
 #include "meshSearch.H"
 #include "DynamicList.H"
 #include "polyMesh.H"
 #include "addToRunTimeSelectionTable.H"
 #include "word.H"
+#include "mathematicalConstants.H"
+#include "Random.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
 namespace Foam
 {
-    defineTypeNameAndDebug(cloudSet, 0);
-    addToRunTimeSelectionTable(sampledSet, cloudSet, word);
+    defineTypeNameAndDebug(sphereRandomSet, 0);
+    addToRunTimeSelectionTable(sampledSet, sphereRandomSet, word);
 }
 
 
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 
-void Foam::cloudSet::calcSamples
+void Foam::sphereRandomSet::calcSamples
 (
     DynamicList<point>& samplingPts,
     DynamicList<label>& samplingCells,
@@ -51,25 +53,35 @@ void Foam::cloudSet::calcSamples
     DynamicList<scalar>& samplingCurveDist
 ) const
 {
-    const meshSearch& queryMesh = searchEngine();
+    Random rndGen(261782);
 
-    forAll(sampleCoords_, sampleI)
+    for (label i = 0; i < nPoints_; ++ i)
     {
-        label celli = queryMesh.findCell(sampleCoords_[sampleI]);
+        // Request all random numbers simultaneously on all processors so that
+        // the generator state stays consistent
+
+        vector dpt(vector::uniform(radius_));
+        while (magSqr(dpt) > sqr(radius_))
+        {
+            dpt = 2*radius_*(rndGen.sample01<vector>() - vector::uniform(0.5));
+        }
+
+        const point pt = centre_ + dpt;
+        const label celli = searchEngine().findCell(pt);
 
         if (celli != -1)
         {
-            samplingPts.append(sampleCoords_[sampleI]);
+            samplingPts.append(pt);
             samplingCells.append(celli);
             samplingFaces.append(-1);
             samplingSegments.append(0);
-            samplingCurveDist.append(1.0 * sampleI);
+            samplingCurveDist.append(scalar(i));
         }
     }
 }
 
 
-void Foam::cloudSet::genSamples()
+void Foam::sphereRandomSet::genSamples()
 {
     // Storage for sample points
     DynamicList<point> samplingPts;
@@ -106,28 +118,7 @@ void Foam::cloudSet::genSamples()
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
-Foam::cloudSet::cloudSet
-(
-    const word& name,
-    const polyMesh& mesh,
-    const meshSearch& searchEngine,
-    const word& axis,
-    const List<point>& sampleCoords
-)
-:
-    sampledSet(name, mesh, searchEngine, axis),
-    sampleCoords_(sampleCoords)
-{
-    genSamples();
-
-    if (debug)
-    {
-        write(Info);
-    }
-}
-
-
-Foam::cloudSet::cloudSet
+Foam::sphereRandomSet::sphereRandomSet
 (
     const word& name,
     const polyMesh& mesh,
@@ -136,7 +127,9 @@ Foam::cloudSet::cloudSet
 )
 :
     sampledSet(name, mesh, searchEngine, dict),
-    sampleCoords_(dict.lookup("points"))
+    centre_(dict.lookup("centre")),
+    radius_(readScalar(dict.lookup("radius"))),
+    nPoints_(readLabel(dict.lookup("nPoints")))
 {
     genSamples();
 
@@ -149,7 +142,7 @@ Foam::cloudSet::cloudSet
 
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 
-Foam::cloudSet::~cloudSet()
+Foam::sphereRandomSet::~sphereRandomSet()
 {}
 
 
diff --git a/src/sampling/sampledSet/cloud/cloudSet.H b/src/sampling/sampledSet/sphereRandom/sphereRandomSet.H
similarity index 67%
rename from src/sampling/sampledSet/cloud/cloudSet.H
rename to src/sampling/sampledSet/sphereRandom/sphereRandomSet.H
index c312bff44c..820f660cd7 100644
--- a/src/sampling/sampledSet/cloud/cloudSet.H
+++ b/src/sampling/sampledSet/sphereRandom/sphereRandomSet.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2018 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -22,17 +22,38 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Class
-    Foam::cloudSet
+    Foam::sphereRandomSet
 
 Description
+    Random samples within a sphere
+
+Usage
+    \table
+        Property    | Description                            | Req'd? | Default
+        centre      | Centre of the sphere                   | yes    |
+        radius      | Radius of the sphere                   | yes    |
+        nPoints     | The number of points                   | yes    |
+        axis        | The coordinate axis that is written    | yes    |
+    \endtable
+
+    Example specification:
+    \verbatim
+    {
+        type        sphereRandom;
+        centre      (0.95 0 0.25);
+        radius      0.25;
+        nPoints     200;
+        axis        x;
+    }
+    \endverbatim
 
 SourceFiles
-    cloudSet.C
+    sphereRandomSet.C
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef cloudSet_H
-#define cloudSet_H
+#ifndef sphereRandomSet_H
+#define sphereRandomSet_H
 
 #include "sampledSet.H"
 #include "DynamicList.H"
@@ -42,27 +63,29 @@ SourceFiles
 namespace Foam
 {
 
-// Forward declaration of classes
-class passiveParticle;
-template<class Type> class particle;
-
 /*---------------------------------------------------------------------------*\
-                           Class cloudSet Declaration
+                          Class sphereRandomSet Declaration
 \*---------------------------------------------------------------------------*/
 
-class cloudSet
+class sphereRandomSet
 :
     public sampledSet
 {
     // Private data
 
-        //- Sampling points
-        List<point> sampleCoords_;
+        //- Centre point
+        const point centre_;
+
+        //- Radius
+        const scalar radius_;
+
+        //- Number of points
+        const label nPoints_;
 
 
     // Private Member Functions
 
-        //- Samples all points in sampleCoords.
+        //- Samples all points in sampleCoords
         void calcSamples
         (
             DynamicList<point>& samplingPts,
@@ -79,23 +102,13 @@ class cloudSet
 public:
 
     //- Runtime type information
-    TypeName("cloud");
+    TypeName("sphereRandom");
 
 
     // Constructors
 
-        //- Construct from components
-        cloudSet
-        (
-            const word& name,
-            const polyMesh& mesh,
-            const meshSearch& searchEngine,
-            const word& axis,
-            const List<point>& sampleCoords
-        );
-
         //- Construct from dictionary
-        cloudSet
+        sphereRandomSet
         (
             const word& name,
             const polyMesh& mesh,
@@ -104,8 +117,9 @@ public:
         );
 
 
-    //- Destructor
-    virtual ~cloudSet();
+    // Destructor
+
+        virtual ~sphereRandomSet();
 };
 
 
diff --git a/src/sampling/sampledSet/triSurfaceMeshPointSet/triSurfaceMeshPointSet.C b/src/sampling/sampledSet/triSurfaceMesh/triSurfaceMeshSet.C
similarity index 67%
rename from src/sampling/sampledSet/triSurfaceMeshPointSet/triSurfaceMeshPointSet.C
rename to src/sampling/sampledSet/triSurfaceMesh/triSurfaceMeshSet.C
index fe6643cd9e..5881c161e8 100644
--- a/src/sampling/sampledSet/triSurfaceMeshPointSet/triSurfaceMeshPointSet.C
+++ b/src/sampling/sampledSet/triSurfaceMesh/triSurfaceMeshSet.C
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2016 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2018 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -23,7 +23,7 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-#include "triSurfaceMeshPointSet.H"
+#include "triSurfaceMeshSet.H"
 #include "meshSearch.H"
 #include "DynamicList.H"
 #include "polyMesh.H"
@@ -35,14 +35,14 @@ License
 
 namespace Foam
 {
-    defineTypeNameAndDebug(triSurfaceMeshPointSet, 0);
-    addToRunTimeSelectionTable(sampledSet, triSurfaceMeshPointSet, word);
+    defineTypeNameAndDebug(triSurfaceMeshSet, 0);
+    addToRunTimeSelectionTable(sampledSet, triSurfaceMeshSet, word);
 }
 
 
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 
-void Foam::triSurfaceMeshPointSet::calcSamples
+void Foam::triSurfaceMeshSet::calcSamples
 (
     DynamicList<point>& samplingPts,
     DynamicList<label>& samplingCells,
@@ -51,23 +51,24 @@ void Foam::triSurfaceMeshPointSet::calcSamples
     DynamicList<scalar>& samplingCurveDist
 ) const
 {
-    forAll(sampleCoords_, sampleI)
+    forAll(points_, i)
     {
-        label celli = searchEngine().findCell(sampleCoords_[sampleI]);
+        const point& pt = points_[i];
+        const label celli = searchEngine().findCell(pt);
 
         if (celli != -1)
         {
-            samplingPts.append(sampleCoords_[sampleI]);
+            samplingPts.append(pt);
             samplingCells.append(celli);
             samplingFaces.append(-1);
             samplingSegments.append(0);
-            samplingCurveDist.append(1.0 * sampleI);
+            samplingCurveDist.append(scalar(i));
         }
     }
 }
 
 
-void Foam::triSurfaceMeshPointSet::genSamples()
+void Foam::triSurfaceMeshSet::genSamples()
 {
     // Storage for sample points
     DynamicList<point> samplingPts;
@@ -104,7 +105,7 @@ void Foam::triSurfaceMeshPointSet::genSamples()
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
-Foam::triSurfaceMeshPointSet::triSurfaceMeshPointSet
+Foam::triSurfaceMeshSet::triSurfaceMeshSet
 (
     const word& name,
     const polyMesh& mesh,
@@ -113,35 +114,26 @@ Foam::triSurfaceMeshPointSet::triSurfaceMeshPointSet
 )
 :
     sampledSet(name, mesh, searchEngine, dict),
-    surface_(dict.lookup("surface"))
-{
-    // Load surface.
-    if (mesh.time().foundObject<triSurfaceMesh>(surface_))
-    {
-        // Note: should use localPoints() instead of points() but assume
-        // trisurface is compact.
-        sampleCoords_ = mesh.time().lookupObject<triSurfaceMesh>
-        (
-            surface_
-        ).points();
-    }
-    else
-    {
-        sampleCoords_ = triSurfaceMesh
+    surface_(dict.lookup("surface")),
+    points_
+    (
+        mesh.time().foundObject<triSurfaceMesh>(surface_)
+      ? mesh.time().lookupObject<triSurfaceMesh>(surface_).points()
+      : triSurfaceMesh
         (
             IOobject
             (
                 surface_,
-                mesh.time().constant(),     // instance
-                "triSurface",               // local
+                mesh.time().constant(),
+                "triSurface",
                 mesh.time(),
                 IOobject::MUST_READ,
                 IOobject::NO_WRITE,
                 false
             )
-        ).points();
-    }
-
+        ).points()
+    )
+{
     genSamples();
 
     if (debug)
@@ -153,25 +145,8 @@ Foam::triSurfaceMeshPointSet::triSurfaceMeshPointSet
 
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 
-Foam::triSurfaceMeshPointSet::~triSurfaceMeshPointSet()
+Foam::triSurfaceMeshSet::~triSurfaceMeshSet()
 {}
 
 
-// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
-
-Foam::point Foam::triSurfaceMeshPointSet::getRefPoint(const List<point>& pts)
- const
-{
-    if (pts.size())
-    {
-        // Use first samplePt as starting point
-        return pts[0];
-    }
-    else
-    {
-        return Zero;
-    }
-}
-
-
 // ************************************************************************* //
diff --git a/src/sampling/sampledSet/triSurfaceMeshPointSet/triSurfaceMeshPointSet.H b/src/sampling/sampledSet/triSurfaceMesh/triSurfaceMeshSet.H
similarity index 74%
rename from src/sampling/sampledSet/triSurfaceMeshPointSet/triSurfaceMeshPointSet.H
rename to src/sampling/sampledSet/triSurfaceMesh/triSurfaceMeshSet.H
index 92ef83ebf8..0d6fbe536e 100644
--- a/src/sampling/sampledSet/triSurfaceMeshPointSet/triSurfaceMeshPointSet.H
+++ b/src/sampling/sampledSet/triSurfaceMesh/triSurfaceMeshSet.H
@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2018 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -22,18 +22,35 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Class
-    Foam::triSurfaceMeshPointSet
+    Foam::triSurfaceMeshSet
 
 Description
-    sampleSet from all points of a triSurfaceMesh.
+    Samples from all the points of a triSurfaceMesh. Surface files are read
+    from constant/triSurface.
+
+Usage
+    \table
+        Property    | Description                            | Req'd? | Default
+        surface     | The surface file name                  | yes    |
+        axis        | The coordinate axis that is written    | yes    |
+    \endtable
+
+    Example specification:
+    \verbatim
+    {
+        type        triSurfaceMesh;
+        surface     "surface.stl";
+        axis        x;
+    }
+    \endverbatim
 
 SourceFiles
-    triSurfaceMeshPointSet.C
+    triSurfaceMeshSet.C
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef triSurfaceMeshPointSet_H
-#define triSurfaceMeshPointSet_H
+#ifndef triSurfaceMeshSet_H
+#define triSurfaceMeshSet_H
 
 #include "sampledSet.H"
 
@@ -42,13 +59,11 @@ SourceFiles
 namespace Foam
 {
 
-// Forward declaration of classes
-
 /*---------------------------------------------------------------------------*\
-                           Class triSurfaceMeshPointSet Declaration
+                           Class triSurfaceMeshSet Declaration
 \*---------------------------------------------------------------------------*/
 
-class triSurfaceMeshPointSet
+class triSurfaceMeshSet
 :
     public sampledSet
 {
@@ -58,7 +73,7 @@ class triSurfaceMeshPointSet
         const word surface_;
 
         //- Sampling points
-        List<point> sampleCoords_;
+        const List<point> points_;
 
 
     // Private Member Functions
@@ -80,13 +95,13 @@ class triSurfaceMeshPointSet
 public:
 
     //- Runtime type information
-    TypeName("triSurfaceMeshPointSet");
+    TypeName("triSurfaceMesh");
 
 
     // Constructors
 
         //- Construct from dictionary
-        triSurfaceMeshPointSet
+        triSurfaceMeshSet
         (
             const word& name,
             const polyMesh& mesh,
@@ -96,13 +111,7 @@ public:
 
 
     //- Destructor
-    virtual ~triSurfaceMeshPointSet();
-
-
-    // Member Functions
-
-        //- Get reference point
-        virtual point getRefPoint(const List<point>&) const;
+    virtual ~triSurfaceMeshSet();
 };
 
 
diff --git a/src/sampling/sampledSet/uniform/uniformSet.C b/src/sampling/sampledSet/uniform/uniformSet.C
deleted file mode 100644
index 201c8fe05d..0000000000
--- a/src/sampling/sampledSet/uniform/uniformSet.C
+++ /dev/null
@@ -1,460 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2018 OpenFOAM Foundation
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-\*---------------------------------------------------------------------------*/
-
-#include "uniformSet.H"
-#include "meshSearch.H"
-#include "DynamicList.H"
-#include "polyMesh.H"
-
-#include "addToRunTimeSelectionTable.H"
-
-// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
-
-namespace Foam
-{
-    defineTypeNameAndDebug(uniformSet, 0);
-    addToRunTimeSelectionTable(sampledSet, uniformSet, word);
-
-    const scalar uniformSet::tol = 1e-3;
-}
-
-
-// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
-
-bool Foam::uniformSet::nextSample
-(
-    const point& currentPt,
-    const vector& offset,
-    const scalar smallDist,
-    point& samplePt,
-    label& sampleI
-) const
-{
-    bool pointFound = false;
-
-    const vector normOffset = offset/mag(offset);
-
-    samplePt += offset;
-    sampleI++;
-
-    for (; sampleI < nPoints_; sampleI++)
-    {
-        scalar s = (samplePt - currentPt) & normOffset;
-
-        if (s > -smallDist)
-        {
-            // samplePt is close to or beyond currentPt -> use it
-            pointFound = true;
-
-            break;
-        }
-        samplePt += offset;
-    }
-
-    return pointFound;
-}
-
-
-bool Foam::uniformSet::trackToBoundary
-(
-    passiveParticleCloud& particleCloud,
-    passiveParticle& singleParticle,
-    point& samplePt,
-    label& sampleI,
-    DynamicList<point>& samplingPts,
-    DynamicList<label>& samplingCells,
-    DynamicList<label>& samplingFaces,
-    DynamicList<scalar>& samplingCurveDist
-) const
-{
-    // distance vector between sampling points
-    const vector offset = (end_ - start_)/(nPoints_ - 1);
-    const vector smallVec = tol*offset;
-    const scalar smallDist = mag(smallVec);
-
-    point trackPt = singleParticle.position();
-
-    while(true)
-    {
-        // Find next samplePt on/after trackPt. Update samplePt, sampleI
-        if (!nextSample(trackPt, offset, smallDist, samplePt, sampleI))
-        {
-            // no more samples.
-            if (debug)
-            {
-                Pout<< "trackToBoundary : Reached end : samplePt now:"
-                    << samplePt << "  sampleI now:" << sampleI << endl;
-            }
-            return false;
-        }
-
-        if (mag(samplePt - trackPt) < smallDist)
-        {
-            // trackPt corresponds with samplePt. Store and use next samplePt
-            if (debug)
-            {
-                Pout<< "trackToBoundary : samplePt corresponds to trackPt : "
-                    << "  trackPt:" << trackPt << "  samplePt:" << samplePt
-                    << endl;
-            }
-
-            samplingPts.append(trackPt);
-            samplingCells.append(singleParticle.cell());
-            samplingFaces.append(-1);
-            samplingCurveDist.append(mag(trackPt - start_));
-
-            // go to next samplePt
-            if (!nextSample(trackPt, offset, smallDist, samplePt, sampleI))
-            {
-                // no more samples.
-                if (debug)
-                {
-                    Pout<< "trackToBoundary : Reached end : "
-                        << "  samplePt now:" << samplePt
-                        << "  sampleI now:" << sampleI
-                        << endl;
-                }
-
-                return false;
-            }
-        }
-
-
-        if (debug)
-        {
-            Pout<< "Searching along trajectory from "
-                << "  trackPt:" << trackPt
-                << "  trackCelli:" << singleParticle.cell()
-                << "  to:" << samplePt << endl;
-        }
-
-        singleParticle.track(samplePt - trackPt, 0);
-        trackPt = singleParticle.position();
-
-        if (singleParticle.onBoundaryFace())
-        {
-            // Pout<< "trackToBoundary : reached boundary" << endl;
-            if (mag(trackPt - samplePt) < smallDist)
-            {
-                // Pout<< "trackToBoundary : boundary is also sampling point"
-                //    << endl;
-                // Reached samplePt on boundary
-                samplingPts.append(trackPt);
-                samplingCells.append(singleParticle.cell());
-                samplingFaces.append(singleParticle.face());
-                samplingCurveDist.append(mag(trackPt - start_));
-            }
-
-            return true;
-        }
-
-        // Pout<< "trackToBoundary : reached internal sampling point" << endl;
-        // Reached samplePt in cell or on internal face
-        samplingPts.append(trackPt);
-        samplingCells.append(singleParticle.cell());
-        samplingFaces.append(-1);
-        samplingCurveDist.append(mag(trackPt - start_));
-
-        // go to next samplePt
-    }
-}
-
-
-void Foam::uniformSet::calcSamples
-(
-    DynamicList<point>& samplingPts,
-    DynamicList<label>& samplingCells,
-    DynamicList<label>& samplingFaces,
-    DynamicList<label>& samplingSegments,
-    DynamicList<scalar>& samplingCurveDist
-) const
-{
-    // distance vector between sampling points
-    if ((nPoints_ < 2) || (mag(end_ - start_) < small))
-    {
-        FatalErrorInFunction
-            << "Incorrect sample specification. Either too few points or"
-            << " start equals end point." << endl
-            << "nPoints:" << nPoints_
-            << "  start:" << start_
-            << "  end:" << end_
-            << exit(FatalError);
-    }
-
-    const vector offset = (end_ - start_)/(nPoints_ - 1);
-    const vector normOffset = offset/mag(offset);
-    const vector smallVec = tol*offset;
-    const scalar smallDist = mag(smallVec);
-
-    // Force calculation of cloud addressing on all processors
-    const bool oldMoving = const_cast<polyMesh&>(mesh()).moving(false);
-    passiveParticleCloud particleCloud(mesh());
-
-    // Get all boundary intersections
-    List<pointIndexHit> bHits = searchEngine().intersections
-    (
-        start_ - smallVec,
-        end_ + smallVec
-    );
-
-    point bPoint(great, great, great);
-    label bFacei = -1;
-
-    if (bHits.size())
-    {
-        bPoint = bHits[0].hitPoint();
-        bFacei = bHits[0].index();
-    }
-
-    // Get first tracking point. Use bPoint, bFacei if provided.
-
-    point trackPt;
-    label trackCelli = -1;
-    label trackFacei = -1;
-
-    bool isSample =
-        getTrackingPoint
-        (
-            start_,
-            bPoint,
-            bFacei,
-            smallDist,
-
-            trackPt,
-            trackCelli,
-            trackFacei
-        );
-
-    if (trackCelli == -1)
-    {
-        // Line start_ - end_ does not intersect domain at all.
-        // (or is along edge)
-        // Set points and cell/face labels to empty lists
-
-        const_cast<polyMesh&>(mesh()).moving(oldMoving);
-        return;
-    }
-
-    if (isSample)
-    {
-        samplingPts.append(start_);
-        samplingCells.append(trackCelli);
-        samplingFaces.append(trackFacei);
-        samplingCurveDist.append(0.0);
-    }
-
-    //
-    // Track until hit end of all boundary intersections
-    //
-
-    // current segment number
-    label segmentI = 0;
-
-    // starting index of current segment in samplePts
-    label startSegmentI = 0;
-
-    label sampleI = 0;
-    point samplePt = start_;
-
-    // index in bHits; current boundary intersection
-    label bHitI = 1;
-
-    while(true)
-    {
-        // Initialize tracking starting from trackPt
-        passiveParticle singleParticle(mesh(), trackPt, trackCelli);
-
-        bool reachedBoundary = trackToBoundary
-        (
-            particleCloud,
-            singleParticle,
-            samplePt,
-            sampleI,
-            samplingPts,
-            samplingCells,
-            samplingFaces,
-            samplingCurveDist
-        );
-
-        // fill sampleSegments
-        for (label i = samplingPts.size() - 1; i >= startSegmentI; --i)
-        {
-            samplingSegments.append(segmentI);
-        }
-
-
-        if (!reachedBoundary)
-        {
-            if (debug)
-            {
-                Pout<< "calcSamples : Reached end of samples: "
-                    << "  samplePt now:" << samplePt
-                    << "  sampleI now:" << sampleI
-                    << endl;
-            }
-            break;
-        }
-
-
-        bool foundValidB = false;
-
-        while (bHitI < bHits.size())
-        {
-            scalar dist =
-                (bHits[bHitI].hitPoint() - singleParticle.position())
-              & normOffset;
-
-            if (debug)
-            {
-                Pout<< "Finding next boundary : "
-                    << "bPoint:" << bHits[bHitI].hitPoint()
-                    << "  tracking:" << singleParticle.position()
-                    << "  dist:" << dist
-                    << endl;
-            }
-
-            if (dist > smallDist)
-            {
-                // hitpoint is past tracking position
-                foundValidB = true;
-                break;
-            }
-            else
-            {
-                bHitI++;
-            }
-        }
-
-        if (!foundValidB)
-        {
-            // No valid boundary intersection found beyond tracking position
-            break;
-        }
-
-        // Update starting point for tracking
-        trackFacei = bFacei;
-        trackPt = pushIn(bPoint, trackFacei);
-        trackCelli = getBoundaryCell(trackFacei);
-
-        segmentI++;
-
-        startSegmentI = samplingPts.size();
-    }
-
-    const_cast<polyMesh&>(mesh()).moving(oldMoving);
-}
-
-
-void Foam::uniformSet::genSamples()
-{
-    // Storage for sample points
-    DynamicList<point> samplingPts;
-    DynamicList<label> samplingCells;
-    DynamicList<label> samplingFaces;
-    DynamicList<label> samplingSegments;
-    DynamicList<scalar> samplingCurveDist;
-
-    calcSamples
-    (
-        samplingPts,
-        samplingCells,
-        samplingFaces,
-        samplingSegments,
-        samplingCurveDist
-    );
-
-    samplingPts.shrink();
-    samplingCells.shrink();
-    samplingFaces.shrink();
-    samplingSegments.shrink();
-    samplingCurveDist.shrink();
-
-    setSamples
-    (
-        samplingPts,
-        samplingCells,
-        samplingFaces,
-        samplingSegments,
-        samplingCurveDist
-    );
-}
-
-
-// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
-
-Foam::uniformSet::uniformSet
-(
-    const word& name,
-    const polyMesh& mesh,
-    const meshSearch& searchEngine,
-    const word& axis,
-    const point& start,
-    const point& end,
-    const label nPoints
-)
-:
-    sampledSet(name, mesh, searchEngine, axis),
-    start_(start),
-    end_(end),
-    nPoints_(nPoints)
-{
-    genSamples();
-
-    if (debug)
-    {
-        write(Pout);
-    }
-}
-
-
-Foam::uniformSet::uniformSet
-(
-    const word& name,
-    const polyMesh& mesh,
-    const meshSearch& searchEngine,
-    const dictionary& dict
-)
-:
-    sampledSet(name, mesh, searchEngine, dict),
-    start_(dict.lookup("start")),
-    end_(dict.lookup("end")),
-    nPoints_(readLabel(dict.lookup("nPoints")))
-{
-    genSamples();
-
-    if (debug)
-    {
-        write(Pout);
-    }
-}
-
-
-// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
-
-Foam::uniformSet::~uniformSet()
-{}
-
-
-// ************************************************************************* //
diff --git a/tutorials/combustion/reactingFoam/RAS/SandiaD_LTS/system/sampleDict b/tutorials/combustion/reactingFoam/RAS/SandiaD_LTS/system/sampleDict
deleted file mode 100644
index 732a5a694f..0000000000
--- a/tutorials/combustion/reactingFoam/RAS/SandiaD_LTS/system/sampleDict
+++ /dev/null
@@ -1,162 +0,0 @@
-/*--------------------------------*- C++ -*----------------------------------*\
-| =========                 |                                                 |
-| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
-|  \\    /   O peration     | Version:  dev                                   |
-|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
-|    \\/     M anipulation  |                                                 |
-\*---------------------------------------------------------------------------*/
-
-FoamFile
-{
-    version         2.0;
-    format          ascii;
-    class           dictionary;
-    location        system;
-    object          sampleDict;
-}
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-// Set output format : choice of
-//      xmgr
-//      jplot
-//      gnuplot
-//      raw
-setFormat raw;
-
-// Surface output format. Choice of
-//      null        : suppress output
-//      foamFile    : separate points, faces and values file
-//      dx          : DX scalar or vector format
-//      vtk         : VTK ascii format
-//      raw         : x y z value format for use with e.g. gnuplot 'splot'.
-//
-// Note:
-// other formats such as obj, stl, etc can also be written (by proxy)
-// but without any values!
-surfaceFormat vtk;
-
-// interpolationScheme. choice of
-//      cell          : use cell-centre value only; constant over cells (default)
-//      cellPoint     : use cell-centre and vertex values
-//      cellPointFace : use cell-centre, vertex and face values.
-// 1] vertex values determined from neighbouring cell-centre values
-// 2] face values determined using the current face interpolation scheme
-//    for the field (linear, gamma, etc.)
-interpolationScheme cellPoint;
-
-// Fields to sample.
-fields
-(
-    T
-    CO
-    CO2
-    H2
-    H2O
-    N2
-    O2
-    OH
-    CH4
-);
-
-
-// Set sampling definition: choice of
-//      uniform             evenly distributed points on line
-//      face                one point per face intersection
-//      midPoint            one point per cell, in between two face intersections
-//      midPointAndFace     combination of face and midPoint
-//
-//      curve               specified points, not necessary on line, uses
-//                          tracking
-//      cloud               specified points, uses findCell
-//
-// axis: how to write point coordinate. Choice of
-// - x/y/z: x/y/z coordinate only
-// - xyz: three columns
-//  (probably does not make sense for anything but raw)
-// - distance: distance from start of sampling line (if uses line) or
-//             distance from first specified sampling point
-//
-// type specific:
-//      uniform, face, midPoint, midPointAndFace : start and end coordinate
-//      uniform: extra number of sampling points
-//      curve, cloud: list of coordinates
-sets
-(
-    Centerline
-    {
-        type        uniform;
-        axis        distance;
-
-        start       (0.00001 0. 0. );
-        end         (0.00001 0. 0.500);
-        nPoints     500;
-    }
-
-    Radial_075
-    {
-        type        uniform;
-        axis        distance;
-
-        start       (0 0 0.054);
-        end         (0.020 0 0.054);
-        nPoints     100;
-    }
-    Radial_15
-       {
-        type        uniform;
-        axis        distance;
-
-        start       (0 0 0.108);
-        end         (0.024 0.108);
-        nPoints     100;
-    }
-    Radial_30
-     {
-        type        uniform;
-        axis        distance;
-
-        start       (0 0 0.216);
-        end         (0.042 0 0.216);
-        nPoints     100;
-    }
-    Radial_45
-      {
-        type        uniform;
-        axis        distance;
-
-        start       (0 0 0.324);
-        end         (0.056 0 0.324);
-        nPoints     100;
-    }
-    Radial_60
-        {
-        type        uniform;
-        axis        distance;
-
-        start       (0 0 0.432);
-        end         (0.070 0 0.432);
-        nPoints     100;
-    }
-    Radial_75
-        {
-        type        uniform;
-        axis        distance;
-
-        start       (0 0 0.54);
-        end         (0.080 0 0.54);
-        nPoints     100;
-    }
-);
-
-
-// Surface sampling definition: choice of
-//      plane : values on plane defined by point, normal.
-//      patch : values on patch.
-//
-// 1] patches are not triangulated by default
-// 2] planes are always triangulated
-// 3] iso-surfaces are always triangulated
-surfaces ();
-
-// *********************************************************************** //
diff --git a/tutorials/compressible/rhoCentralFoam/biconic25-55Run35/system/sample b/tutorials/compressible/rhoCentralFoam/biconic25-55Run35/system/sample
index e58283cb8b..6cfa354b98 100644
--- a/tutorials/compressible/rhoCentralFoam/biconic25-55Run35/system/sample
+++ b/tutorials/compressible/rhoCentralFoam/biconic25-55Run35/system/sample
@@ -26,7 +26,7 @@ sets
 (
     cone25
     {
-        type    face;
+        type    lineFace;
         axis    x;
         start   (0 0 0);
         end     (0.09208087 0.042939 0);
@@ -34,7 +34,7 @@ sets
     }
     cone55
     {
-        type    face;
+        type    lineFace;
         axis    x;
         start   (0.09208087 0.042939 0);
         end     (0.153683 0.13092 0);
@@ -42,7 +42,7 @@ sets
     }
     base
     {
-        type    face;
+        type    lineFace;
         axis    x;
         start   (0.153683 0.13092 0);
         end     (0.193675 0.13092 0);
diff --git a/tutorials/compressible/rhoCentralFoam/shockTube/system/sample b/tutorials/compressible/rhoCentralFoam/shockTube/system/sample
index c6c3c7bd00..3ebbf1c826 100644
--- a/tutorials/compressible/rhoCentralFoam/shockTube/system/sample
+++ b/tutorials/compressible/rhoCentralFoam/shockTube/system/sample
@@ -26,7 +26,7 @@ sets
 (
     line
     {
-        type    face;
+        type    lineFace;
         axis    x;
         start   (-5 0 0);
         end     (5 0 0);
diff --git a/tutorials/compressible/sonicFoam/laminar/shockTube/system/sample b/tutorials/compressible/sonicFoam/laminar/shockTube/system/sample
index 49a179436f..6c9ecce668 100644
--- a/tutorials/compressible/sonicFoam/laminar/shockTube/system/sample
+++ b/tutorials/compressible/sonicFoam/laminar/shockTube/system/sample
@@ -26,7 +26,7 @@ sets
 (
     data
     {
-        type    uniform;
+        type    lineUniform;
         axis    x;
         start   (-4.995 0 0);
         end     (4.995 0 0);
diff --git a/tutorials/electromagnetics/mhdFoam/hartmann/system/sample b/tutorials/electromagnetics/mhdFoam/hartmann/system/sample
index 14019e4fbf..b8f4c1c63d 100644
--- a/tutorials/electromagnetics/mhdFoam/hartmann/system/sample
+++ b/tutorials/electromagnetics/mhdFoam/hartmann/system/sample
@@ -26,7 +26,7 @@ sets
 (
     line_centreProfile
     {
-        type    uniform;
+        type    lineUniform;
         axis    distance;
         start   (10.001 -1 0.01);
         end     (10.001 1 0.01);
diff --git a/tutorials/heatTransfer/buoyantSimpleFoam/buoyantCavity/system/sample b/tutorials/heatTransfer/buoyantSimpleFoam/buoyantCavity/system/sample
index b350b7d68d..b7d0e41e53 100644
--- a/tutorials/heatTransfer/buoyantSimpleFoam/buoyantCavity/system/sample
+++ b/tutorials/heatTransfer/buoyantSimpleFoam/buoyantCavity/system/sample
@@ -27,63 +27,63 @@ sets
 (
     y0.1
     {
-        type            face;
+        type            lineFace;
         axis            x;
         start           (-1 0.218 0);
         end             (1 0.218 0);
     }
     y0.2
     {
-        type            face;
+        type            lineFace;
         axis            x;
         start           (-1 0.436 0);
         end             (1 0.436 0);
     }
     y0.3
     {
-        type            face;
+        type            lineFace;
         axis            x;
         start           (-1 0.654 0);
         end             (1 0.654 0);
     }
     y0.4
     {
-        type            face;
+        type            lineFace;
         axis            x;
         start           (-1 0.872 0);
         end             (1 0.872 0);
     }
     y0.5
     {
-        type            face;
+        type            lineFace;
         axis            x;
         start           (-1 1.09 0);
         end             (1 1.09 0);
     }
     y0.6
     {
-        type            face;
+        type            lineFace;
         axis            x;
         start           (-1 1.308 0);
         end             (1 1.308 0);
     }
     y0.7
     {
-        type            face;
+        type            lineFace;
         axis            x;
         start           (-1 1.526 0);
         end             (1 1.526 0);
     }
     y0.8
     {
-        type            face;
+        type            lineFace;
         axis            x;
         start           (-1 1.744 0);
         end             (1 1.744 0);
     }
     y0.9
     {
-        type            face;
+        type            lineFace;
         axis            x;
         start           (-1 1.962 0);
         end             (1 1.962 0);
diff --git a/tutorials/incompressible/pimpleFoam/laminar/planarContraction/system/graphs b/tutorials/incompressible/pimpleFoam/laminar/planarContraction/system/graphs
index 6c622052c3..c731fb1d54 100644
--- a/tutorials/incompressible/pimpleFoam/laminar/planarContraction/system/graphs
+++ b/tutorials/incompressible/pimpleFoam/laminar/planarContraction/system/graphs
@@ -15,9 +15,6 @@ Description
 // Sampling and I/O settings
 #includeEtc "caseDicts/postProcessing/graphs/sampleDict.cfg"
 
-// Override settings here, e.g.
-// setConfig { type midPoint; }
-
 type            sets;
 libs            ("libsampling.so");
 
@@ -29,7 +26,7 @@ setFormat   raw;
 
 setConfig
 {
-    type    midPoint;  // midPoint
+    type    lineCell;
     axis    distance;  // x, y, z, xyz
 }
 
diff --git a/tutorials/incompressible/pimpleFoam/laminar/planarPoiseuille/system/singleGraph b/tutorials/incompressible/pimpleFoam/laminar/planarPoiseuille/system/singleGraph
index 560dd1c51a..51b994b338 100644
--- a/tutorials/incompressible/pimpleFoam/laminar/planarPoiseuille/system/singleGraph
+++ b/tutorials/incompressible/pimpleFoam/laminar/planarPoiseuille/system/singleGraph
@@ -15,9 +15,6 @@ Description
 // Sampling and I/O settings
 #includeEtc "caseDicts/postProcessing/graphs/sampleDict.cfg"
 
-// Override settings here, e.g.
-// setConfig { type midPoint; }
-
 type            sets;
 libs            ("libsampling.so");
 
@@ -29,7 +26,7 @@ setFormat   raw;
 
 setConfig
 {
-    type    midPoint;  // midPoint
+    type    lineCell;
     axis    distance;  // x, y, z, xyz
 }
 
diff --git a/tutorials/incompressible/pisoFoam/LES/motorBike/motorBike/system/controlDict b/tutorials/incompressible/pisoFoam/LES/motorBike/motorBike/system/controlDict
index 10be98ae67..d08d3dd4bb 100644
--- a/tutorials/incompressible/pisoFoam/LES/motorBike/motorBike/system/controlDict
+++ b/tutorials/incompressible/pisoFoam/LES/motorBike/motorBike/system/controlDict
@@ -61,7 +61,7 @@ functions
         cloudName       particleTracks;
         seedSampleSet
         {
-            type            uniform;
+            type            lineUniform;
             axis            x;
             start           (-1.001 1e-07 0.0011);
             end             (-1.001 1e-07 1.0011);
diff --git a/tutorials/incompressible/pisoFoam/LES/motorBike/motorBike/system/streamLines b/tutorials/incompressible/pisoFoam/LES/motorBike/motorBike/system/streamLines
index 3085ec8a4d..0e0f855559 100644
--- a/tutorials/incompressible/pisoFoam/LES/motorBike/motorBike/system/streamLines
+++ b/tutorials/incompressible/pisoFoam/LES/motorBike/motorBike/system/streamLines
@@ -34,7 +34,7 @@ streamLines
     // Seeding method.
     seedSampleSet
     {
-        type        uniform;
+        type        lineUniform;
         axis        x;  // distance;
 
         // Note: tracks slightly offset so as not to be on a face
diff --git a/tutorials/incompressible/simpleFoam/motorBike/system/streamLines b/tutorials/incompressible/simpleFoam/motorBike/system/streamLines
index 084a1b597a..f1502a0609 100644
--- a/tutorials/incompressible/simpleFoam/motorBike/system/streamLines
+++ b/tutorials/incompressible/simpleFoam/motorBike/system/streamLines
@@ -44,7 +44,7 @@ streamLines
     // Seeding method.
     seedSampleSet
     {
-        type        uniform;
+        type        lineUniform;
         axis        x;  // distance;
 
         // Note: tracks slightly offset so as not to be on a face
diff --git a/tutorials/incompressible/simpleFoam/pitzDailyExptInlet/system/controlDict b/tutorials/incompressible/simpleFoam/pitzDailyExptInlet/system/controlDict
index 9056237b41..b88a80ab7e 100644
--- a/tutorials/incompressible/simpleFoam/pitzDailyExptInlet/system/controlDict
+++ b/tutorials/incompressible/simpleFoam/pitzDailyExptInlet/system/controlDict
@@ -78,7 +78,7 @@ functions
         // Seeding method.
         seedSampleSet
         {
-            type        uniform;
+            type        lineUniform;
 
             axis        x;  // distance;
             start       (-0.0205 0.001  0.00001);