From 50dcc40e9aeceafd3bfa117a8e1229d0abdadd49 Mon Sep 17 00:00:00 2001
From: mattijs <mattijs@hunt.opencfd.co.uk>
Date: Mon, 20 Oct 2008 15:31:39 +0100
Subject: [PATCH 01/10] new interval syntax

---
 tutorials/interDyMFoam/sloshingTank2D/system/controlDict | 9 +++++++--
 .../interDyMFoam/sloshingTank2D3DoF/system/controlDict   | 9 +++++++--
 tutorials/interDyMFoam/sloshingTank3D/system/controlDict | 9 +++++++--
 .../interDyMFoam/sloshingTank3D3DoF/system/controlDict   | 9 +++++++--
 .../interDyMFoam/sloshingTank3D6DoF/system/controlDict   | 9 +++++++--
 5 files changed, 35 insertions(+), 10 deletions(-)

diff --git a/tutorials/interDyMFoam/sloshingTank2D/system/controlDict b/tutorials/interDyMFoam/sloshingTank2D/system/controlDict
index 8d7fb44aa4..e3e7167169 100644
--- a/tutorials/interDyMFoam/sloshingTank2D/system/controlDict
+++ b/tutorials/interDyMFoam/sloshingTank2D/system/controlDict
@@ -57,6 +57,10 @@ functions
         // Type of functionObject
         type probes;
 
+        // Output every
+        outputControl timeStep;
+        outputInterval 1;
+
         // Name of the directory for the probe data
         name probes;
 
@@ -82,8 +86,9 @@ functions
         // Where to load it from (if not already in solver)
         functionObjectLibs ("libsampling.so");
 
-		// Output every 10th time step
-        interval 10;
+        // Output every
+        outputControl timeStep;
+        outputInterval 10;
 
         surfaceFormat raw;
 
diff --git a/tutorials/interDyMFoam/sloshingTank2D3DoF/system/controlDict b/tutorials/interDyMFoam/sloshingTank2D3DoF/system/controlDict
index 8d7fb44aa4..410cb58d6d 100644
--- a/tutorials/interDyMFoam/sloshingTank2D3DoF/system/controlDict
+++ b/tutorials/interDyMFoam/sloshingTank2D3DoF/system/controlDict
@@ -57,6 +57,10 @@ functions
         // Type of functionObject
         type probes;
 
+        // Output every 10th time step
+        outputControl timeStep;
+        outputInterval 10;
+
         // Name of the directory for the probe data
         name probes;
 
@@ -82,8 +86,9 @@ functions
         // Where to load it from (if not already in solver)
         functionObjectLibs ("libsampling.so");
 
-		// Output every 10th time step
-        interval 10;
+        // Output every 10th time step
+        outputControl timeStep;
+        outputInterval 10;
 
         surfaceFormat raw;
 
diff --git a/tutorials/interDyMFoam/sloshingTank3D/system/controlDict b/tutorials/interDyMFoam/sloshingTank3D/system/controlDict
index b721c9c058..208bb1c29a 100644
--- a/tutorials/interDyMFoam/sloshingTank3D/system/controlDict
+++ b/tutorials/interDyMFoam/sloshingTank3D/system/controlDict
@@ -57,6 +57,10 @@ functions
         // Type of functionObject
         type probes;
 
+        // Output every
+        outputControl timeStep;
+        outputInterval 1;
+
         // Name of the directory for the probe data
         name probes;
 
@@ -83,8 +87,9 @@ functions
         // Where to load it from (if not already in solver)
         functionObjectLibs ("libsampling.so");
 
-		// Output every 10th time step
-        interval 10;
+        // Output every 10th time step
+        outputControl timeStep;
+        outputInterval 10;
 
         surfaceFormat raw;
 
diff --git a/tutorials/interDyMFoam/sloshingTank3D3DoF/system/controlDict b/tutorials/interDyMFoam/sloshingTank3D3DoF/system/controlDict
index b721c9c058..208bb1c29a 100644
--- a/tutorials/interDyMFoam/sloshingTank3D3DoF/system/controlDict
+++ b/tutorials/interDyMFoam/sloshingTank3D3DoF/system/controlDict
@@ -57,6 +57,10 @@ functions
         // Type of functionObject
         type probes;
 
+        // Output every
+        outputControl timeStep;
+        outputInterval 1;
+
         // Name of the directory for the probe data
         name probes;
 
@@ -83,8 +87,9 @@ functions
         // Where to load it from (if not already in solver)
         functionObjectLibs ("libsampling.so");
 
-		// Output every 10th time step
-        interval 10;
+        // Output every 10th time step
+        outputControl timeStep;
+        outputInterval 10;
 
         surfaceFormat raw;
 
diff --git a/tutorials/interDyMFoam/sloshingTank3D6DoF/system/controlDict b/tutorials/interDyMFoam/sloshingTank3D6DoF/system/controlDict
index b721c9c058..208bb1c29a 100644
--- a/tutorials/interDyMFoam/sloshingTank3D6DoF/system/controlDict
+++ b/tutorials/interDyMFoam/sloshingTank3D6DoF/system/controlDict
@@ -57,6 +57,10 @@ functions
         // Type of functionObject
         type probes;
 
+        // Output every
+        outputControl timeStep;
+        outputInterval 1;
+
         // Name of the directory for the probe data
         name probes;
 
@@ -83,8 +87,9 @@ functions
         // Where to load it from (if not already in solver)
         functionObjectLibs ("libsampling.so");
 
-		// Output every 10th time step
-        interval 10;
+        // Output every 10th time step
+        outputControl timeStep;
+        outputInterval 10;
 
         surfaceFormat raw;
 

From 9b15a7e249d87e2a80a6dbc29478426b92c94a2e Mon Sep 17 00:00:00 2001
From: mattijs <mattijs@hunt.opencfd.co.uk>
Date: Tue, 21 Oct 2008 13:45:50 +0100
Subject: [PATCH 02/10] foamAddLib does not like multiple paths

---
 etc/settings.csh | 19 ++++---------------
 1 file changed, 4 insertions(+), 15 deletions(-)

diff --git a/etc/settings.csh b/etc/settings.csh
index 5eb326c5a5..1958e71787 100644
--- a/etc/settings.csh
+++ b/etc/settings.csh
@@ -78,11 +78,6 @@ _foamMkDir $FOAM_USER_LIBBIN
 _foamMkDir $FOAM_USER_APPBIN
 
 
-# Compiler settings
-# ~~~~~~~~~~~~~~~~~
-set compilerBin=
-set compilerLib=
-
 # Select compiler installation
 # ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 # compilerInstall = OpenFOAM | System
@@ -111,19 +106,13 @@ case OpenFOAM:
         echo
     endif
 
-    set compilerBin=$WM_COMPILER_DIR/bin
-    set compilerLib=$WM_COMPILER_DIR/lib${WM_COMPILER_LIB_ARCH}:$WM_COMPILER_DIR/lib
+    _foamAddPath ${WM_COMPILER_DIR}/bin
+    _foamAddLib  ${WM_COMPILER_DIR}/lib${WM_COMPILER_LIB_ARCH}
+    _foamAddLib  ${WM_COMPILER_DIR}/lib
+
     breaksw
 endsw
 
-if ($?compilerBin) then
-    _foamAddPath $compilerBin
-    _foamAddLib  $compilerLib
-endif
-
-unset compilerBin
-unset compilerLib
-
 
 # Communications library
 # ~~~~~~~~~~~~~~~~~~~~~~

From 99e9ffa46fc7a315c298881ecc0df5f35921d7fb Mon Sep 17 00:00:00 2001
From: mattijs <mattijs@hunt.opencfd.co.uk>
Date: Tue, 21 Oct 2008 13:46:32 +0100
Subject: [PATCH 03/10] deletion of owned objects

---
 .../db/objectRegistry/objectRegistry.C        |  8 +++++--
 src/OpenFOAM/meshes/MeshObject/MeshObject.C   | 23 +++++++++++++++++++
 src/OpenFOAM/meshes/MeshObject/MeshObject.H   |  2 ++
 3 files changed, 31 insertions(+), 2 deletions(-)

diff --git a/src/OpenFOAM/db/objectRegistry/objectRegistry.C b/src/OpenFOAM/db/objectRegistry/objectRegistry.C
index dbbf8a82e5..df9da24055 100644
--- a/src/OpenFOAM/db/objectRegistry/objectRegistry.C
+++ b/src/OpenFOAM/db/objectRegistry/objectRegistry.C
@@ -177,12 +177,16 @@ bool Foam::objectRegistry::checkOut(regIOobject& io) const
         }
         else
         {
+            regIOobject* object = iter();
+
+            bool hasErased = const_cast<objectRegistry&>(*this).erase(iter);
+
             if (io.ownedByRegistry())
             {
-                delete iter();
+                delete object;
             }
 
-            return const_cast<objectRegistry&>(*this).erase(iter);
+            return hasErased;
         }
     }
     else
diff --git a/src/OpenFOAM/meshes/MeshObject/MeshObject.C b/src/OpenFOAM/meshes/MeshObject/MeshObject.C
index fddfadfa59..ba67517700 100644
--- a/src/OpenFOAM/meshes/MeshObject/MeshObject.C
+++ b/src/OpenFOAM/meshes/MeshObject/MeshObject.C
@@ -105,6 +105,29 @@ const Type& Foam::MeshObject<Mesh, Type>::New
 
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * //
 
+template<class Mesh, class Type>
+bool Foam::MeshObject<Mesh, Type>::Delete(const Mesh& mesh)
+{
+    if (mesh.db().objectRegistry::foundObject<Type>(Type::typeName))
+    {
+        return mesh.db().objectRegistry::checkOut
+        (
+            const_cast<Type&>
+            (
+                mesh.db().objectRegistry::lookupObject<Type>
+                (
+                    Type::typeName
+                )
+            )
+        );
+    }
+    else
+    {
+        return false;
+    }
+}
+
+
 template<class Mesh, class Type>
 Foam::MeshObject<Mesh, Type>::~MeshObject()
 {
diff --git a/src/OpenFOAM/meshes/MeshObject/MeshObject.H b/src/OpenFOAM/meshes/MeshObject/MeshObject.H
index b142b47f96..ee20ccfa3e 100644
--- a/src/OpenFOAM/meshes/MeshObject/MeshObject.H
+++ b/src/OpenFOAM/meshes/MeshObject/MeshObject.H
@@ -78,6 +78,8 @@ public:
 
     // Destructor
 
+        static bool Delete(const Mesh& mesh);
+
         virtual ~MeshObject();
 
 

From 5640ed63c289dcbcd6f8450f355801c7e88f2b54 Mon Sep 17 00:00:00 2001
From: mattijs <mattijs@hunt.opencfd.co.uk>
Date: Tue, 21 Oct 2008 13:49:25 +0100
Subject: [PATCH 04/10] writing

---
 src/meshTools/searchableSurface/distributedTriSurfaceMesh.C | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/meshTools/searchableSurface/distributedTriSurfaceMesh.C b/src/meshTools/searchableSurface/distributedTriSurfaceMesh.C
index 5abc758ad3..0b2d8d1bde 100644
--- a/src/meshTools/searchableSurface/distributedTriSurfaceMesh.C
+++ b/src/meshTools/searchableSurface/distributedTriSurfaceMesh.C
@@ -2188,6 +2188,9 @@ bool Foam::distributedTriSurfaceMesh::writeObject
     IOstream::compressionType cmp
 ) const
 {
+    // Make sure dictionary goes to same directory as surface
+    const_cast<fileName&>(dict_.instance()) = searchableSurface::instance();
+
     return
         triSurfaceMesh::writeObject(fmt, ver, cmp)
      && dict_.writeObject(fmt, ver, cmp);

From 20e528e8bd7d15cdc7425eb19becf6e787e2b6e9 Mon Sep 17 00:00:00 2001
From: mattijs <mattijs@hunt.opencfd.co.uk>
Date: Tue, 21 Oct 2008 14:01:18 +0100
Subject: [PATCH 05/10] xfer constructors

---
 src/OpenFOAM/meshes/polyMesh/polyMesh.C | 464 ++++++++++++++++++++++++
 1 file changed, 464 insertions(+)

diff --git a/src/OpenFOAM/meshes/polyMesh/polyMesh.C b/src/OpenFOAM/meshes/polyMesh/polyMesh.C
index 3b7961979d..31ff85bf2c 100644
--- a/src/OpenFOAM/meshes/polyMesh/polyMesh.C
+++ b/src/OpenFOAM/meshes/polyMesh/polyMesh.C
@@ -35,6 +35,8 @@ License
 #include "OSspecific.H"
 #include "demandDrivenData.H"
 
+#include "pointMesh.H"
+
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
 namespace Foam
@@ -425,6 +427,162 @@ Foam::polyMesh::polyMesh
 }
 
 
+Foam::polyMesh::polyMesh
+(
+    const IOobject& io,
+    const xfer<pointField>& points,
+    const xfer<faceList>& faces,
+    const xfer<labelList>& owner,
+    const xfer<labelList>& neighbour,
+    const bool syncPar
+)
+:
+    objectRegistry(io),
+    primitiveMesh(),
+    points_
+    (
+        IOobject
+        (
+            "points",
+            instance(),
+            meshSubDir,
+            *this,
+            IOobject::NO_READ,
+            IOobject::AUTO_WRITE
+        ),
+        points
+    ),
+    faces_
+    (
+        IOobject
+        (
+            "faces",
+            instance(),
+            meshSubDir,
+            *this,
+            IOobject::NO_READ,
+            IOobject::AUTO_WRITE
+        ),
+        faces
+    ),
+    owner_
+    (
+        IOobject
+        (
+            "owner",
+            instance(),
+            meshSubDir,
+            *this,
+            IOobject::NO_READ,
+            IOobject::AUTO_WRITE
+        ),
+        owner
+    ),
+    neighbour_
+    (
+        IOobject
+        (
+            "neighbour",
+            instance(),
+            meshSubDir,
+            *this,
+            IOobject::NO_READ,
+            IOobject::AUTO_WRITE
+        ),
+        neighbour
+    ),
+    clearedPrimitives_(false),
+    boundary_
+    (
+        IOobject
+        (
+            "boundary",
+            instance(),
+            meshSubDir,
+            *this,
+            IOobject::NO_READ,
+            IOobject::AUTO_WRITE
+        ),
+        *this,
+        0
+    ),
+    bounds_(points_, syncPar),
+    directions_(Vector<label>::zero),
+    pointZones_
+    (
+        IOobject
+        (
+            "pointZones",
+            instance(),
+            meshSubDir,
+            *this,
+            IOobject::NO_READ,
+            IOobject::NO_WRITE
+        ),
+        *this,
+        0
+    ),
+    faceZones_
+    (
+        IOobject
+        (
+            "faceZones",
+            instance(),
+            meshSubDir,
+            *this,
+            IOobject::NO_READ,
+            IOobject::NO_WRITE
+        ),
+        *this,
+        0
+    ),
+    cellZones_
+    (
+        IOobject
+        (
+            "cellZones",
+            instance(),
+            meshSubDir,
+            *this,
+            IOobject::NO_READ,
+            IOobject::NO_WRITE
+        ),
+        *this,
+        0
+    ),
+    globalMeshDataPtr_(NULL),
+    moving_(false),
+    changing_(false),
+    curMotionTimeIndex_(time().timeIndex()),
+    oldPointsPtr_(NULL)
+{
+    // Check if the faces and cells are valid
+    forAll (faces_, faceI)
+    {
+        const face& curFace = faces_[faceI];
+
+        if (min(curFace) < 0 || max(curFace) > points_.size())
+        {
+            FatalErrorIn
+            (
+                "polyMesh::polyMesh\n"
+                "(\n"
+                "    const IOobject& io,\n"
+                "    const pointField& points,\n"
+                "    const faceList& faces,\n"
+                "    const cellList& cells\n"
+                ")\n"
+            )   << "Face " << faceI << "contains vertex labels out of range: "
+                << curFace << " Max point index = " << points_.size()
+                << abort(FatalError);
+        }
+    }
+
+    // Set the primitive mesh
+    initMesh();
+}
+
+
 Foam::polyMesh::polyMesh
 (
     const IOobject& io,
@@ -602,6 +760,185 @@ Foam::polyMesh::polyMesh
 }
 
 
+Foam::polyMesh::polyMesh
+(
+    const IOobject& io,
+    const xfer<pointField>& points,
+    const xfer<faceList>& faces,
+    const xfer<cellList>& cells,
+    const bool syncPar
+)
+:
+    objectRegistry(io),
+    primitiveMesh(),
+    points_
+    (
+        IOobject
+        (
+            "points",
+            instance(),
+            meshSubDir,
+            *this,
+            IOobject::NO_READ,
+            IOobject::AUTO_WRITE
+        ),
+        points
+    ),
+    faces_
+    (
+        IOobject
+        (
+            "faces",
+            instance(),
+            meshSubDir,
+            *this,
+            IOobject::NO_READ,
+            IOobject::AUTO_WRITE
+        ),
+        faces
+    ),
+    owner_
+    (
+        IOobject
+        (
+            "owner",
+            instance(),
+            meshSubDir,
+            *this,
+            IOobject::NO_READ,
+            IOobject::AUTO_WRITE
+        ),
+        0
+    ),
+    neighbour_
+    (
+        IOobject
+        (
+            "neighbour",
+            instance(),
+            meshSubDir,
+            *this,
+            IOobject::NO_READ,
+            IOobject::AUTO_WRITE
+        ),
+        0
+    ),
+    clearedPrimitives_(false),
+    boundary_
+    (
+        IOobject
+        (
+            "boundary",
+            instance(),
+            meshSubDir,
+            *this,
+            IOobject::NO_READ,
+            IOobject::AUTO_WRITE
+        ),
+        *this,
+        0
+    ),
+    bounds_(points_, syncPar),
+    directions_(Vector<label>::zero),
+    pointZones_
+    (
+        IOobject
+        (
+            "pointZones",
+            instance(),
+            meshSubDir,
+            *this,
+            IOobject::NO_READ,
+            IOobject::NO_WRITE
+        ),
+        *this,
+        0
+    ),
+    faceZones_
+    (
+        IOobject
+        (
+            "faceZones",
+            instance(),
+            meshSubDir,
+            *this,
+            IOobject::NO_READ,
+            IOobject::NO_WRITE
+        ),
+        *this,
+        0
+    ),
+    cellZones_
+    (
+        IOobject
+        (
+            "cellZones",
+            instance(),
+            meshSubDir,
+            *this,
+            IOobject::NO_READ,
+            IOobject::NO_WRITE
+        ),
+        *this,
+        0
+    ),
+    globalMeshDataPtr_(NULL),
+    moving_(false),
+    changing_(false),
+    curMotionTimeIndex_(time().timeIndex()),
+    oldPointsPtr_(NULL)
+{
+    // Check if faces are valid
+    forAll (faces_, faceI)
+    {
+        const face& curFace = faces_[faceI];
+
+        if (min(curFace) < 0 || max(curFace) > points_.size())
+        {
+            FatalErrorIn
+            (
+                "polyMesh::polyMesh\n"
+                "(\n"
+                "    const IOobject&,\n"
+                "    const xfer<pointField>&,\n"
+                "    const xfer<faceList>&,\n"
+                "    const xfer<cellList>&\n"
+                ")\n"
+            )   << "Face " << faceI << "contains vertex labels out of range: "
+                << curFace << " Max point index = " << points_.size()
+                << abort(FatalError);
+        }
+    }
+
+    const cellList& cLst = cells();
+
+    // Check if cells are valid
+    forAll (cLst, cellI)
+    {
+        const cell& curCell = cLst[cellI];
+
+        if (min(curCell) < 0 || max(curCell) > faces_.size())
+        {
+            FatalErrorIn
+            (
+                "polyMesh::polyMesh\n"
+                "(\n"
+                "    const IOobject&,\n"
+                "    const xfer<pointField>&,\n"
+                "    const xfer<faceList>&,\n"
+                "    const xfer<cellList>&\n"
+                ")\n"
+            )   << "Cell " << cellI << "contains face labels out of range: "
+                << curCell << " Max face index = " << faces_.size()
+                << abort(FatalError);
+        }
+    }
+
+    // Set the primitive mesh
+    initMesh(cells);
+}
+
+
 void Foam::polyMesh::resetPrimitives
 (
     const label nUsedFaces,
@@ -719,6 +1056,111 @@ void Foam::polyMesh::resetPrimitives
 }
 
 
+void Foam::polyMesh::resetPrimitives
+(
+    const label nUsedFaces,
+    const xfer<pointField>& points,
+    const xfer<faceList>& faces,
+    const xfer<labelList>& owner,
+    const xfer<labelList>& neighbour,
+    const labelList& patchSizes,
+    const labelList& patchStarts,
+    const bool validBoundary
+)
+{
+    // Clear addressing. Keep geometric props for mapping.
+    clearAddressing();
+
+    // Take over new primitive data.
+    points_.transfer(points());
+    bounds_ = boundBox(points_, validBoundary);
+
+    faces_.transfer(faces());
+    owner_.transfer(owner());
+    neighbour_.transfer(neighbour());
+
+    // Reset patch sizes and starts
+    forAll(boundary_, patchI)
+    {
+        boundary_[patchI] = polyPatch
+        (
+            boundary_[patchI].name(),
+            patchSizes[patchI],
+            patchStarts[patchI],
+            patchI,
+            boundary_
+        );
+    }
+
+
+    // Flags the mesh files as being changed
+    setInstance(time().timeName());
+
+    // Check if the faces and cells are valid
+    forAll (faces_, faceI)
+    {
+        const face& curFace = faces_[faceI];
+
+        if (min(curFace) < 0 || max(curFace) > points_.size())
+        {
+            FatalErrorIn
+            (
+                "polyMesh::polyMesh::resetPrimitives\n"
+                "(\n"
+                "    const label nUsedFaces,\n"
+                "    const xfer<pointField>&,\n"
+                "    const xfer<faceList>&,\n"
+                "    const xfer<labelList>& owner,\n"
+                "    const xfer<labelList>& neighbour,\n"
+                "    const labelList& patchSizes,\n"
+                "    const labelList& patchStarts\n"
+                ")\n"
+            )   << "Face " << faceI << " contains vertex labels out of range: "
+                << curFace << " Max point index = " << points_.size()
+                << abort(FatalError);
+        }
+    }
+
+
+    // Set the primitive mesh from the owner_, neighbour_. Works
+    // out from patch end where the active faces stop.
+    initMesh();
+
+
+    if (validBoundary)
+    {
+        // Note that we assume that all the patches stay the same and are
+        // correct etc. so we can already use the patches to do
+        // processor-processor comms.
+
+        // Calculate topology for the patches (processor-processor comms etc.)
+        boundary_.updateMesh();
+
+        // Calculate the geometry for the patches (transformation tensors etc.)
+        boundary_.calcGeometry();
+
+        // Warn if global empty mesh (constructs globalData!)
+        if (globalData().nTotalPoints() == 0 || globalData().nTotalCells() == 0)
+        {
+            FatalErrorIn
+            (
+                "polyMesh::polyMesh::resetPrimitives\n"
+                "(\n"
+                "    const label nUsedFaces,\n"
+                "    const xfer<pointField>&,\n"
+                "    const xfer<faceList>&,\n"
+                "    const xfer<labelList>& owner,\n"
+                "    const xfer<labelList>& neighbour,\n"
+                "    const labelList& patchSizes,\n"
+                "    const labelList& patchStarts\n"
+                ")\n"
+            )
+                << "no points or no cells in mesh" << endl;
+        }
+    }
+}
+
+
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 
 Foam::polyMesh::~polyMesh()
@@ -1037,6 +1479,28 @@ Foam::tmp<Foam::scalarField> Foam::polyMesh::movePoints
     faceZones_.movePoints(points_);
     cellZones_.movePoints(points_);
 
+
+    // Hack until proper callbacks. Below are all the polyMeh MeshObjects with a
+    // movePoints function.
+
+    // pointMesh
+    if
+    (
+        db().objectRegistry::foundObject<pointMesh>
+        (
+            pointMesh::typeName
+        )
+    )
+    {
+        const_cast<pointMesh&>
+        (
+            db().objectRegistry::lookupObject<pointMesh>
+            (
+                pointMesh::typeName
+            )
+        ).movePoints(points_);
+    }
+
     return sweptVols;
 }
 

From 204f93e89d501107b281925288b8c86e800b1ab4 Mon Sep 17 00:00:00 2001
From: mattijs <mattijs@hunt.opencfd.co.uk>
Date: Tue, 21 Oct 2008 14:05:05 +0100
Subject: [PATCH 06/10] xfer constructors

---
 src/finiteVolume/fvMesh/fvMesh.C | 301 ++++++++++++++++++++++++++++---
 1 file changed, 271 insertions(+), 30 deletions(-)

diff --git a/src/finiteVolume/fvMesh/fvMesh.C b/src/finiteVolume/fvMesh/fvMesh.C
index b6edbd66f6..8021b09f55 100644
--- a/src/finiteVolume/fvMesh/fvMesh.C
+++ b/src/finiteVolume/fvMesh/fvMesh.C
@@ -38,18 +38,34 @@ License
 #include "fvMeshMapper.H"
 #include "mapClouds.H"
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+#include "volPointInterpolation.H"
+#include "extendedLeastSquaresVectors.H"
+#include "extendedLeastSquaresVectors.H"
+#include "leastSquaresVectors.H"
+//#include "linearFitData.H"
+#include "quadraticFitData.H"
+//#include "quadraticFitSnGradData.H"
+#include "skewCorrectionVectors.H"
 
-namespace Foam
-{
+#include "centredCECStencilObject.H"
+#include "centredCFCStencilObject.H"
+#include "centredCPCStencilObject.H"
+#include "centredFECStencilObject.H"
+#include "upwindCECStencilObject.H"
+#include "upwindCFCStencilObject.H"
+#include "upwindCPCStencilObject.H"
+#include "upwindFECStencilObject.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-defineTypeNameAndDebug(fvMesh, 0);
+namespace Foam
+{
+    defineTypeNameAndDebug(fvMesh, 0);
+}
 
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 
-void fvMesh::clearGeomNotOldVol()
+void Foam::fvMesh::clearGeomNotOldVol()
 {
     slicedVolScalarField::DimensionedInternalField* VPtr =
         static_cast<slicedVolScalarField::DimensionedInternalField*>(VPtr_);
@@ -63,7 +79,7 @@ void fvMesh::clearGeomNotOldVol()
 }
 
 
-void fvMesh::clearGeom()
+void Foam::fvMesh::clearGeom()
 {
     clearGeomNotOldVol();
 
@@ -72,16 +88,47 @@ void fvMesh::clearGeom()
 
     // Mesh motion flux cannot be deleted here because the old-time flux
     // needs to be saved.
+
+
+    // Things geometry dependent that are not updated.
+    volPointInterpolation::Delete(*this);
+    extendedLeastSquaresVectors::Delete(*this);
+    extendedLeastSquaresVectors::Delete(*this);
+    leastSquaresVectors::Delete(*this);
+    //linearFitData::Delete(*this);
+    quadraticFitData::Delete(*this);
+    //quadraticFitSnGradData::Delete(*this);
+    skewCorrectionVectors::Delete(*this);
 }
 
 
-void fvMesh::clearAddressing()
+void Foam::fvMesh::clearAddressing()
 {
     deleteDemandDrivenData(lduPtr_);
+
+    // Hack until proper callbacks. Below are all the fvMesh-MeshObjects.
+
+    volPointInterpolation::Delete(*this);
+    extendedLeastSquaresVectors::Delete(*this);
+    extendedLeastSquaresVectors::Delete(*this);
+    leastSquaresVectors::Delete(*this);
+    //linearFitData::Delete(*this);
+    quadraticFitData::Delete(*this);
+    //quadraticFitSnGradData::Delete(*this);
+    skewCorrectionVectors::Delete(*this);
+
+    centredCECStencilObject::Delete(*this);
+    centredCFCStencilObject::Delete(*this);
+    centredCPCStencilObject::Delete(*this);
+    centredFECStencilObject::Delete(*this);
+    upwindCECStencilObject::Delete(*this);
+    upwindCFCStencilObject::Delete(*this);
+    upwindCPCStencilObject::Delete(*this);
+    upwindFECStencilObject::Delete(*this);
 }
 
 
-void fvMesh::clearOut()
+void Foam::fvMesh::clearOut()
 {
     clearGeom();
     surfaceInterpolation::clearOut();
@@ -97,7 +144,7 @@ void fvMesh::clearOut()
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
-fvMesh::fvMesh(const IOobject& io)
+Foam::fvMesh::fvMesh(const IOobject& io)
 :
     polyMesh(io),
     surfaceInterpolation(*this),
@@ -139,7 +186,7 @@ fvMesh::fvMesh(const IOobject& io)
         V00();
     }
 
-    // Check the existance of the mesh fluxes, read if present and set the 
+    // Check the existance of the mesh fluxes, read if present and set the
     // mesh to be moving
     if (file(time().timePath()/"meshPhi"))
     {
@@ -181,7 +228,7 @@ fvMesh::fvMesh(const IOobject& io)
 }
 
 
-fvMesh::fvMesh
+Foam::fvMesh::fvMesh
 (
     const IOobject& io,
     const pointField& points,
@@ -213,7 +260,39 @@ fvMesh::fvMesh
 }
 
 
-fvMesh::fvMesh
+Foam::fvMesh::fvMesh
+(
+    const IOobject& io,
+    const xfer<pointField>& points,
+    const xfer<faceList>& faces,
+    const xfer<labelList>& allOwner,
+    const xfer<labelList>& allNeighbour,
+    const bool syncPar
+)
+:
+    polyMesh(io, points, faces, allOwner, allNeighbour, syncPar),
+    surfaceInterpolation(*this),
+    boundary_(*this),
+    lduPtr_(NULL),
+    curTimeIndex_(time().timeIndex()),
+    VPtr_(NULL),
+    V0Ptr_(NULL),
+    V00Ptr_(NULL),
+    SfPtr_(NULL),
+    magSfPtr_(NULL),
+    CPtr_(NULL),
+    CfPtr_(NULL),
+    phiPtr_(NULL)
+{
+    if (debug)
+    {
+        Info<< "Constructing fvMesh from components"
+            << endl;
+    }
+}
+
+
+Foam::fvMesh::fvMesh
 (
     const IOobject& io,
     const pointField& points,
@@ -244,9 +323,40 @@ fvMesh::fvMesh
 }
 
 
+Foam::fvMesh::fvMesh
+(
+    const IOobject& io,
+    const xfer<pointField>& points,
+    const xfer<faceList>& faces,
+    const xfer<cellList>& cells,
+    const bool syncPar
+)
+:
+    polyMesh(io, points, faces, cells, syncPar),
+    surfaceInterpolation(*this),
+    boundary_(*this),
+    lduPtr_(NULL),
+    curTimeIndex_(time().timeIndex()),
+    VPtr_(NULL),
+    V0Ptr_(NULL),
+    V00Ptr_(NULL),
+    SfPtr_(NULL),
+    magSfPtr_(NULL),
+    CPtr_(NULL),
+    CfPtr_(NULL),
+    phiPtr_(NULL)
+{
+    if (debug)
+    {
+        Info<< "Constructing fvMesh from components"
+            << endl;
+    }
+}
+
+
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 
-fvMesh::~fvMesh()
+Foam::fvMesh::~fvMesh()
 {
     clearOut();
 }
@@ -255,7 +365,11 @@ fvMesh::~fvMesh()
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
 // Helper function for construction from pieces
-void fvMesh::addFvPatches(const List<polyPatch*> & p, const bool validBoundary)
+void Foam::fvMesh::addFvPatches
+(
+    const List<polyPatch*> & p,
+    const bool validBoundary
+)
 {
     if (boundary().size() > 0)
     {
@@ -272,7 +386,7 @@ void fvMesh::addFvPatches(const List<polyPatch*> & p, const bool validBoundary)
 }
 
 
-void fvMesh::removeFvBoundary()
+void Foam::fvMesh::removeFvBoundary()
 {
     if (debug)
     {
@@ -290,7 +404,7 @@ void fvMesh::removeFvBoundary()
 }
 
 
-polyMesh::readUpdateState fvMesh::readUpdate()
+Foam::polyMesh::readUpdateState Foam::fvMesh::readUpdate()
 {
     if (debug)
     {
@@ -310,7 +424,7 @@ polyMesh::readUpdateState fvMesh::readUpdate()
         boundary_.readUpdate(boundaryMesh());
 
         clearOut();
-        
+
     }
     else if (state == polyMesh::TOPO_CHANGE)
     {
@@ -342,13 +456,13 @@ polyMesh::readUpdateState fvMesh::readUpdate()
 }
 
 
-const fvBoundaryMesh& fvMesh::boundary() const
+const Foam::fvBoundaryMesh& Foam::fvMesh::boundary() const
 {
     return boundary_;
 }
 
 
-const lduAddressing& fvMesh::lduAddr() const
+const Foam::lduAddressing& Foam::fvMesh::lduAddr() const
 {
     if (!lduPtr_)
     {
@@ -359,7 +473,7 @@ const lduAddressing& fvMesh::lduAddr() const
 }
 
 
-void fvMesh::mapFields(const mapPolyMesh& meshMap)
+void Foam::fvMesh::mapFields(const mapPolyMesh& meshMap)
 {
     // Create a mapper
     const fvMeshMapper mapper(*this, meshMap);
@@ -438,7 +552,7 @@ void fvMesh::mapFields(const mapPolyMesh& meshMap)
 }
 
 
-tmp<scalarField> fvMesh::movePoints(const pointField& p)
+Foam::tmp<Foam::scalarField> Foam::fvMesh::movePoints(const pointField& p)
 {
     // Grab old time volumes if the time has been incremented
     if (curTimeIndex_ < time().timeIndex())
@@ -525,11 +639,142 @@ tmp<scalarField> fvMesh::movePoints(const pointField& p)
     boundary_.movePoints();
     surfaceInterpolation::movePoints();
 
+
+    // Hack until proper callbacks. Below are all the fvMesh MeshObjects with a
+    // movePoints function.
+
+    // volPointInterpolation
+    if
+    (
+        db().objectRegistry::foundObject<volPointInterpolation>
+        (
+            volPointInterpolation::typeName
+        )
+    )
+    {
+        const_cast<volPointInterpolation&>
+        (
+            db().objectRegistry::lookupObject<volPointInterpolation>
+            (
+                volPointInterpolation::typeName
+            )
+        ).movePoints();
+    }
+
+    // extendedLeastSquaresVectors
+    if
+    (
+        db().objectRegistry::foundObject<extendedLeastSquaresVectors>
+        (
+            extendedLeastSquaresVectors::typeName
+        )
+    )
+    {
+        const_cast<extendedLeastSquaresVectors&>
+        (
+            db().objectRegistry::lookupObject<extendedLeastSquaresVectors>
+            (
+                extendedLeastSquaresVectors::typeName
+            )
+        ).movePoints();
+    }
+
+    // leastSquaresVectors
+    if
+    (
+        db().objectRegistry::foundObject<leastSquaresVectors>
+        (
+            leastSquaresVectors::typeName
+        )
+    )
+    {
+        const_cast<leastSquaresVectors&>
+        (
+            db().objectRegistry::lookupObject<leastSquaresVectors>
+            (
+                leastSquaresVectors::typeName
+            )
+        ).movePoints();
+    }
+
+    //// linearFitData
+    //if
+    //(
+    //    db().objectRegistry::foundObject<linearFitData>
+    //    (
+    //        linearFitData::typeName
+    //    )
+    //)
+    //{
+    //    const_cast<linearFitData&>
+    //    (
+    //        db().objectRegistry::lookupObject<linearFitData>
+    //        (
+    //            linearFitData::typeName
+    //        )
+    //    ).movePoints();
+    //}
+
+    // quadraticFitData
+    if
+    (
+        db().objectRegistry::foundObject<quadraticFitData>
+        (
+            quadraticFitData::typeName
+        )
+    )
+    {
+        const_cast<quadraticFitData&>
+        (
+            db().objectRegistry::lookupObject<quadraticFitData>
+            (
+                quadraticFitData::typeName
+            )
+        ).movePoints();
+    }
+
+    //// quadraticFitSnGradData
+    //if
+    //(
+    //    db().objectRegistry::foundObject<quadraticFitSnGradData>
+    //    (
+    //        quadraticFitSnGradData::typeName
+    //    )
+    //)
+    //{
+    //    const_cast<quadraticFitSnGradData&>
+    //    (
+    //        db().objectRegistry::lookupObject<quadraticFitSnGradData>
+    //        (
+    //            quadraticFitSnGradData::typeName
+    //        )
+    //    ).movePoints();
+    //}
+
+    // skewCorrectionVectors
+    if
+    (
+        db().objectRegistry::foundObject<skewCorrectionVectors>
+        (
+            skewCorrectionVectors::typeName
+        )
+    )
+    {
+        const_cast<skewCorrectionVectors&>
+        (
+            db().objectRegistry::lookupObject<skewCorrectionVectors>
+            (
+                skewCorrectionVectors::typeName
+            )
+        ).movePoints();
+    }
+
+
     return tsweptVols;
 }
 
 
-void fvMesh::updateMesh(const mapPolyMesh& mpm)
+void Foam::fvMesh::updateMesh(const mapPolyMesh& mpm)
 {
     // Update polyMesh. This needs to keep volume existent!
     polyMesh::updateMesh(mpm);
@@ -551,7 +796,7 @@ void fvMesh::updateMesh(const mapPolyMesh& mpm)
 }
 
 
-bool fvMesh::writeObjects
+bool Foam::fvMesh::writeObjects
 (
     IOstream::streamFormat fmt,
     IOstream::versionNumber ver,
@@ -563,7 +808,7 @@ bool fvMesh::writeObjects
 
 
 //- Write mesh using IO settings from the time
-bool fvMesh::write() const
+bool Foam::fvMesh::write() const
 {
     return polyMesh::write();
 }
@@ -571,20 +816,16 @@ bool fvMesh::write() const
 
 // * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
 
-bool fvMesh::operator!=(const fvMesh& bm) const
+bool Foam::fvMesh::operator!=(const fvMesh& bm) const
 {
     return &bm != this;
 }
 
 
-bool fvMesh::operator==(const fvMesh& bm) const
+bool Foam::fvMesh::operator==(const fvMesh& bm) const
 {
     return &bm == this;
 }
 
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
-
 // ************************************************************************* //

From cdb0a8a8d517b26f91a551f3c3af335fa16dd8fb Mon Sep 17 00:00:00 2001
From: mattijs <mattijs@hunt.opencfd.co.uk>
Date: Tue, 21 Oct 2008 14:06:10 +0100
Subject: [PATCH 07/10] iso surface

---
 .../sampledSurface/isoSurface/isoSurface.C    | 291 +++++++++++++++++
 .../sampledSurface/isoSurface/isoSurface.H    | 173 +++++++++++
 .../isoSurface/isoSurfaceTemplates.C          | 292 ++++++++++++++++++
 .../isoSurface/sampledIsoSurface.C            | 204 ++++++++++++
 .../isoSurface/sampledIsoSurface.H            | 232 ++++++++++++++
 .../isoSurface/sampledIsoSurfaceTemplates.C   | 144 +++++++++
 6 files changed, 1336 insertions(+)
 create mode 100644 src/sampling/sampledSurface/isoSurface/isoSurface.C
 create mode 100644 src/sampling/sampledSurface/isoSurface/isoSurface.H
 create mode 100644 src/sampling/sampledSurface/isoSurface/isoSurfaceTemplates.C
 create mode 100644 src/sampling/sampledSurface/isoSurface/sampledIsoSurface.C
 create mode 100644 src/sampling/sampledSurface/isoSurface/sampledIsoSurface.H
 create mode 100644 src/sampling/sampledSurface/isoSurface/sampledIsoSurfaceTemplates.C

diff --git a/src/sampling/sampledSurface/isoSurface/isoSurface.C b/src/sampling/sampledSurface/isoSurface/isoSurface.C
new file mode 100644
index 0000000000..45be2c1334
--- /dev/null
+++ b/src/sampling/sampledSurface/isoSurface/isoSurface.C
@@ -0,0 +1,291 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 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, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+\*---------------------------------------------------------------------------*/
+
+#include "isoSurface.H"
+#include "dictionary.H"
+#include "polyMesh.H"
+#include "volFields.H"
+#include "mergePoints.H"
+#include "tetMatcher.H"
+
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(isoSurface, 0);
+}
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::isoSurface::isoSurface
+(
+    const polyMesh& mesh,
+    const scalarField& cellValues,
+    const scalarField& pointValues,
+    const scalar iso
+)
+:
+    mesh_(mesh),
+    cellValues_(cellValues),
+    pointValues_(pointValues),
+    iso_(iso)
+{
+    const pointField& cellCentres = mesh.cellCentres();
+
+    tetMatcher tet;
+
+    DynamicList<point> triPoints;
+    DynamicList<label> triMeshCells;
+
+    forAll(mesh.cells(), cellI)
+    {
+        label oldNPoints = triPoints.size();
+
+        const cell& cFaces = mesh.cells()[cellI];
+
+        if (tet.isA(mesh, cellI))
+        {
+            // For tets don't do cell-centre decomposition, just use the
+            // tet points and values
+
+            const face& f0 = mesh.faces()[cFaces[0]];
+
+            // Get the other point
+            const face& f1 = mesh.faces()[cFaces[1]];
+            label oppositeI = -1;
+            forAll(f1, fp)
+            {
+                oppositeI = f1[fp];
+
+                if (findIndex(f0, oppositeI) == -1)
+                {
+                    break;
+                }
+            }
+
+            vertexInterp
+            (
+                iso,
+                pointValues[f0[0]],
+                pointValues[f0[1]],
+                pointValues[f0[2]],
+                pointValues[oppositeI],
+
+                mesh.points()[f0[0]],
+                mesh.points()[f0[1]],
+                mesh.points()[f0[2]],
+                mesh.points()[oppositeI],
+
+                triPoints
+            );
+        }
+        else
+        {
+            const cell& cFaces = mesh.cells()[cellI];
+
+            forAll(cFaces, cFaceI)
+            {
+                label faceI = cFaces[cFaceI];
+                const face& f = mesh.faces()[faceI];
+
+                // Do a tetrahedrisation. Each face to cc becomes pyr.
+                // Each pyr gets split into two tets by diagionalisation
+                // of face. So
+                // - f[0], f[1], f[2], cc
+                // - f[0], f[2], f[3], cc
+
+                for(label fp = 1; fp < f.size() - 1; fp++)
+                {
+                    vertexInterp
+                    (
+                        iso,
+                        pointValues[f[0]],
+                        pointValues[f[fp]],
+                        pointValues[f[f.fcIndex(fp)]],
+                        cellValues[cellI],
+
+                        mesh.points()[f[0]],
+                        mesh.points()[f[fp]],
+                        mesh.points()[f[f.fcIndex(fp)]],
+                        cellCentres[cellI],
+
+                        triPoints
+                    );
+                }
+            }
+        }
+
+
+        // Every three triPoints is a cell
+        label nCells = (triPoints.size()-oldNPoints)/3;
+        for (label i = 0; i < nCells; i++)
+        {
+            triMeshCells.append(cellI);
+        }
+    }
+
+    triPoints.shrink();
+    triMeshCells.shrink();
+    meshCells_.transfer(triMeshCells);
+
+    pointField newPoints;
+    mergePoints(triPoints, SMALL, false, triPointMergeMap_, newPoints);
+
+    DynamicList<labelledTri> tris(meshCells_.size());
+    forAll(meshCells_, triI)
+    {
+        tris.append
+        (
+            labelledTri
+            (
+                triPointMergeMap_[3*triI],
+                triPointMergeMap_[3*triI+1],
+                triPointMergeMap_[3*triI+2],
+                0
+            )
+        );
+    }
+
+    //- 1.5.x:
+    //tris.shrink();
+    //triSurface::operator=
+    //(
+    //    triSurface(tris, geometricSurfacePatchList(0), newPoints)
+    //);
+
+    triSurface::operator=
+    (
+        triSurface(tris, geometricSurfacePatchList(0), newPoints, true)
+    );
+}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+//Foam::tmp<Foam::scalarField>
+//Foam::isoSurface::sample
+//(
+//    const volScalarField& vField
+//) const
+//{
+//    return sampleField(vField);
+//}
+//
+//
+//Foam::tmp<Foam::vectorField>
+//Foam::isoSurface::sample
+//(
+//    const volVectorField& vField
+//) const
+//{
+//    return sampleField(vField);
+//}
+//
+//Foam::tmp<Foam::sphericalTensorField>
+//Foam::isoSurface::sample
+//(
+//    const volSphericalTensorField& vField
+//) const
+//{
+//    return sampleField(vField);
+//}
+//
+//
+//Foam::tmp<Foam::symmTensorField>
+//Foam::isoSurface::sample
+//(
+//    const volSymmTensorField& vField
+//) const
+//{
+//    return sampleField(vField);
+//}
+//
+//
+//Foam::tmp<Foam::tensorField>
+//Foam::isoSurface::sample
+//(
+//    const volTensorField& vField
+//) const
+//{
+//    return sampleField(vField);
+//}
+//
+//
+//Foam::tmp<Foam::scalarField>
+//Foam::isoSurface::interpolate
+//(
+//    const interpolation<scalar>& interpolator
+//) const
+//{
+//    return interpolateField(interpolator);
+//}
+//
+//
+//Foam::tmp<Foam::vectorField>
+//Foam::isoSurface::interpolate
+//(
+//    const interpolation<vector>& interpolator
+//) const
+//{
+//    return interpolateField(interpolator);
+//}
+//
+//Foam::tmp<Foam::sphericalTensorField>
+//Foam::isoSurface::interpolate
+//(
+//    const interpolation<sphericalTensor>& interpolator
+//) const
+//{
+//    return interpolateField(interpolator);
+//}
+//
+//
+//Foam::tmp<Foam::symmTensorField>
+//Foam::isoSurface::interpolate
+//(
+//    const interpolation<symmTensor>& interpolator
+//) const
+//{
+//    return interpolateField(interpolator);
+//}
+//
+//
+//Foam::tmp<Foam::tensorField>
+//Foam::isoSurface::interpolate
+//(
+//    const interpolation<tensor>& interpolator
+//) const
+//{
+//    return interpolateField(interpolator);
+//}
+
+
+// ************************************************************************* //
diff --git a/src/sampling/sampledSurface/isoSurface/isoSurface.H b/src/sampling/sampledSurface/isoSurface/isoSurface.H
new file mode 100644
index 0000000000..ddd6854909
--- /dev/null
+++ b/src/sampling/sampledSurface/isoSurface/isoSurface.H
@@ -0,0 +1,173 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 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, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Class
+    Foam::isoSurface
+
+Description
+    A surface formed by the iso value.
+    After "Polygonising A Scalar Field Using Tetrahedrons", Paul Bourke
+
+SourceFiles
+    isoSurface.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef isoSurface_H
+#define isoSurface_H
+
+#include "triSurface.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+class polyMesh;
+
+/*---------------------------------------------------------------------------*\
+                       Class isoSurface Declaration
+\*---------------------------------------------------------------------------*/
+
+class isoSurface
+:
+    public triSurface
+{
+    // Private data
+
+        //- Reference to mesh
+        const polyMesh& mesh_;
+
+        //- Reference to cell values
+        const scalarField& cellValues_;
+
+        //- Reference to point values
+        const scalarField& pointValues_;
+
+        //- Isosurface value
+        const scalar iso_;
+
+
+        //- For every triangle the original cell in mesh
+        labelList meshCells_;
+
+        //- For every unmerged triangle point the point in the triSurface
+        labelList triPointMergeMap_;
+
+
+    // Private Member Functions
+
+        template<class T>
+        static T vertexInterp
+        (
+            const scalar iso,
+            const T& p0,
+            const T& p1,
+            const scalar s0,
+            const scalar s1
+        );
+
+        template<class T>
+        static void vertexInterp
+        (
+            const scalar iso,
+            const scalar s0,
+            const scalar s1,
+            const scalar s2,
+            const scalar s3,
+
+            const T& p0,
+            const T& p1,
+            const T& p2,
+            const T& p3,
+
+            DynamicList<T>& points
+        );
+
+public:
+
+    //- Runtime type information
+    TypeName("isoSurface");
+
+
+    // Constructors
+
+        //- Construct from dictionary
+        isoSurface
+        (
+            const polyMesh& mesh,
+            const scalarField& cellValues,
+            const scalarField& pointValues,
+            const scalar iso
+        );
+
+
+    // Member Functions
+
+        //- For every face original cell in mesh
+        const labelList& meshCells() const
+        {
+            return meshCells_;
+        }
+
+        //- For every unmerged triangle point the point in the triSurface
+        const labelList triPointMergeMap() const
+        {
+            return triPointMergeMap_;
+        }
+
+
+        //- sample field on faces
+        template <class Type>
+        tmp<Field<Type> > sample
+        (
+            const Field<Type>& sampleCellValues
+        ) const;
+
+        //- interpolate field to points
+        template <class Type>
+        tmp<Field<Type> >
+        interpolate
+        (
+            const Field<Type>& sampleCellValues,
+            const Field<Type>& samplePointValues
+        ) const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+#   include "isoSurfaceTemplates.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/sampling/sampledSurface/isoSurface/isoSurfaceTemplates.C b/src/sampling/sampledSurface/isoSurface/isoSurfaceTemplates.C
new file mode 100644
index 0000000000..e1500ca6e5
--- /dev/null
+++ b/src/sampling/sampledSurface/isoSurface/isoSurfaceTemplates.C
@@ -0,0 +1,292 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 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, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+\*---------------------------------------------------------------------------*/
+
+#include "isoSurface.H"
+#include "polyMesh.H"
+#include "tetMatcher.H"
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+template<class Type>
+Type Foam::isoSurface::vertexInterp
+(
+    const scalar iso,
+    const Type& p0,
+    const Type& p1,
+    const scalar s0,
+    const scalar s1
+)
+{
+    scalar d = s1-s0;
+
+    if (mag(d) > VSMALL)
+    {
+        return (iso-s0)/d*p1 + (s1-iso)/d*p0;
+    }
+    else
+    {
+        return 0.5*(p0+p1);
+    }
+}
+
+
+// After "Polygonising A Scalar Field Using Tetrahedrons"
+// by Paul Bourke
+// Get value consistent with uncompacted triangle points.
+// Given tet corner sample values s0..s3 interpolate the corresponding
+// values p0..p3 to construct the surface corresponding to sample value iso.
+template<class Type>
+void Foam::isoSurface::vertexInterp
+(
+    const scalar iso,
+    const scalar s0,
+    const scalar s1,
+    const scalar s2,
+    const scalar s3,
+
+    const Type& p0,
+    const Type& p1,
+    const Type& p2,
+    const Type& p3,
+
+    DynamicList<Type>& points
+)
+{
+    int triIndex = 0;
+    if (s0 < iso)
+    {
+        triIndex |= 1;
+    }
+    if (s1 < iso)
+    {
+        triIndex |= 2;
+    }
+    if (s2 < iso)
+    {
+        triIndex |= 4;
+    }
+    if (s3 < iso)
+    {
+        triIndex |= 8;
+    }
+
+    /* Form the vertices of the triangles for each case */
+    switch (triIndex)
+    {
+        case 0x00:
+        case 0x0F:
+        break;
+
+        case 0x0E:
+        case 0x01:
+            points.append(vertexInterp(iso,p0,p1,s0,s1));
+            points.append(vertexInterp(iso,p0,p2,s0,s2));
+            points.append(vertexInterp(iso,p0,p3,s0,s3));
+        break;
+
+        case 0x0D:
+        case 0x02:
+            points.append(vertexInterp(iso,p1,p0,s1,s0));
+            points.append(vertexInterp(iso,p1,p3,s1,s3));
+            points.append(vertexInterp(iso,p1,p2,s1,s2));
+        break;
+
+        case 0x0C:
+        case 0x03:
+        {
+            const Type tp1 = vertexInterp(iso,p0,p2,s0,s2);
+            const Type tp2 = vertexInterp(iso,p1,p3,s1,s3);
+
+            points.append(vertexInterp(iso,p0,p3,s0,s3));
+            points.append(tp1);
+            points.append(tp2);
+            points.append(tp2);
+            points.append(vertexInterp(iso,p1,p2,s1,s2));
+            points.append(tp1);
+        }
+        break;
+
+        case 0x0B:
+        case 0x04:
+        {
+            points.append(vertexInterp(iso,p2,p0,s2,s0));
+            points.append(vertexInterp(iso,p2,p1,s2,s1));
+            points.append(vertexInterp(iso,p2,p3,s2,s3));
+        }
+        break;
+
+        case 0x0A:
+        case 0x05:
+        {
+            const Type tp0 = vertexInterp(iso,p0,p1,s0,s1);
+            const Type tp1 = vertexInterp(iso,p2,p3,s2,s3);
+
+            points.append(tp0);
+            points.append(tp1);
+            points.append(vertexInterp(iso,p0,p3,s0,s3));
+            points.append(tp0);
+            points.append(vertexInterp(iso,p1,p2,s1,s2));
+            points.append(tp1);
+        }
+        break;
+
+        case 0x09:
+        case 0x06:
+        {
+            const Type tp0 = vertexInterp(iso,p0,p1,s0,s1);
+            const Type tp1 = vertexInterp(iso,p2,p3,s2,s3);
+
+            points.append(tp0);
+            points.append(vertexInterp(iso,p1,p3,s1,s3));
+            points.append(tp1);
+            points.append(tp0);
+            points.append(vertexInterp(iso,p0,p2,s0,s2));
+            points.append(tp1);
+        }
+        break;
+
+        case 0x07:
+        case 0x08:
+            points.append(vertexInterp(iso,p3,p0,s3,s0));
+            points.append(vertexInterp(iso,p3,p2,s3,s2));
+            points.append(vertexInterp(iso,p3,p1,s3,s1));
+        break;
+    }
+}
+
+
+template <class Type>
+Foam::tmp<Foam::Field<Type> >
+Foam::isoSurface::sample(const Field<Type>& vField) const
+{
+    return tmp<Field<Type> >(new Field<Type>(vField, meshCells()));
+}
+
+
+template <class Type>
+Foam::tmp<Foam::Field<Type> >
+Foam::isoSurface::interpolate
+(
+    const Field<Type>& sampleCellValues,
+    const Field<Type>& samplePointValues
+) const
+{
+    tetMatcher tet;
+
+    DynamicList<Type> triValues;
+
+    // Note: in same order as construction of triSurface
+    label oldCellI = -1;
+    forAll(meshCells_, triI)
+    {
+        label cellI = meshCells_[triI];
+
+        if (cellI != oldCellI)
+        {
+            oldCellI = cellI;
+
+            const cell& cFaces = mesh_.cells()[cellI];
+
+            if (tet.isA(mesh_, cellI))
+            {
+                // For tets don't do cell-centre decomposition, just use the
+                // tet points and values
+
+                const face& f0 = mesh_.faces()[cFaces[0]];
+
+                // Get the other point
+                const face& f1 = mesh_.faces()[cFaces[1]];
+                label oppositeI = -1;
+                forAll(f1, fp)
+                {
+                    oppositeI = f1[fp];
+
+                    if (findIndex(f0, oppositeI) == -1)
+                    {
+                        break;
+                    }
+                }
+
+                vertexInterp
+                (
+                    iso_,
+                    pointValues_[f0[0]],
+                    pointValues_[f0[1]],
+                    pointValues_[f0[2]],
+                    pointValues_[oppositeI],
+
+                    samplePointValues[f0[0]],
+                    samplePointValues[f0[1]],
+                    samplePointValues[f0[2]],
+                    samplePointValues[oppositeI],
+
+                    triValues
+                );
+            }
+            else
+            {
+                forAll(cFaces, cFaceI)
+                {
+                    label faceI = cFaces[cFaceI];
+                    const face& f = mesh_.faces()[faceI];
+
+                    for(label fp = 1; fp < f.size() - 1; fp++)
+                    {
+                        vertexInterp
+                        (
+                            iso_,
+                            pointValues_[f[0]],
+                            pointValues_[f[fp]],
+                            pointValues_[f[f.fcIndex(fp)]],
+                            cellValues_[cellI],
+
+                            samplePointValues[f[0]],
+                            samplePointValues[f[fp]],
+                            samplePointValues[f[f.fcIndex(fp)]],
+                            sampleCellValues[cellI],
+
+                            triValues
+                        );
+                    }
+                }
+            }
+        }
+    }
+
+    // One value per point
+    tmp<Field<Type> > tvalues(new Field<Type>(points().size()));
+    Field<Type>& values = tvalues();
+
+    forAll(triValues, i)
+    {
+        values[triPointMergeMap_[i]] = triValues[i];
+    }
+
+    return tvalues;
+}
+
+
+// ************************************************************************* //
diff --git a/src/sampling/sampledSurface/isoSurface/sampledIsoSurface.C b/src/sampling/sampledSurface/isoSurface/sampledIsoSurface.C
new file mode 100644
index 0000000000..53344e6282
--- /dev/null
+++ b/src/sampling/sampledSurface/isoSurface/sampledIsoSurface.C
@@ -0,0 +1,204 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 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, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+\*---------------------------------------------------------------------------*/
+
+#include "sampledIsoSurface.H"
+#include "dictionary.H"
+#include "volFields.H"
+#include "volPointInterpolation.H"
+#include "addToRunTimeSelectionTable.H"
+#include "fvMesh.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(sampledIsoSurface, 0);
+    addNamedToRunTimeSelectionTable(sampledSurface, sampledIsoSurface, word, isoSurface);
+}
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::sampledIsoSurface::sampledIsoSurface
+(
+    const word& name,
+    const polyMesh& mesh,
+    const dictionary& dict
+)
+:
+    sampledSurface(name, mesh, dict),
+    isoField_(dict.lookup("isoField")),
+    isoVal_(readScalar(dict.lookup("isoValue"))),
+    zoneName_(word::null),
+    facesPtr_(NULL),
+    storedTimeIndex_(-1),
+    meshCells_(0),
+    triPointMergeMap_(0)
+{
+//    label zoneId = -1;
+//    if (dict.readIfPresent("zone", zoneName_))
+//    {
+//        zoneId = mesh.cellZones().findZoneID(zoneName_);
+//        if (debug && zoneId < 0)
+//        {
+//            Info<< "cellZone \"" << zoneName_
+//                << "\" not found - using entire mesh"
+//                << endl;
+//        }
+//    }
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::sampledIsoSurface::~sampledIsoSurface()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+void Foam::sampledIsoSurface::correct(const bool meshChanged)
+{
+    // Only change of mesh changes plane - zone restriction gets lost
+    if (meshChanged)
+    {
+        facesPtr_.clear();
+    }
+}
+
+
+Foam::tmp<Foam::scalarField>
+Foam::sampledIsoSurface::sample
+(
+    const volScalarField& vField
+) const
+{
+    return sampleField(vField);
+}
+
+
+Foam::tmp<Foam::vectorField>
+Foam::sampledIsoSurface::sample
+(
+    const volVectorField& vField
+) const
+{
+    return sampleField(vField);
+}
+
+
+Foam::tmp<Foam::sphericalTensorField>
+Foam::sampledIsoSurface::sample
+(
+    const volSphericalTensorField& vField
+) const
+{
+    return sampleField(vField);
+}
+
+
+Foam::tmp<Foam::symmTensorField>
+Foam::sampledIsoSurface::sample
+(
+    const volSymmTensorField& vField
+) const
+{
+    return sampleField(vField);
+}
+
+
+Foam::tmp<Foam::tensorField>
+Foam::sampledIsoSurface::sample
+(
+    const volTensorField& vField
+) const
+{
+    return sampleField(vField);
+}
+
+
+Foam::tmp<Foam::scalarField>
+Foam::sampledIsoSurface::interpolate
+(
+    const interpolation<scalar>& interpolator
+) const
+{
+    return interpolateField(interpolator);
+}
+
+
+Foam::tmp<Foam::vectorField>
+Foam::sampledIsoSurface::interpolate
+(
+    const interpolation<vector>& interpolator
+) const
+{
+    return interpolateField(interpolator);
+}
+
+Foam::tmp<Foam::sphericalTensorField>
+Foam::sampledIsoSurface::interpolate
+(
+    const interpolation<sphericalTensor>& interpolator
+) const
+{
+    return interpolateField(interpolator);
+}
+
+
+Foam::tmp<Foam::symmTensorField>
+Foam::sampledIsoSurface::interpolate
+(
+    const interpolation<symmTensor>& interpolator
+) const
+{
+    return interpolateField(interpolator);
+}
+
+
+Foam::tmp<Foam::tensorField>
+Foam::sampledIsoSurface::interpolate
+(
+    const interpolation<tensor>& interpolator
+) const
+{
+    return interpolateField(interpolator);
+}
+
+
+void Foam::sampledIsoSurface::print(Ostream& os) const
+{
+    os  << "sampledIsoSurface: " << name() << " :"
+        << "  field:" << isoField_
+        << "  value:" << isoVal_
+        << "  faces:" << faces().size()
+        << "  points:" << points().size();
+}
+
+
+// ************************************************************************* //
diff --git a/src/sampling/sampledSurface/isoSurface/sampledIsoSurface.H b/src/sampling/sampledSurface/isoSurface/sampledIsoSurface.H
new file mode 100644
index 0000000000..57445082f6
--- /dev/null
+++ b/src/sampling/sampledSurface/isoSurface/sampledIsoSurface.H
@@ -0,0 +1,232 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 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, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Class
+    Foam::sampledIsoSurface
+
+Description
+    A sampledSurface defined by a surface of iso value. Always triangulated.
+    To be used in sampleSurfaces / functionObjects. Recalculates iso surface
+    only if time changes.
+
+SourceFiles
+    sampledIsoSurface.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef sampledIsoSurface_H
+#define sampledIsoSurface_H
+
+#include "sampledSurface.H"
+#include "triSurface.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                       Class sampledIsoSurface Declaration
+\*---------------------------------------------------------------------------*/
+
+class sampledIsoSurface
+:
+    public sampledSurface,
+    public triSurface
+{
+    // Private data
+
+        //- Field to get isoSurface of
+        word isoField_;
+
+        //- iso value
+        scalar isoVal_;
+
+        //- zone name (if restricted to zones)
+        word zoneName_;
+
+        //- triangles converted to faceList
+        mutable autoPtr<faceList> facesPtr_;
+
+
+        // Recreated for every isoSurface
+
+            //- Time at last call
+            mutable label storedTimeIndex_;
+
+            //- For every triangle the original cell in mesh
+            mutable labelList meshCells_;
+
+            //- For every unmerged triangle point the point in the triSurface
+            mutable labelList triPointMergeMap_;
+
+
+    // Private Member Functions
+
+        //- sample field on faces
+        template <class Type>
+        tmp<Field<Type> > sampleField
+        (
+            const GeometricField<Type, fvPatchField, volMesh>& vField
+        ) const;
+
+
+        template <class Type>
+        tmp<Field<Type> >
+        interpolateField(const interpolation<Type>&) const;
+
+
+public:
+
+    //- Runtime type information
+    TypeName("sampledIsoSurface");
+
+
+    // Constructors
+
+        //- Construct from dictionary
+        sampledIsoSurface
+        (
+            const word& name,
+            const polyMesh& mesh,
+            const dictionary& dict
+        );
+
+
+    // Destructor
+
+        virtual ~sampledIsoSurface();
+
+
+    // Member Functions
+
+        //- Points of surface
+        virtual const pointField& points() const
+        {
+            return triSurface::points();
+        }
+
+        //- Faces of surface
+        virtual const faceList& faces() const
+        {
+            if (!facesPtr_.valid())
+            {
+                const triSurface& s = *this;
+
+                facesPtr_.reset(new faceList(s.size()));
+
+                forAll(s, i)
+                {
+                    facesPtr_()[i] = s[i].triFaceFace();
+                }
+            }
+            return facesPtr_;
+        }
+
+
+        //- Correct for mesh movement and/or field changes
+        virtual void correct(const bool meshChanged);
+
+
+        //- sample field on surface
+        virtual tmp<scalarField> sample
+        (
+            const volScalarField&
+        ) const;
+
+        //- sample field on surface
+        virtual tmp<vectorField> sample
+        (
+            const volVectorField&
+        ) const;
+
+        //- sample field on surface
+        virtual tmp<sphericalTensorField> sample
+        (
+            const volSphericalTensorField&
+        ) const;
+
+        //- sample field on surface
+        virtual tmp<symmTensorField> sample
+        (
+            const volSymmTensorField&
+        ) const;
+
+        //- sample field on surface
+        virtual tmp<tensorField> sample
+        (
+            const volTensorField&
+        ) const;
+
+
+        //- interpolate field on surface
+        virtual tmp<scalarField> interpolate
+        (
+            const interpolation<scalar>&
+        ) const;
+
+        //- interpolate field on surface
+        virtual tmp<vectorField> interpolate
+        (
+            const interpolation<vector>&
+        ) const;
+
+        //- interpolate field on surface
+        virtual tmp<sphericalTensorField> interpolate
+        (
+            const interpolation<sphericalTensor>&
+        ) const;
+
+        //- interpolate field on surface
+        virtual tmp<symmTensorField> interpolate
+        (
+            const interpolation<symmTensor>&
+        ) const;
+
+        //- interpolate field on surface
+        virtual tmp<tensorField> interpolate
+        (
+            const interpolation<tensor>&
+        ) const;
+
+        //- Write
+        virtual void print(Ostream&) const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+#   include "sampledIsoSurfaceTemplates.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/sampling/sampledSurface/isoSurface/sampledIsoSurfaceTemplates.C b/src/sampling/sampledSurface/isoSurface/sampledIsoSurfaceTemplates.C
new file mode 100644
index 0000000000..755fc95939
--- /dev/null
+++ b/src/sampling/sampledSurface/isoSurface/sampledIsoSurfaceTemplates.C
@@ -0,0 +1,144 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 1991-2008 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 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, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+\*---------------------------------------------------------------------------*/
+
+#include "sampledIsoSurface.H"
+#include "isoSurface.H"
+#include "volFieldsFwd.H"
+#include "pointFields.H"
+#include "volPointInterpolation.H"
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+template <class Type>
+Foam::tmp<Foam::Field<Type> >
+Foam::sampledIsoSurface::sampleField
+(
+    const GeometricField<Type, fvPatchField, volMesh>& vField
+) const
+{
+    const fvMesh& fvm = vField.mesh();
+
+    if (fvm.time().timeIndex() != storedTimeIndex_)
+    {
+        storedTimeIndex_ = fvm.time().timeIndex();
+
+        //- Clear any stored topo
+        facesPtr_.clear();
+
+        const volScalarField& cellFld =
+            fvm.lookupObject<volScalarField>(isoField_);
+
+        tmp<pointScalarField> pointFld
+        (
+            volPointInterpolation::New(fvm).interpolate(cellFld)
+        );
+
+        const isoSurface iso
+        (
+            fvm,
+            cellFld.internalField(),
+            pointFld().internalField(),
+            isoVal_
+        );
+
+        const_cast<sampledIsoSurface&>(*this).triSurface::operator=(iso);
+        meshCells_ = iso.meshCells();
+        triPointMergeMap_ = iso.triPointMergeMap();
+    }
+
+    return tmp<Field<Type> >(new Field<Type>(vField, meshCells_));
+}
+
+
+template <class Type>
+Foam::tmp<Foam::Field<Type> >
+Foam::sampledIsoSurface::interpolateField
+(
+    const interpolation<Type>& interpolator
+) const
+{
+    const fvMesh& fvm = static_cast<const fvMesh&>(mesh());
+
+    if (fvm.time().timeIndex() != storedTimeIndex_)
+    {
+        //- Clear any stored topo
+        facesPtr_.clear();
+
+        storedTimeIndex_ = fvm.time().timeIndex();
+
+        const volScalarField& cellFld =
+            fvm.lookupObject<volScalarField>(isoField_);
+
+        tmp<pointScalarField> pointFld
+        (
+            volPointInterpolation::New(fvm).interpolate(cellFld)
+        );
+
+        const isoSurface iso
+        (
+            fvm,
+            cellFld.internalField(),
+            pointFld().internalField(),
+            isoVal_
+        );
+
+        const_cast<sampledIsoSurface&>(*this).triSurface::operator=(iso);
+        meshCells_ = iso.meshCells();
+        triPointMergeMap_ = iso.triPointMergeMap();
+    }
+
+
+    // One value per point
+    tmp<Field<Type> > tvalues(new Field<Type>(points().size()));
+    Field<Type>& values = tvalues();
+
+    boolList pointDone(points().size(), false);
+
+    forAll(faces(), cutFaceI)
+    {
+        const face& f = faces()[cutFaceI];
+
+        forAll(f, faceVertI)
+        {
+            label pointI = f[faceVertI];
+
+            if (!pointDone[pointI])
+            {
+                values[pointI] = interpolator.interpolate
+                (
+                    points()[pointI],
+                    meshCells_[cutFaceI]
+                );
+                pointDone[pointI] = true;
+            }
+        }
+    }
+
+    return tvalues;
+}
+
+
+// ************************************************************************* //

From 99e8bf7516a8c4ffee8134286fc83f65dd088521 Mon Sep 17 00:00:00 2001
From: mattijs <mattijs@hunt.opencfd.co.uk>
Date: Tue, 21 Oct 2008 15:02:04 +0100
Subject: [PATCH 08/10] volPointInterpolation, pointMesh now MeshObject

---
 .../kinematicParcelFoam/createFields.H        |  4 -
 .../combustion/dieselEngineFoam/createSpray.H |  4 -
 .../dieselEngineFoam/dieselEngineFoam.C       |  6 +-
 .../manipulation/deformedGeom/deformedGeom.C  |  3 +-
 .../foamToFieldview9/foamToFieldview9.C       |  3 +-
 .../dataConversion/foamToVTK/foamToVTK.C      | 12 +--
 .../dataConversion/foamToVTK/vtkMesh.C        |  1 -
 .../dataConversion/foamToVTK/vtkMesh.H        | 28 +------
 .../vtkPV3Foam/vtkPV3FoamFields.C             |  3 +-
 src/OpenFOAM/meshes/pointMesh/pointMesh.C     |  7 +-
 src/OpenFOAM/meshes/pointMesh/pointMesh.H     | 12 ++-
 src/OpenFOAM/meshes/polyMesh/polyMeshClear.C  |  6 ++
 src/OpenFOAM/meshes/polyMesh/polyMeshUpdate.C | 21 +++++
 .../autoHexMeshDriver/autoHexMeshDriver.C     |  1 -
 .../autoHexMeshDriver/autoLayerDriver.C       |  2 +-
 .../autoHexMeshDriver/autoLayerDriverShrink.C |  8 +-
 .../autoHexMeshDriver/autoSnapDriver.C        |  4 +-
 .../meshRefinement/meshRefinement.C           |  2 +-
 .../fvMesh/fvMeshSubset/fvMeshSubset.C        | 22 -----
 .../fvMesh/fvMeshSubset/fvMeshSubset.H        |  7 --
 .../fvMeshSubset/fvMeshSubsetInterpolate.C    |  2 +-
 .../interpolation/interpolation.H             |  6 +-
 .../interpolation/newInterpolation.C          |  6 +-
 .../interpolationCell/interpolationCell.C     |  1 -
 .../interpolationCell/interpolationCell.H     |  1 -
 .../interpolationCellPoint.C                  |  3 +-
 .../interpolationCellPoint.H                  |  4 +-
 .../interpolationCellPointFace.C              |  3 +-
 .../interpolationCellPointFace.H              |  8 +-
 .../pointPatchInterpolate.C                   |  2 +-
 .../pointPatchInterpolation.C                 | 13 +--
 .../pointPatchInterpolation.H                 |  8 +-
 .../volPointInterpolate.C                     | 10 ++-
 .../volPointInterpolation.C                   | 11 +--
 .../volPointInterpolation.H                   | 10 +--
 .../displacementSBRStressFvMotionSolver.C     |  9 ++-
 ...lacementComponentLaplacianFvMotionSolver.C | 11 ++-
 .../displacementInterpolationFvMotionSolver.C |  3 +-
 .../displacementLaplacianFvMotionSolver.C     | 11 ++-
 .../fvMotionSolver/fvMotionSolver.C           | 11 +--
 .../fvMotionSolver/fvMotionSolver.H           | 12 +--
 ...velocityComponentLaplacianFvMotionSolver.C |  9 ++-
 .../velocityLaplacianFvMotionSolver.C         |  9 ++-
 .../inversePointDistanceDiffusivity.C         |  5 +-
 src/lagrangian/basic/Cloud/Cloud.H            | 18 ++---
 src/lagrangian/basic/Cloud/CloudIO.C          | 50 +++++-------
 src/lagrangian/dieselSpray/parcel/parcelIO.C  | 68 +++++++++-------
 src/lagrangian/dieselSpray/spray/spray.C      |  4 +-
 src/lagrangian/dieselSpray/spray/spray.H      |  3 -
 src/lagrangian/dieselSpray/spray/sprayOps.C   | 28 +------
 .../Templates/KinematicCloud/KinematicCloud.C | 10 +--
 .../Templates/KinematicCloud/KinematicCloud.H |  8 --
 .../KinematicCloud/KinematicCloudI.H          |  8 --
 .../Templates/ReactingCloud/ReactingCloud.C   | 11 +--
 .../Templates/ReactingCloud/ReactingCloud.H   |  1 -
 .../Templates/ThermoCloud/ThermoCloud.C       |  7 --
 .../Templates/ThermoCloud/ThermoCloud.H       |  1 -
 .../basicKinematicCloud/basicKinematicCloud.C |  3 +-
 .../basicKinematicCloud/basicKinematicCloud.H |  1 -
 .../basicReactingCloud/basicReactingCloud.C   |  2 -
 .../basicReactingCloud/basicReactingCloud.H   |  1 -
 .../basicThermoCloud/basicThermoCloud.C       |  3 +-
 .../basicThermoCloud/basicThermoCloud.H       |  1 -
 .../KinematicParcel/KinematicParcelIO.C       | 34 ++++----
 .../ReactingParcel/ReactingParcelIO.C         | 45 ++++++++---
 .../Templates/ThermoParcel/ThermoParcelIO.C   |  8 +-
 .../molecule/molecule/moleculeIO.C            | 35 +++++---
 .../solidParticle/solidParticleCloud.C        | 10 +--
 .../solidParticle/solidParticleIO.C           |  8 +-
 src/meshTools/PointEdgeWave/PointEdgeWave.C   | 80 +++++++++----------
 src/meshTools/PointEdgeWave/PointEdgeWave.H   |  7 +-
 .../meshToMesh/meshToMesh.C                   |  2 -
 .../meshToMesh/meshToMesh.H                   |  4 -
 .../meshToMesh/meshToMeshInterpolate.C        |  9 +--
 .../sampledSet/sampledSets/sampledSets.C      | 12 +--
 .../sampledSet/sampledSets/sampledSets.H      |  8 --
 .../sampledSets/sampledSetsTemplates.C        | 13 +--
 .../sampledSurfaces/sampledSurfaces.C         |  9 +--
 .../sampledSurfaces/sampledSurfaces.H         | 18 +----
 .../sampledSurfacesTemplates.C                | 30 ++-----
 .../rhoTurbTwinParcelFoam/createFields.H      |  5 --
 81 files changed, 371 insertions(+), 518 deletions(-)

diff --git a/applications/solvers/Lagrangian/kinematicParcelFoam/createFields.H b/applications/solvers/Lagrangian/kinematicParcelFoam/createFields.H
index 6b87262133..c5a992817f 100644
--- a/applications/solvers/Lagrangian/kinematicParcelFoam/createFields.H
+++ b/applications/solvers/Lagrangian/kinematicParcelFoam/createFields.H
@@ -46,9 +46,6 @@
         )
     );
 
-    pointMesh pMesh(mesh);
-    volPointInterpolation vpi(mesh, pMesh);
-
     word kinematicCloudName("kinematicCloud");
 
     if (args.options().found("cloudName"))
@@ -60,7 +57,6 @@
     basicKinematicCloud kinematicCloud
     (
         kinematicCloudName,
-        vpi,
         rho,
         U,
         thermo().mu(),
diff --git a/applications/solvers/combustion/dieselEngineFoam/createSpray.H b/applications/solvers/combustion/dieselEngineFoam/createSpray.H
index c5bc0d88cf..b86b3684c2 100644
--- a/applications/solvers/combustion/dieselEngineFoam/createSpray.H
+++ b/applications/solvers/combustion/dieselEngineFoam/createSpray.H
@@ -1,8 +1,5 @@
 Info << "Constructing Spray" << endl;
 
-pointMesh pMesh(mesh);
-volPointInterpolation vpi(mesh, pMesh);
-
 PtrList<specieProperties> gasProperties(Y.size());
 forAll(gasProperties, i)
 {
@@ -18,7 +15,6 @@ forAll(gasProperties, i)
 
 spray dieselSpray
 (
-    vpi,
     U,
     rho,
     p,
diff --git a/applications/solvers/combustion/dieselEngineFoam/dieselEngineFoam.C b/applications/solvers/combustion/dieselEngineFoam/dieselEngineFoam.C
index b6cfb46d92..f579825384 100644
--- a/applications/solvers/combustion/dieselEngineFoam/dieselEngineFoam.C
+++ b/applications/solvers/combustion/dieselEngineFoam/dieselEngineFoam.C
@@ -41,6 +41,7 @@ Description
 #include "multivariateScheme.H"
 #include "Switch.H"
 #include "OFstream.H"
+#include "volPointInterpolation.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -75,7 +76,10 @@ int main(int argc, char *argv[])
         Info<< "Crank angle = " << runTime.theta() << " CA-deg" << endl;
 
         mesh.move();
-        vpi.updateMesh();
+        const_cast<volPointInterpolation&>
+        (
+            volPointInterpolation::New(mesh)
+        ).updateMesh();
 
         dieselSpray.evolve();
 
diff --git a/applications/utilities/mesh/manipulation/deformedGeom/deformedGeom.C b/applications/utilities/mesh/manipulation/deformedGeom/deformedGeom.C
index 3246c1d335..06586f4a8f 100644
--- a/applications/utilities/mesh/manipulation/deformedGeom/deformedGeom.C
+++ b/applications/utilities/mesh/manipulation/deformedGeom/deformedGeom.C
@@ -52,8 +52,7 @@ int main(int argc, char *argv[])
 #   include "createTime.H"
 #   include "createMesh.H"
 
-    pointMesh pMesh(mesh);
-    volPointInterpolation pInterp(mesh, pMesh);
+    volPointInterpolation pInterp(mesh);
 
     // Get times list
     instantList Times = runTime.times();
diff --git a/applications/utilities/postProcessing/dataConversion/foamToFieldview9/foamToFieldview9.C b/applications/utilities/postProcessing/dataConversion/foamToFieldview9/foamToFieldview9.C
index 7cf137cd0e..62a68eda69 100644
--- a/applications/utilities/postProcessing/dataConversion/foamToFieldview9/foamToFieldview9.C
+++ b/applications/utilities/postProcessing/dataConversion/foamToFieldview9/foamToFieldview9.C
@@ -642,8 +642,7 @@ int main(int argc, char *argv[])
 
         //Info<< "Writing variables data ..." << endl;
 
-        pointMesh pMesh(mesh);
-        volPointInterpolation pInterp(mesh, pMesh);
+        volPointInterpolation pInterp(mesh);
 
         writeInt(fvFile, FV_VARIABLES);
 
diff --git a/applications/utilities/postProcessing/dataConversion/foamToVTK/foamToVTK.C b/applications/utilities/postProcessing/dataConversion/foamToVTK/foamToVTK.C
index 96b13cad71..a9c7edadfb 100644
--- a/applications/utilities/postProcessing/dataConversion/foamToVTK/foamToVTK.C
+++ b/applications/utilities/postProcessing/dataConversion/foamToVTK/foamToVTK.C
@@ -489,7 +489,7 @@ int main(int argc, char *argv[])
             readFields
             (
                 vMesh,
-                vMesh.basePointMesh(),
+                pointMesh::New(vMesh.baseMesh()),
                 objects,
                 selectedFields,
                 psf
@@ -499,7 +499,7 @@ int main(int argc, char *argv[])
             readFields
             (
                 vMesh,
-                vMesh.basePointMesh(),
+                pointMesh::New(vMesh.baseMesh()),
                 objects,
                 selectedFields,
                 pvf
@@ -509,7 +509,7 @@ int main(int argc, char *argv[])
             readFields
             (
                 vMesh,
-                vMesh.basePointMesh(),
+                pointMesh::New(vMesh.baseMesh()),
                 objects,
                 selectedFields,
                 pSpheretf
@@ -519,7 +519,7 @@ int main(int argc, char *argv[])
             readFields
             (
                 vMesh,
-                vMesh.basePointMesh(),
+                pointMesh::New(vMesh.baseMesh()),
                 objects,
                 selectedFields,
                 pSymmtf
@@ -529,7 +529,7 @@ int main(int argc, char *argv[])
             readFields
             (
                 vMesh,
-                vMesh.basePointMesh(),
+                pointMesh::New(vMesh.baseMesh()),
                 objects,
                 selectedFields,
                 ptf
@@ -598,7 +598,7 @@ int main(int argc, char *argv[])
                 writer.write(ptf);
 
                 // Interpolated volFields
-                volPointInterpolation pInterp(mesh, vMesh.pMesh());
+                volPointInterpolation pInterp(mesh);
                 writer.write(pInterp, vsf);
                 writer.write(pInterp, vvf);
                 writer.write(pInterp, vSpheretf);
diff --git a/applications/utilities/postProcessing/dataConversion/foamToVTK/vtkMesh.C b/applications/utilities/postProcessing/dataConversion/foamToVTK/vtkMesh.C
index f650dab04c..51f4951906 100644
--- a/applications/utilities/postProcessing/dataConversion/foamToVTK/vtkMesh.C
+++ b/applications/utilities/postProcessing/dataConversion/foamToVTK/vtkMesh.C
@@ -70,7 +70,6 @@ Foam::polyMesh::readUpdateState Foam::vtkMesh::readUpdate()
         // the subset even if only movement.
 
         topoPtr_.clear();
-        pointMeshPtr_.clear();
 
         if (setName_.size() > 0)
         {
diff --git a/applications/utilities/postProcessing/dataConversion/foamToVTK/vtkMesh.H b/applications/utilities/postProcessing/dataConversion/foamToVTK/vtkMesh.H
index 315a36561b..b0533dcc86 100644
--- a/applications/utilities/postProcessing/dataConversion/foamToVTK/vtkMesh.H
+++ b/applications/utilities/postProcessing/dataConversion/foamToVTK/vtkMesh.H
@@ -39,7 +39,6 @@ SourceFiles
 
 #include "vtkTopo.H"
 #include "fvMeshSubset.H"
-#include "pointMesh.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -60,9 +59,6 @@ class vtkMesh
         //- Reference to mesh
         fvMesh& baseMesh_;
 
-        //- Demand driven pointMesh
-        mutable autoPtr<pointMesh> pointMeshPtr_;
-
         //- Subsetting engine + sub-fvMesh
         fvMeshSubset subsetter_;
 
@@ -101,15 +97,6 @@ public:
                 return baseMesh_;
             }
 
-            const pointMesh& basePointMesh() const
-            {
-                if (!pointMeshPtr_.valid())
-                {
-                    pointMeshPtr_.reset(new pointMesh(baseMesh_));
-                }
-                return pointMeshPtr_();
-            }
-
             const fvMeshSubset& subsetter() const
             {
                 return subsetter_;
@@ -144,19 +131,6 @@ public:
                 }
             }
 
-            //- Access either pointMesh of base or pointMesh of subset
-            const pointMesh& pMesh() const
-            {
-                if (useSubMesh())
-                {
-                    return subsetter_.subPointMesh();
-                }
-                else
-                {
-                    return basePointMesh();
-                }
-            }
-
             //- Number of field cells
             label nFieldCells() const
             {
@@ -166,7 +140,7 @@ public:
             //- Number of field points
             label nFieldPoints() const
             {
-                return pMesh().size() + topo().addPointCellLabels().size();
+                return mesh().nPoints() + topo().addPointCellLabels().size();
             }
 
 
diff --git a/applications/utilities/postProcessing/graphics/PV3FoamReader/vtkPV3Foam/vtkPV3FoamFields.C b/applications/utilities/postProcessing/graphics/PV3FoamReader/vtkPV3Foam/vtkPV3FoamFields.C
index 4f320c802c..94f98d8f25 100644
--- a/applications/utilities/postProcessing/graphics/PV3FoamReader/vtkPV3Foam/vtkPV3FoamFields.C
+++ b/applications/utilities/postProcessing/graphics/PV3FoamReader/vtkPV3Foam/vtkPV3FoamFields.C
@@ -107,8 +107,7 @@ void Foam::vtkPV3Foam::convertVolFields
     }
 
     // Construct interpolation on the raw mesh
-    pointMesh pMesh(mesh);
-    volPointInterpolation pInterp(mesh, pMesh);
+    volPointInterpolation pInterp(mesh);
 
     PtrList<PrimitivePatchInterpolation<primitivePatch> >
         ppInterpList(mesh.boundaryMesh().size());
diff --git a/src/OpenFOAM/meshes/pointMesh/pointMesh.C b/src/OpenFOAM/meshes/pointMesh/pointMesh.C
index c17993109d..bbafbad0e7 100644
--- a/src/OpenFOAM/meshes/pointMesh/pointMesh.C
+++ b/src/OpenFOAM/meshes/pointMesh/pointMesh.C
@@ -62,11 +62,16 @@ Foam::pointMesh::pointMesh
     bool alwaysConstructGlobalPatch
 )
 :
+    MeshObject<polyMesh, pointMesh>(pMesh),
     GeoMesh<polyMesh>(pMesh),
     boundary_(*this, pMesh.boundaryMesh())
 {
     // Add the globalPointPatch if there are global points
-    if (alwaysConstructGlobalPatch || mesh_.globalData().nGlobalPoints())
+    if
+    (
+        alwaysConstructGlobalPatch
+     || GeoMesh<polyMesh>::mesh_.globalData().nGlobalPoints()
+    )
     {
         boundary_.setSize(boundary_.size() + 1);
 
diff --git a/src/OpenFOAM/meshes/pointMesh/pointMesh.H b/src/OpenFOAM/meshes/pointMesh/pointMesh.H
index e760ab3cab..093fc06255 100644
--- a/src/OpenFOAM/meshes/pointMesh/pointMesh.H
+++ b/src/OpenFOAM/meshes/pointMesh/pointMesh.H
@@ -34,6 +34,7 @@ Description
 #define pointMesh_H
 
 #include "GeoMesh.H"
+#include "MeshObject.H"
 #include "polyMesh.H"
 #include "pointBoundaryMesh.H"
 
@@ -48,6 +49,7 @@ namespace Foam
 
 class pointMesh
 :
+    public MeshObject<polyMesh, pointMesh>,
     public GeoMesh<polyMesh>
 {
     // Permanent data
@@ -95,7 +97,7 @@ public:
         //- Return number of points
         static label size(const Mesh& mesh)
         {
-            return mesh.mesh_.nPoints();
+            return mesh.GeoMesh<polyMesh>::mesh_.nPoints();
         }
 
         //- Return reference to boundary mesh
@@ -107,7 +109,13 @@ public:
         //- Return parallel info
         const globalMeshData& globalData() const
         {
-            return mesh_.globalData();
+            return GeoMesh<polyMesh>::mesh_.globalData();
+        }
+
+        //- Return database (only needed for compilation purposes)
+        const objectRegistry& db() const
+        {
+            return GeoMesh<polyMesh>::mesh_.db();
         }
 
 
diff --git a/src/OpenFOAM/meshes/polyMesh/polyMeshClear.C b/src/OpenFOAM/meshes/polyMesh/polyMeshClear.C
index 7ac30ce8a8..ae5ab8b761 100644
--- a/src/OpenFOAM/meshes/polyMesh/polyMeshClear.C
+++ b/src/OpenFOAM/meshes/polyMesh/polyMeshClear.C
@@ -28,6 +28,8 @@ License
 #include "primitiveMesh.H"
 #include "globalMeshData.H"
 #include "demandDrivenData.H"
+#include "pointMesh.H"
+#include "Time.H"
 
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 
@@ -65,6 +67,8 @@ void Foam::polyMesh::clearGeom()
     {
         boundary_[patchI].clearGeom();
     }
+
+    pointMesh::Delete(*this);
 }
 
 
@@ -82,6 +86,8 @@ void Foam::polyMesh::clearAddressing()
     // parallelData depends on the processorPatch ordering so force
     // recalculation
     deleteDemandDrivenData(globalMeshDataPtr_);
+
+    pointMesh::Delete(*this);
 }
 
 
diff --git a/src/OpenFOAM/meshes/polyMesh/polyMeshUpdate.C b/src/OpenFOAM/meshes/polyMesh/polyMeshUpdate.C
index 5e1d1cadeb..9b53965e2a 100644
--- a/src/OpenFOAM/meshes/polyMesh/polyMeshUpdate.C
+++ b/src/OpenFOAM/meshes/polyMesh/polyMeshUpdate.C
@@ -31,6 +31,7 @@ Description
 #include "mapPolyMesh.H"
 #include "Time.H"
 #include "globalMeshData.H"
+#include "pointMesh.H"
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
@@ -66,6 +67,26 @@ void Foam::polyMesh::updateMesh(const mapPolyMesh& mpm)
         // Map the list
         newMotionPoints.map(oldMotionPoints, mpm.pointMap());
     }
+
+    // Hack until proper callbacks. Below are all the polyMesh-MeshObjects.
+
+    // pointMesh
+    if
+    (
+        db().objectRegistry::foundObject<pointMesh>
+        (
+            pointMesh::typeName
+        )
+    )
+    {
+        const_cast<pointMesh&>
+        (
+            db().objectRegistry::lookupObject<pointMesh>
+            (
+                pointMesh::typeName
+            )
+        ).updateMesh(mpm);
+    }
 }
 
 
diff --git a/src/autoMesh/autoHexMesh/autoHexMeshDriver/autoHexMeshDriver.C b/src/autoMesh/autoHexMesh/autoHexMeshDriver/autoHexMeshDriver.C
index c07b950d0a..de6ee7c894 100644
--- a/src/autoMesh/autoHexMesh/autoHexMeshDriver/autoHexMeshDriver.C
+++ b/src/autoMesh/autoHexMesh/autoHexMeshDriver/autoHexMeshDriver.C
@@ -34,7 +34,6 @@ License
 #include "cellSet.H"
 #include "syncTools.H"
 #include "motionSmoother.H"
-#include "pointMesh.H"
 #include "refinementParameters.H"
 #include "snapParameters.H"
 #include "layerParameters.H"
diff --git a/src/autoMesh/autoHexMesh/autoHexMeshDriver/autoLayerDriver.C b/src/autoMesh/autoHexMesh/autoHexMeshDriver/autoLayerDriver.C
index 7caa1af11e..71707195f3 100644
--- a/src/autoMesh/autoHexMesh/autoHexMeshDriver/autoLayerDriver.C
+++ b/src/autoMesh/autoHexMesh/autoHexMeshDriver/autoLayerDriver.C
@@ -3082,7 +3082,7 @@ void Foam::autoLayerDriver::doLayers
         Info<< "Constructing mesh displacer ..." << endl;
 
         {
-            pointMesh pMesh(mesh);
+            const pointMesh& pMesh = pointMesh::New(mesh);
 
             motionSmoother meshMover
             (
diff --git a/src/autoMesh/autoHexMesh/autoHexMeshDriver/autoLayerDriverShrink.C b/src/autoMesh/autoHexMesh/autoHexMeshDriver/autoLayerDriverShrink.C
index 8c41371ddc..c21c44f8d5 100644
--- a/src/autoMesh/autoHexMesh/autoHexMeshDriver/autoLayerDriverShrink.C
+++ b/src/autoMesh/autoHexMesh/autoHexMeshDriver/autoLayerDriverShrink.C
@@ -675,7 +675,6 @@ void Foam::autoLayerDriver::medialAxisSmoothingInfo
 
     const polyMesh& mesh = meshMover.mesh();
     const pointField& points = mesh.points();
-    const pointMesh& pMesh = meshMover.pMesh();
 
     const indirectPrimitivePatch& pp = meshMover.patch();
     const vectorField& faceNormals = pp.faceNormals();
@@ -788,7 +787,7 @@ void Foam::autoLayerDriver::medialAxisSmoothingInfo
         List<pointData> edgeWallDist(mesh.nEdges());
         PointEdgeWave<pointData> wallDistCalc
         (
-            pMesh,
+            mesh,
             meshPoints,
             wallInfo,
             pointWallDist,
@@ -892,7 +891,7 @@ void Foam::autoLayerDriver::medialAxisSmoothingInfo
         // Do all calculations
         PointEdgeWave<pointData> medialDistCalc
         (
-            pMesh,
+            mesh,
             maxPoints,
             maxInfo,
 
@@ -975,7 +974,6 @@ void Foam::autoLayerDriver::shrinkMeshMedialDistance
     Info<< "shrinkMeshMedialDistance : Smoothing using Medial Axis ..." << endl;
 
     const polyMesh& mesh = meshMover.mesh();
-    const pointMesh& pMesh = meshMover.pMesh();
 
     const indirectPrimitivePatch& pp = meshMover.patch();
     const labelList& meshPoints = pp.meshPoints();
@@ -1100,7 +1098,7 @@ void Foam::autoLayerDriver::shrinkMeshMedialDistance
         // Do all calculations
         PointEdgeWave<pointData> wallDistCalc
         (
-            pMesh,
+            mesh,
             wallPoints,
             wallInfo,
             pointWallDist,
diff --git a/src/autoMesh/autoHexMesh/autoHexMeshDriver/autoSnapDriver.C b/src/autoMesh/autoHexMesh/autoHexMeshDriver/autoSnapDriver.C
index bd0825217a..3a6c79987c 100644
--- a/src/autoMesh/autoHexMesh/autoHexMeshDriver/autoSnapDriver.C
+++ b/src/autoMesh/autoHexMesh/autoHexMeshDriver/autoSnapDriver.C
@@ -527,7 +527,7 @@ Foam::tmp<Foam::scalarField> Foam::autoSnapDriver::edgePatchDist
 
     PointEdgeWave<pointEdgePoint> wallCalc
     (
-        pMesh,
+        mesh,
         pp.meshPoints(),
         wallInfo,
 
@@ -1504,7 +1504,7 @@ void Foam::autoSnapDriver::doSnap
         Info<< "Constructing mesh displacer ..." << endl;
         Info<< "Using mesh parameters " << motionDict << nl << endl;
 
-        pointMesh pMesh(mesh);
+        const pointMesh& pMesh = pointMesh::New(mesh);
 
         motionSmoother meshMover
         (
diff --git a/src/autoMesh/autoHexMesh/meshRefinement/meshRefinement.C b/src/autoMesh/autoHexMesh/meshRefinement/meshRefinement.C
index 626fb2fe25..93e37f1932 100644
--- a/src/autoMesh/autoHexMesh/meshRefinement/meshRefinement.C
+++ b/src/autoMesh/autoHexMesh/meshRefinement/meshRefinement.C
@@ -1992,7 +1992,7 @@ void Foam::meshRefinement::dumpRefinementLevel() const
     volRefLevel.write();
 
 
-    pointMesh pMesh(mesh_);
+    const pointMesh& pMesh = pointMesh::New(mesh_);
 
     pointScalarField pointRefLevel
     (
diff --git a/src/finiteVolume/fvMesh/fvMeshSubset/fvMeshSubset.C b/src/finiteVolume/fvMesh/fvMeshSubset/fvMeshSubset.C
index 2351ab9f8b..2a703ba462 100644
--- a/src/finiteVolume/fvMesh/fvMeshSubset/fvMeshSubset.C
+++ b/src/finiteVolume/fvMesh/fvMeshSubset/fvMeshSubset.C
@@ -680,7 +680,6 @@ void Foam::fvMeshSubset::setCellSubset
             newCells
         )
     );
-    pointMeshSubsetPtr_.clear();
 
 
     // Add old patches
@@ -1180,7 +1179,6 @@ void Foam::fvMeshSubset::setLargeCellSubset
             syncPar           // parallel synchronisation
         )
     );
-    pointMeshSubsetPtr_.clear();
 
     // Add old patches
     List<polyPatch*> newBoundary(nbSize);
@@ -1370,26 +1368,6 @@ fvMesh& Foam::fvMeshSubset::subMesh()
 }
 
 
-const pointMesh& Foam::fvMeshSubset::subPointMesh() const
-{
-    if (!pointMeshSubsetPtr_.valid())
-    {
-        pointMeshSubsetPtr_.reset(new pointMesh(subMesh()));
-    }
-    return pointMeshSubsetPtr_();
-}
-
-
-pointMesh& Foam::fvMeshSubset::subPointMesh()
-{
-    if (!pointMeshSubsetPtr_.valid())
-    {
-        pointMeshSubsetPtr_.reset(new pointMesh(subMesh()));
-    }
-    return pointMeshSubsetPtr_();
-}
-
-
 const labelList& Foam::fvMeshSubset::pointMap() const
 {
     checkCellSubset();
diff --git a/src/finiteVolume/fvMesh/fvMeshSubset/fvMeshSubset.H b/src/finiteVolume/fvMesh/fvMeshSubset/fvMeshSubset.H
index 11c1af1bc9..3fbc20d9f8 100644
--- a/src/finiteVolume/fvMesh/fvMeshSubset/fvMeshSubset.H
+++ b/src/finiteVolume/fvMesh/fvMeshSubset/fvMeshSubset.H
@@ -171,8 +171,6 @@ private:
         //- Subset mesh pointer
         autoPtr<fvMesh> fvMeshSubsetPtr_;
 
-        mutable autoPtr<pointMesh> pointMeshSubsetPtr_;
-
         //- Point mapping array
         labelList pointMap_;
 
@@ -278,11 +276,6 @@ public:
 
             fvMesh& subMesh();
 
-            //- Return reference to demand-driven subset pointMesh
-            const pointMesh& subPointMesh() const;
-
-            pointMesh& subPointMesh();
-
             //- Return point map
             const labelList& pointMap() const;
 
diff --git a/src/finiteVolume/fvMesh/fvMeshSubset/fvMeshSubsetInterpolate.C b/src/finiteVolume/fvMesh/fvMeshSubset/fvMeshSubsetInterpolate.C
index ea3fdccbcf..1afa83f9d0 100644
--- a/src/finiteVolume/fvMesh/fvMeshSubset/fvMeshSubsetInterpolate.C
+++ b/src/finiteVolume/fvMesh/fvMeshSubset/fvMeshSubsetInterpolate.C
@@ -409,7 +409,7 @@ tmp<GeometricField<Type, pointPatchField, pointMesh> > fvMeshSubset::interpolate
     return interpolate
     (
         sf,
-        subPointMesh(),     // subsetted point mesh
+        pointMesh::New(subMesh()),     // subsetted point mesh
         subMesh(),          // registry (pointfields are stored on the polyMesh)
         patchMap(),
         pointMap()
diff --git a/src/finiteVolume/interpolation/interpolation/interpolation/interpolation.H b/src/finiteVolume/interpolation/interpolation/interpolation/interpolation.H
index 2a37087a48..d9893d0e82 100644
--- a/src/finiteVolume/interpolation/interpolation/interpolation/interpolation.H
+++ b/src/finiteVolume/interpolation/interpolation/interpolation/interpolation.H
@@ -46,7 +46,6 @@ namespace Foam
 {
 
 class polyMesh;
-class volPointInterpolation;
 
 /*---------------------------------------------------------------------------*\
                            Class interpolation Declaration
@@ -83,10 +82,9 @@ public:
             interpolation,
             dictionary,
             (
-                const volPointInterpolation& pInterp,
                 const GeometricField<Type, fvPatchField, volMesh>& psi
             ),
-            (pInterp, psi)
+            (psi)
         );
 
 
@@ -96,7 +94,6 @@ public:
         static autoPtr<interpolation<Type> > New
         (
             const word& interpolationType,
-            const volPointInterpolation& pInterp,
             const GeometricField<Type, fvPatchField, volMesh>& psi
         );
 
@@ -104,7 +101,6 @@ public:
         static autoPtr<interpolation<Type> > New
         (
             const dictionary& interpolationSchemes,
-            const volPointInterpolation& pInterp,
             const GeometricField<Type, fvPatchField, volMesh>& psi
         );
 
diff --git a/src/finiteVolume/interpolation/interpolation/interpolation/newInterpolation.C b/src/finiteVolume/interpolation/interpolation/interpolation/newInterpolation.C
index a908b61f19..9cb13f8c71 100644
--- a/src/finiteVolume/interpolation/interpolation/interpolation/newInterpolation.C
+++ b/src/finiteVolume/interpolation/interpolation/interpolation/newInterpolation.C
@@ -34,7 +34,6 @@ Foam::autoPtr<Foam::interpolation<Type> >
 Foam::interpolation<Type>::New
 (
     const word& interpolationType,
-    const volPointInterpolation& pInterp,
     const GeometricField<Type, fvPatchField, volMesh>& psi
 )
 {
@@ -55,7 +54,7 @@ Foam::interpolation<Type>::New
             << exit(FatalError);
     }
 
-    return autoPtr<interpolation<Type> >(cstrIter()(pInterp, psi));
+    return autoPtr<interpolation<Type> >(cstrIter()(psi));
 }
 
 
@@ -64,11 +63,10 @@ Foam::autoPtr<Foam::interpolation<Type> >
 Foam::interpolation<Type>::New
 (
     const dictionary& interpolationSchemes,
-    const volPointInterpolation& pInterp,
     const GeometricField<Type, fvPatchField, volMesh>& psi
 )
 {
-    return New(word(interpolationSchemes.lookup(psi.name())), pInterp, psi);
+    return New(word(interpolationSchemes.lookup(psi.name())), psi);
 }
 
 
diff --git a/src/finiteVolume/interpolation/interpolation/interpolationCell/interpolationCell.C b/src/finiteVolume/interpolation/interpolation/interpolationCell/interpolationCell.C
index c99ffcaf9d..6d634db810 100644
--- a/src/finiteVolume/interpolation/interpolation/interpolationCell/interpolationCell.C
+++ b/src/finiteVolume/interpolation/interpolation/interpolationCell/interpolationCell.C
@@ -39,7 +39,6 @@ namespace Foam
 template<class Type>
 interpolationCell<Type>::interpolationCell
 (
-    const volPointInterpolation&,
     const GeometricField<Type, fvPatchField, volMesh>& psi
 )
 :
diff --git a/src/finiteVolume/interpolation/interpolation/interpolationCell/interpolationCell.H b/src/finiteVolume/interpolation/interpolation/interpolationCell/interpolationCell.H
index dac33efbbf..44e6fc8c6f 100644
--- a/src/finiteVolume/interpolation/interpolation/interpolationCell/interpolationCell.H
+++ b/src/finiteVolume/interpolation/interpolation/interpolationCell/interpolationCell.H
@@ -63,7 +63,6 @@ public:
         //- Construct from components
         interpolationCell
         (
-            const volPointInterpolation& pInterp,
             const GeometricField<Type, fvPatchField, volMesh>& psi
         );
 
diff --git a/src/finiteVolume/interpolation/interpolation/interpolationCellPoint/interpolationCellPoint.C b/src/finiteVolume/interpolation/interpolation/interpolationCellPoint/interpolationCellPoint.C
index 0701737ffa..7b837feb20 100644
--- a/src/finiteVolume/interpolation/interpolation/interpolationCellPoint/interpolationCellPoint.C
+++ b/src/finiteVolume/interpolation/interpolation/interpolationCellPoint/interpolationCellPoint.C
@@ -32,12 +32,11 @@ License
 template<class Type>
 Foam::interpolationCellPoint<Type>::interpolationCellPoint
 (
-    const volPointInterpolation& pInterp,
     const GeometricField<Type, fvPatchField, volMesh>& psi
 )
 :
     interpolation<Type>(psi),
-    psip_(pInterp.interpolate(psi))
+    psip_(volPointInterpolation::New(psi.mesh()).interpolate(psi))
 {}
 
 
diff --git a/src/finiteVolume/interpolation/interpolation/interpolationCellPoint/interpolationCellPoint.H b/src/finiteVolume/interpolation/interpolation/interpolationCellPoint/interpolationCellPoint.H
index c29bad38da..6ba0be2c46 100644
--- a/src/finiteVolume/interpolation/interpolation/interpolationCellPoint/interpolationCellPoint.H
+++ b/src/finiteVolume/interpolation/interpolation/interpolationCellPoint/interpolationCellPoint.H
@@ -52,7 +52,8 @@ class interpolationCellPoint
 {
     // Private data
 
-        GeometricField<Type, pointPatchField, pointMesh> psip_;
+        //- Interpolated volfield
+        const GeometricField<Type, pointPatchField, pointMesh> psip_;
 
 
 public:
@@ -66,7 +67,6 @@ public:
         //- Construct from components
         interpolationCellPoint
         (
-            const volPointInterpolation& pInterp,
             const GeometricField<Type, fvPatchField, volMesh>& psi
         );
 
diff --git a/src/finiteVolume/interpolation/interpolation/interpolationCellPointFace/interpolationCellPointFace.C b/src/finiteVolume/interpolation/interpolation/interpolationCellPointFace/interpolationCellPointFace.C
index 4c398155bb..0ffc3efe4c 100644
--- a/src/finiteVolume/interpolation/interpolation/interpolationCellPointFace/interpolationCellPointFace.C
+++ b/src/finiteVolume/interpolation/interpolation/interpolationCellPointFace/interpolationCellPointFace.C
@@ -44,12 +44,11 @@ namespace Foam
 template<class Type>
 interpolationCellPointFace<Type>::interpolationCellPointFace
 (
-    const volPointInterpolation& pInterp,
     const GeometricField<Type, fvPatchField, volMesh>& psi
 )
 :
     interpolation<Type>(psi),
-    psip_(pInterp.interpolate(psi)),
+    psip_(volPointInterpolation::New(psi.mesh()).interpolate(psi)),
     psis_(linearInterpolate(psi))
 {}
 
diff --git a/src/finiteVolume/interpolation/interpolation/interpolationCellPointFace/interpolationCellPointFace.H b/src/finiteVolume/interpolation/interpolation/interpolationCellPointFace/interpolationCellPointFace.H
index 02bb34d7a2..fc1378a3a9 100644
--- a/src/finiteVolume/interpolation/interpolation/interpolationCellPointFace/interpolationCellPointFace.H
+++ b/src/finiteVolume/interpolation/interpolation/interpolationCellPointFace/interpolationCellPointFace.H
@@ -51,8 +51,11 @@ class interpolationCellPointFace
 {
     // Private data
 
-        GeometricField<Type, pointPatchField, pointMesh> psip_;
-        GeometricField<Type, fvsPatchField, surfaceMesh> psis_;
+        //- Interpolated volfield
+        const GeometricField<Type, pointPatchField, pointMesh> psip_;
+
+        //- Linearly interpolated volfield
+        const GeometricField<Type, fvsPatchField, surfaceMesh> psis_;
 
         bool findTet
         (
@@ -87,7 +90,6 @@ public:
         //- Construct from components
         interpolationCellPointFace
         (
-            const volPointInterpolation& pInterp,
             const GeometricField<Type, fvPatchField, volMesh>& psi
         );
 
diff --git a/src/finiteVolume/interpolation/volPointInterpolation/pointPatchInterpolation/pointPatchInterpolate.C b/src/finiteVolume/interpolation/volPointInterpolation/pointPatchInterpolation/pointPatchInterpolate.C
index e81791e9f1..01af2cc5ec 100644
--- a/src/finiteVolume/interpolation/volPointInterpolation/pointPatchInterpolation/pointPatchInterpolate.C
+++ b/src/finiteVolume/interpolation/volPointInterpolation/pointPatchInterpolation/pointPatchInterpolate.C
@@ -62,7 +62,7 @@ void pointPatchInterpolation::interpolate
     // patch
 
     const fvBoundaryMesh& bm = fvMesh_.boundary();
-    const pointBoundaryMesh& pbm = pointMesh_.boundary();
+    const pointBoundaryMesh& pbm = pointMesh::New(fvMesh_).boundary();
 
     forAll(bm, patchi)
     {
diff --git a/src/finiteVolume/interpolation/volPointInterpolation/pointPatchInterpolation/pointPatchInterpolation.C b/src/finiteVolume/interpolation/volPointInterpolation/pointPatchInterpolation/pointPatchInterpolation.C
index 82e2bfc899..f823b2c7b2 100644
--- a/src/finiteVolume/interpolation/volPointInterpolation/pointPatchInterpolation/pointPatchInterpolation.C
+++ b/src/finiteVolume/interpolation/volPointInterpolation/pointPatchInterpolation/pointPatchInterpolation.C
@@ -55,7 +55,7 @@ void pointPatchInterpolation::makePatchPatchAddressing()
     }
 
     const fvBoundaryMesh& bm = fvMesh_.boundary();
-    const pointBoundaryMesh& pbm = pointMesh_.boundary();
+    const pointBoundaryMesh& pbm = pointMesh::New(fvMesh_).boundary();
 
     // first count the total number of patch-patch points
 
@@ -188,7 +188,7 @@ void pointPatchInterpolation::makePatchPatchWeights()
             fvMesh_.polyMesh::instance(),
             fvMesh_
         ),
-        pointMesh_,
+        pointMesh::New(fvMesh_),
         dimensionedScalar("zero", dimless, 0)
     );
 
@@ -285,14 +285,9 @@ void pointPatchInterpolation::makePatchPatchWeights()
 
 // * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * * //
 
-pointPatchInterpolation::pointPatchInterpolation
-(
-    const fvMesh& vm,
-    const pointMesh& pm
-)
+pointPatchInterpolation::pointPatchInterpolation(const fvMesh& vm)
 :
-    fvMesh_(vm),
-    pointMesh_(pm)
+    fvMesh_(vm)
 {
     updateMesh();
 }
diff --git a/src/finiteVolume/interpolation/volPointInterpolation/pointPatchInterpolation/pointPatchInterpolation.H b/src/finiteVolume/interpolation/volPointInterpolation/pointPatchInterpolation/pointPatchInterpolation.H
index 5f84902662..042c608e23 100644
--- a/src/finiteVolume/interpolation/volPointInterpolation/pointPatchInterpolation/pointPatchInterpolation.H
+++ b/src/finiteVolume/interpolation/volPointInterpolation/pointPatchInterpolation/pointPatchInterpolation.H
@@ -61,7 +61,6 @@ class pointPatchInterpolation
     // Private data
 
         const fvMesh& fvMesh_;
-        const pointMesh& pointMesh_;
 
         //- Primitive patch interpolators
         PtrList<primitivePatchInterpolation> patchInterpolators_;
@@ -101,7 +100,7 @@ public:
     // Constructors
 
         //- Constructor given fvMesh and pointMesh.
-        pointPatchInterpolation(const fvMesh&, const pointMesh&);
+        pointPatchInterpolation(const fvMesh&);
 
 
     // Destructor
@@ -118,11 +117,6 @@ public:
                 return fvMesh_;
             }
 
-            const pointMesh& pMesh() const
-            {
-                return pointMesh_;
-            }
-
 
         // Edit
 
diff --git a/src/finiteVolume/interpolation/volPointInterpolation/volPointInterpolate.C b/src/finiteVolume/interpolation/volPointInterpolation/volPointInterpolate.C
index 048f7697e8..8175242a03 100644
--- a/src/finiteVolume/interpolation/volPointInterpolation/volPointInterpolate.C
+++ b/src/finiteVolume/interpolation/volPointInterpolation/volPointInterpolate.C
@@ -103,18 +103,20 @@ volPointInterpolation::interpolate
 {
     wordList types(patchFieldTypes);
 
+    const pointMesh& pMesh = pointMesh::New(vf.mesh());
+
     // If the last patch of the pointBoundaryMesh is the global patch
     // it must be added to the list of patchField types
     if
     (
         isType<globalPointPatch>
         (
-            pMesh().boundary()[pMesh().boundary().size() - 1]
+            pMesh.boundary()[pMesh.boundary().size() - 1]
         )
     )
     {
         types.setSize(types.size() + 1);
-        types[types.size()-1] = pMesh().boundary()[types.size()-1].type();
+        types[types.size()-1] = pMesh.boundary()[types.size()-1].type();
     }
 
     // Construct tmp<pointField>
@@ -128,7 +130,7 @@ volPointInterpolation::interpolate
                 vf.instance(),
                 vf.db()
             ),
-            pMesh(),
+            pMesh,
             vf.dimensions(),
             types
         )
@@ -176,7 +178,7 @@ volPointInterpolation::interpolate
                 vf.instance(),
                 vf.db()
             ),
-            pMesh(),
+            pointMesh::New(vf.mesh()),
             vf.dimensions()
         )
     );
diff --git a/src/finiteVolume/interpolation/volPointInterpolation/volPointInterpolation.C b/src/finiteVolume/interpolation/volPointInterpolation/volPointInterpolation.C
index 64f0e24b38..be773374ae 100644
--- a/src/finiteVolume/interpolation/volPointInterpolation/volPointInterpolation.C
+++ b/src/finiteVolume/interpolation/volPointInterpolation/volPointInterpolation.C
@@ -74,7 +74,7 @@ void volPointInterpolation::makeWeights()
             mesh().polyMesh::instance(),
             mesh()
         ),
-        pMesh(),
+        pointMesh::New(mesh()),
         dimensionedScalar("zero", dimless, 0)
     );
 
@@ -139,13 +139,10 @@ void volPointInterpolation::makeWeights()
 
 // * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * * //
 
-volPointInterpolation::volPointInterpolation
-(
-    const fvMesh& vm,
-    const pointMesh& pm
-)
+volPointInterpolation::volPointInterpolation(const fvMesh& vm)
 :
-    boundaryInterpolator_(vm, pm)
+    MeshObject<fvMesh, volPointInterpolation>(vm),
+    boundaryInterpolator_(vm)
 {
     updateMesh();
 }
diff --git a/src/finiteVolume/interpolation/volPointInterpolation/volPointInterpolation.H b/src/finiteVolume/interpolation/volPointInterpolation/volPointInterpolation.H
index 2072adf559..7679868552 100644
--- a/src/finiteVolume/interpolation/volPointInterpolation/volPointInterpolation.H
+++ b/src/finiteVolume/interpolation/volPointInterpolation/volPointInterpolation.H
@@ -37,6 +37,7 @@ SourceFiles
 #ifndef volPointInterpolation_H
 #define volPointInterpolation_H
 
+#include "MeshObject.H"
 #include "pointPatchInterpolation.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@@ -52,6 +53,8 @@ class pointMesh;
 \*---------------------------------------------------------------------------*/
 
 class volPointInterpolation
+:
+    public MeshObject<fvMesh, volPointInterpolation>
 {
     // Private data
 
@@ -83,7 +86,7 @@ public:
     // Constructors
 
         //- Constructor given fvMesh and pointMesh.
-        volPointInterpolation(const fvMesh&, const pointMesh&);
+        explicit volPointInterpolation(const fvMesh&);
 
 
     // Destructor
@@ -100,11 +103,6 @@ public:
                 return boundaryInterpolator_.mesh();
             }
 
-            const pointMesh& pMesh() const
-            {
-                return boundaryInterpolator_.pMesh();
-            }
-
 
         // Edit
 
diff --git a/src/fvMotionSolver/fvMotionSolvers/displacement/SBRStress/displacementSBRStressFvMotionSolver.C b/src/fvMotionSolver/fvMotionSolvers/displacement/SBRStress/displacementSBRStressFvMotionSolver.C
index f445079809..ba8498bba0 100644
--- a/src/fvMotionSolver/fvMotionSolvers/displacement/SBRStress/displacementSBRStressFvMotionSolver.C
+++ b/src/fvMotionSolver/fvMotionSolvers/displacement/SBRStress/displacementSBRStressFvMotionSolver.C
@@ -33,6 +33,7 @@ License
 #include "surfaceInterpolate.H"
 #include "fvcLaplacian.H"
 #include "mapPolyMesh.H"
+#include "volPointInterpolation.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
@@ -83,7 +84,7 @@ Foam::displacementSBRStressFvMotionSolver::displacementSBRStressFvMotionSolver
             IOobject::MUST_READ,
             IOobject::AUTO_WRITE
         ),
-        pointMesh_
+        pointMesh::New(fvMesh_)
     ),
     cellDisplacement_
     (
@@ -123,7 +124,11 @@ Foam::displacementSBRStressFvMotionSolver::
 Foam::tmp<Foam::pointField>
 Foam::displacementSBRStressFvMotionSolver::curPoints() const
 {
-    vpi_.interpolate(cellDisplacement_, pointDisplacement_);
+    volPointInterpolation::New(fvMesh_).interpolate
+    (
+        cellDisplacement_,
+        pointDisplacement_
+    );
 
     tmp<pointField> tcurPoints
     (
diff --git a/src/fvMotionSolver/fvMotionSolvers/displacement/componentLaplacian/displacementComponentLaplacianFvMotionSolver.C b/src/fvMotionSolver/fvMotionSolvers/displacement/componentLaplacian/displacementComponentLaplacianFvMotionSolver.C
index 3f6e85acba..0b676f19a1 100644
--- a/src/fvMotionSolver/fvMotionSolvers/displacement/componentLaplacian/displacementComponentLaplacianFvMotionSolver.C
+++ b/src/fvMotionSolver/fvMotionSolvers/displacement/componentLaplacian/displacementComponentLaplacianFvMotionSolver.C
@@ -29,6 +29,7 @@ License
 #include "fvmLaplacian.H"
 #include "addToRunTimeSelectionTable.H"
 #include "mapPolyMesh.H"
+#include "volPointInterpolation.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
@@ -117,7 +118,7 @@ displacementComponentLaplacianFvMotionSolver
             IOobject::MUST_READ,
             IOobject::AUTO_WRITE
         ),
-        pointMesh_
+        pointMesh::New(fvMesh_)
     ),
     cellDisplacement_
     (
@@ -173,7 +174,7 @@ displacementComponentLaplacianFvMotionSolver
             new pointVectorField
             (
                 io,
-                pointMesh_
+                pointMesh::New(fvMesh_)
             )
         );
 
@@ -202,7 +203,11 @@ Foam::displacementComponentLaplacianFvMotionSolver::
 Foam::tmp<Foam::pointField>
 Foam::displacementComponentLaplacianFvMotionSolver::curPoints() const
 {
-    vpi_.interpolate(cellDisplacement_, pointDisplacement_);
+    volPointInterpolation::New(fvMesh_).interpolate
+    (
+        cellDisplacement_,
+        pointDisplacement_
+    );
 
     if (pointLocation_.valid())
     {
diff --git a/src/fvMotionSolver/fvMotionSolvers/displacement/interpolation/displacementInterpolationFvMotionSolver.C b/src/fvMotionSolver/fvMotionSolvers/displacement/interpolation/displacementInterpolationFvMotionSolver.C
index 7ad1d32712..dae6656380 100644
--- a/src/fvMotionSolver/fvMotionSolvers/displacement/interpolation/displacementInterpolationFvMotionSolver.C
+++ b/src/fvMotionSolver/fvMotionSolvers/displacement/interpolation/displacementInterpolationFvMotionSolver.C
@@ -334,7 +334,8 @@ displacementInterpolationFvMotionSolver
 
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 
-Foam::displacementInterpolationFvMotionSolver::~displacementInterpolationFvMotionSolver()
+Foam::displacementInterpolationFvMotionSolver::
+~displacementInterpolationFvMotionSolver()
 {}
 
 
diff --git a/src/fvMotionSolver/fvMotionSolvers/displacement/laplacian/displacementLaplacianFvMotionSolver.C b/src/fvMotionSolver/fvMotionSolvers/displacement/laplacian/displacementLaplacianFvMotionSolver.C
index 2437710385..02e5f3b5eb 100644
--- a/src/fvMotionSolver/fvMotionSolvers/displacement/laplacian/displacementLaplacianFvMotionSolver.C
+++ b/src/fvMotionSolver/fvMotionSolvers/displacement/laplacian/displacementLaplacianFvMotionSolver.C
@@ -31,6 +31,7 @@ License
 #include "OFstream.H"
 #include "meshTools.H"
 #include "mapPolyMesh.H"
+#include "volPointInterpolation.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
@@ -82,7 +83,7 @@ Foam::displacementLaplacianFvMotionSolver::displacementLaplacianFvMotionSolver
             IOobject::MUST_READ,
             IOobject::AUTO_WRITE
         ),
-        pointMesh_
+        pointMesh::New(fvMesh_)
     ),
     cellDisplacement_
     (
@@ -139,7 +140,7 @@ Foam::displacementLaplacianFvMotionSolver::displacementLaplacianFvMotionSolver
             new pointVectorField
             (
                 io,
-                pointMesh_
+                pointMesh::New(fvMesh_)
             )
         );
 
@@ -168,7 +169,11 @@ Foam::displacementLaplacianFvMotionSolver::
 Foam::tmp<Foam::pointField> 
 Foam::displacementLaplacianFvMotionSolver::curPoints() const
 {
-    vpi_.interpolate(cellDisplacement_, pointDisplacement_);
+    volPointInterpolation::New(fvMesh_).interpolate
+    (
+        cellDisplacement_,
+        pointDisplacement_
+    );
 
     if (pointLocation_.valid())
     {
diff --git a/src/fvMotionSolver/fvMotionSolvers/fvMotionSolver/fvMotionSolver.C b/src/fvMotionSolver/fvMotionSolvers/fvMotionSolver/fvMotionSolver.C
index 5c54c4f03c..e7a26d4b41 100644
--- a/src/fvMotionSolver/fvMotionSolvers/fvMotionSolver/fvMotionSolver.C
+++ b/src/fvMotionSolver/fvMotionSolvers/fvMotionSolver/fvMotionSolver.C
@@ -25,6 +25,7 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "fvMotionSolver.H"
+#include "volPointInterpolation.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
@@ -39,9 +40,7 @@ namespace Foam
 Foam::fvMotionSolver::fvMotionSolver(const polyMesh& mesh)
 :
     motionSolver(mesh),
-    fvMesh_(refCast<const fvMesh>(mesh)),
-    pointMesh_(fvMesh_),
-    vpi_(fvMesh_, pointMesh_)
+    fvMesh_(refCast<const fvMesh>(mesh))
 {}
 
 
@@ -55,16 +54,14 @@ Foam::fvMotionSolver::~fvMotionSolver()
 
 void Foam::fvMotionSolver::movePoints(const pointField& p)
 {
-    pointMesh_.movePoints(p);
-    vpi_.movePoints();
+    // Movement of pointMesh and volPointInterpolation done by polyMesh,fvMesh
 }
 
 
 void Foam::fvMotionSolver::updateMesh(const mapPolyMesh& mpm)
 {
     motionSolver::updateMesh(mpm);
-    pointMesh_.updateMesh(mpm);
-    vpi_.updateMesh();
+    // Update of pointMesh and volPointInterpolation done by polyMesh,fvMesh
 }
 
 
diff --git a/src/fvMotionSolver/fvMotionSolvers/fvMotionSolver/fvMotionSolver.H b/src/fvMotionSolver/fvMotionSolvers/fvMotionSolver/fvMotionSolver.H
index c91a3ca65e..ae5e744b70 100644
--- a/src/fvMotionSolver/fvMotionSolvers/fvMotionSolver/fvMotionSolver.H
+++ b/src/fvMotionSolver/fvMotionSolvers/fvMotionSolver/fvMotionSolver.H
@@ -40,13 +40,16 @@ SourceFiles
 #define fvMotionSolver_H
 
 #include "motionSolver.H"
-#include "volPointInterpolation.H"
+#include "pointFieldsFwd.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 namespace Foam
 {
 
+class fvMesh;
+class mapPolyMesh;
+
 /*---------------------------------------------------------------------------*\
                            Class fvMotionSolver Declaration
 \*---------------------------------------------------------------------------*/
@@ -63,13 +66,6 @@ protected:
         //- The fvMesh to be moved
         const fvMesh& fvMesh_;
 
-        //- Point mesh needed by the volPointInterpolation
-        mutable pointMesh pointMesh_;
-
-        //- Vol-point interpolator used to obtain the point motion from
-        //  the cell-centre motion
-        mutable volPointInterpolation vpi_;
-
 
     // Protected member functions
 
diff --git a/src/fvMotionSolver/fvMotionSolvers/velocity/componentLaplacian/velocityComponentLaplacianFvMotionSolver.C b/src/fvMotionSolver/fvMotionSolvers/velocity/componentLaplacian/velocityComponentLaplacianFvMotionSolver.C
index 86d5c1e32b..2cefbdec25 100644
--- a/src/fvMotionSolver/fvMotionSolvers/velocity/componentLaplacian/velocityComponentLaplacianFvMotionSolver.C
+++ b/src/fvMotionSolver/fvMotionSolvers/velocity/componentLaplacian/velocityComponentLaplacianFvMotionSolver.C
@@ -28,6 +28,7 @@ License
 #include "motionDiffusivity.H"
 #include "fvmLaplacian.H"
 #include "addToRunTimeSelectionTable.H"
+#include "volPointInterpolation.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
@@ -66,7 +67,7 @@ velocityComponentLaplacianFvMotionSolver
             IOobject::MUST_READ,
             IOobject::AUTO_WRITE
         ),
-        pointMesh_
+        pointMesh::New(fvMesh_)
     ),
     cellMotionU_
     (
@@ -129,7 +130,11 @@ Foam::velocityComponentLaplacianFvMotionSolver::
 Foam::tmp<Foam::pointField>
 Foam::velocityComponentLaplacianFvMotionSolver::curPoints() const
 {
-    vpi_.interpolate(cellMotionU_, pointMotionU_);
+    volPointInterpolation::New(fvMesh_).interpolate
+    (
+        cellMotionU_,
+        pointMotionU_
+    );
 
     tmp<pointField> tcurPoints(new pointField(fvMesh_.points()));
 
diff --git a/src/fvMotionSolver/fvMotionSolvers/velocity/laplacian/velocityLaplacianFvMotionSolver.C b/src/fvMotionSolver/fvMotionSolvers/velocity/laplacian/velocityLaplacianFvMotionSolver.C
index f259a097ca..50a06de548 100644
--- a/src/fvMotionSolver/fvMotionSolvers/velocity/laplacian/velocityLaplacianFvMotionSolver.C
+++ b/src/fvMotionSolver/fvMotionSolvers/velocity/laplacian/velocityLaplacianFvMotionSolver.C
@@ -28,6 +28,7 @@ License
 #include "motionDiffusivity.H"
 #include "fvmLaplacian.H"
 #include "addToRunTimeSelectionTable.H"
+#include "volPointInterpolation.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
@@ -63,7 +64,7 @@ Foam::velocityLaplacianFvMotionSolver::velocityLaplacianFvMotionSolver
             IOobject::MUST_READ,
             IOobject::AUTO_WRITE
         ),
-        pointMesh_
+        pointMesh::New(fvMesh_)
     ),
     cellMotionU_
     (
@@ -102,7 +103,11 @@ Foam::velocityLaplacianFvMotionSolver::~velocityLaplacianFvMotionSolver()
 Foam::tmp<Foam::pointField>
 Foam::velocityLaplacianFvMotionSolver::curPoints() const
 {
-    vpi_.interpolate(cellMotionU_, pointMotionU_);
+    volPointInterpolation::New(fvMesh_).interpolate
+    (
+        cellMotionU_,
+        pointMotionU_
+    );
 
     tmp<pointField> tcurPoints
     (
diff --git a/src/fvMotionSolver/motionDiffusivity/inversePointDistance/inversePointDistanceDiffusivity.C b/src/fvMotionSolver/motionDiffusivity/inversePointDistance/inversePointDistanceDiffusivity.C
index 9767dabc42..5859c4d356 100644
--- a/src/fvMotionSolver/motionDiffusivity/inversePointDistance/inversePointDistanceDiffusivity.C
+++ b/src/fvMotionSolver/motionDiffusivity/inversePointDistance/inversePointDistanceDiffusivity.C
@@ -73,9 +73,6 @@ void Foam::inversePointDistanceDiffusivity::correct()
     const polyMesh& mesh = mSolver().mesh();
     const polyBoundaryMesh& bdry = mesh.boundaryMesh();
 
-    // Construct point mesh
-    const pointMesh pMesh(mesh);
-
     labelHashSet patchSet(bdry.size());
 
     label nPatchEdges = 0;
@@ -133,7 +130,7 @@ void Foam::inversePointDistanceDiffusivity::correct()
         // Do calculations
         PointEdgeWave<pointEdgePoint> waveInfo
         (
-            pMesh,
+            mesh,
             seedPoints,
             seedInfo,
         
diff --git a/src/lagrangian/basic/Cloud/Cloud.H b/src/lagrangian/basic/Cloud/Cloud.H
index 270a30ce7b..0dc41403e7 100644
--- a/src/lagrangian/basic/Cloud/Cloud.H
+++ b/src/lagrangian/basic/Cloud/Cloud.H
@@ -37,7 +37,6 @@ SourceFiles
 #define Cloud_H
 
 #include "cloud.H"
-#include "pointMesh.H"
 #include "IDLList.H"
 #include "IOField.H"
 
@@ -231,8 +230,14 @@ public:
 
         // Read
 
-            //- Read and return a lagrangian data field
-            //  Checks that data is valid
+            //- Helper to construct IOobject for field and current time.
+            IOobject fieldIOobject
+            (
+                const word& fieldName,
+                const IOobject::readOption r
+            ) const;
+
+            //- Check lagrangian data field
             template<class DataType>
             void checkFieldIOobject
             (
@@ -240,13 +245,6 @@ public:
                 const IOField<DataType>& data
             ) const;
 
-            //- Read and return a lagrangian data field
-            IOobject fieldIOobject(const word& fieldName) const;
-
-            //- Read and return a lagrangian data field
-            template<class Type>
-            tmp<IOField<Type> > readField(const word& fieldName) const;
-
             //- Read the field data for the cloud of particles
             void readFields();
 
diff --git a/src/lagrangian/basic/Cloud/CloudIO.C b/src/lagrangian/basic/Cloud/CloudIO.C
index 0401955801..d9247527d3 100644
--- a/src/lagrangian/basic/Cloud/CloudIO.C
+++ b/src/lagrangian/basic/Cloud/CloudIO.C
@@ -103,6 +103,25 @@ Foam::Cloud<ParticleType>::Cloud
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
+template<class ParticleType>
+Foam::IOobject Foam::Cloud<ParticleType>::fieldIOobject
+(
+    const word& fieldName,
+    const IOobject::readOption r
+) const
+{
+    return IOobject
+    (
+        fieldName,
+        time().timeName(),
+        *this,
+        r,
+        IOobject::NO_WRITE,
+        false
+    );
+}
+
+
 template<class ParticleType>
 template<class DataType>
 void Foam::Cloud<ParticleType>::checkFieldIOobject
@@ -116,7 +135,7 @@ void Foam::Cloud<ParticleType>::checkFieldIOobject
         FatalErrorIn
         (
             "void Cloud<ParticleType>::checkFieldIOobject"
-            "(Cloud<ParticleType>, IOField<DataType>)"
+            "(const Cloud<ParticleType>&, const IOField<DataType>&) const"
         )   << "Size of " << data.name()
             << " field " << data.size()
             << " does not match the number of particles " << c.size()
@@ -125,35 +144,6 @@ void Foam::Cloud<ParticleType>::checkFieldIOobject
 }
 
 
-template<class ParticleType>
-Foam::IOobject Foam::Cloud<ParticleType>::fieldIOobject
-(
-    const word& fieldName
-) const
-{
-    return IOobject
-    (
-        fieldName,
-        time().timeName(),
-        *this,
-        IOobject::MUST_READ,
-        IOobject::NO_WRITE,
-        false
-    );
-}
-
-
-template<class ParticleType>
-template<class Type>
-Foam::tmp<Foam::IOField<Type> > Foam::Cloud<ParticleType>::readField
-(
-    const word& fieldName
-) const
-{
-    return tmp<IOField<Type> >(new IOField<Type>(fieldIOobject(fieldName)));
-}
-
-
 template<class ParticleType>
 void Foam::Cloud<ParticleType>::readFields()
 {}
diff --git a/src/lagrangian/dieselSpray/parcel/parcelIO.C b/src/lagrangian/dieselSpray/parcel/parcelIO.C
index cbc432eb31..5f31f40212 100644
--- a/src/lagrangian/dieselSpray/parcel/parcelIO.C
+++ b/src/lagrangian/dieselSpray/parcel/parcelIO.C
@@ -106,43 +106,46 @@ void Foam::parcel::readFields
         return;
     }
 
-    IOField<scalar> d(c.fieldIOobject("d"));
+    IOField<scalar> d(c.fieldIOobject("d", IOobject::MUST_READ));
     c.checkFieldIOobject(c, d);
 
-    IOField<scalar> T(c.fieldIOobject("T"));
+    IOField<scalar> T(c.fieldIOobject("T", IOobject::MUST_READ));
     c.checkFieldIOobject(c, T);
 
-    IOField<scalar> m(c.fieldIOobject("m"));
+    IOField<scalar> m(c.fieldIOobject("m", IOobject::MUST_READ));
     c.checkFieldIOobject(c, m);
 
-    IOField<scalar> y(c.fieldIOobject("y"));
+    IOField<scalar> y(c.fieldIOobject("y", IOobject::MUST_READ));
     c.checkFieldIOobject(c, y);
 
-    IOField<scalar> yDot(c.fieldIOobject("yDot"));
+    IOField<scalar> yDot(c.fieldIOobject("yDot", IOobject::MUST_READ));
     c.checkFieldIOobject(c, yDot);
 
-    IOField<scalar> ct(c.fieldIOobject("ct"));
+    IOField<scalar> ct(c.fieldIOobject("ct", IOobject::MUST_READ));
     c.checkFieldIOobject(c, ct);
 
-    IOField<scalar> ms(c.fieldIOobject("ms"));
+    IOField<scalar> ms(c.fieldIOobject("ms", IOobject::MUST_READ));
     c.checkFieldIOobject(c, ms);
 
-    IOField<scalar> tTurb(c.fieldIOobject("tTurb"));
+    IOField<scalar> tTurb(c.fieldIOobject("tTurb", IOobject::MUST_READ));
     c.checkFieldIOobject(c, tTurb);
 
-    IOField<scalar> liquidCore(c.fieldIOobject("liquidCore"));
+    IOField<scalar> liquidCore
+    (
+        c.fieldIOobject("liquidCore", IOobject::MUST_READ)
+    );
     c.checkFieldIOobject(c, liquidCore);
 
-    IOField<scalar> injector(c.fieldIOobject("injector"));
+    IOField<scalar> injector(c.fieldIOobject("injector", IOobject::MUST_READ));
     c.checkFieldIOobject(c, injector);
 
-    IOField<vector> U(c.fieldIOobject("U"));
+    IOField<vector> U(c.fieldIOobject("U", IOobject::MUST_READ));
     c.checkFieldIOobject(c, U);
 
-    IOField<vector> Uturb(c.fieldIOobject("Uturb"));
+    IOField<vector> Uturb(c.fieldIOobject("Uturb", IOobject::MUST_READ));
     c.checkFieldIOobject(c, Uturb);
 
-    IOField<vector> n(c.fieldIOobject("n"));
+    IOField<vector> n(c.fieldIOobject("n", IOobject::MUST_READ));
     c.checkFieldIOobject(c, n);
 
     label i = 0;
@@ -179,7 +182,7 @@ void Foam::parcel::readFields
 
         for (label j=0; j<nX; j++)
         {
-            IOField<scalar> X(c.fieldIOobject(names[j]));
+            IOField<scalar> X(c.fieldIOobject(names[j], IOobject::MUST_READ));
 
             label i = 0;
             forAllIter(Cloud<parcel>, c, iter)
@@ -201,20 +204,27 @@ void Foam::parcel::writeFields
 
     label np = c.size();
 
-    IOField<scalar> d(c.fieldIOobject("d"), np);
-    IOField<scalar> T(c.fieldIOobject("T"), np);
-    IOField<scalar> m(c.fieldIOobject("m"), np);
-    IOField<scalar> y(c.fieldIOobject("y"), np);
-    IOField<scalar> yDot(c.fieldIOobject("yDot"), np);
-    IOField<scalar> ct(c.fieldIOobject("ct"), np);
-    IOField<scalar> ms(c.fieldIOobject("ms"), np);
-    IOField<scalar> tTurb(c.fieldIOobject("tTurb"), np);
-    IOField<scalar> liquidCore(c.fieldIOobject("liquidCore"), np);
-    IOField<scalar> injector(c.fieldIOobject("injector"), np);
-
-    IOField<vector> U(c.fieldIOobject("U"), np);
-    IOField<vector> Uturb(c.fieldIOobject("Uturb"), np);
-    IOField<vector> n(c.fieldIOobject("n"), np);
+    IOField<scalar> d(c.fieldIOobject("d", IOobject::NO_READ), np);
+    IOField<scalar> T(c.fieldIOobject("T", IOobject::NO_READ), np);
+    IOField<scalar> m(c.fieldIOobject("m", IOobject::NO_READ), np);
+    IOField<scalar> y(c.fieldIOobject("y", IOobject::NO_READ), np);
+    IOField<scalar> yDot(c.fieldIOobject("yDot", IOobject::NO_READ), np);
+    IOField<scalar> ct(c.fieldIOobject("ct", IOobject::NO_READ), np);
+    IOField<scalar> ms(c.fieldIOobject("ms", IOobject::NO_READ), np);
+    IOField<scalar> tTurb(c.fieldIOobject("tTurb", IOobject::NO_READ), np);
+    IOField<scalar> liquidCore
+    (
+        c.fieldIOobject("liquidCore", IOobject::NO_READ),
+        np
+    );
+    IOField<scalar> injector
+    (
+        c.fieldIOobject("injector", IOobject::NO_READ),
+        np
+    );
+    IOField<vector> U(c.fieldIOobject("U", IOobject::NO_READ), np);
+    IOField<vector> Uturb(c.fieldIOobject("Uturb", IOobject::NO_READ), np);
+    IOField<vector> n(c.fieldIOobject("n", IOobject::NO_READ), np);
 
     label i = 0;
     forAllConstIter(Cloud<parcel>, c, iter)
@@ -265,7 +275,7 @@ void Foam::parcel::writeFields
 
         for (label j=0; j<nX; j++)
         {
-            IOField<scalar> X(c.fieldIOobject(names[j]), np);
+            IOField<scalar> X(c.fieldIOobject(names[j], IOobject::NO_READ), np);
 
             label i = 0;
             forAllConstIter(Cloud<parcel>, c, iter)
diff --git a/src/lagrangian/dieselSpray/spray/spray.C b/src/lagrangian/dieselSpray/spray/spray.C
index fb9e16bc9b..4aa5c775ef 100644
--- a/src/lagrangian/dieselSpray/spray/spray.C
+++ b/src/lagrangian/dieselSpray/spray/spray.C
@@ -52,7 +52,6 @@ defineTemplateTypeNameAndDebug(IOPtrList<injector>, 0);
 // Construct from components
 Foam::spray::spray
 (
-    const volPointInterpolation& vpi,
     const volVectorField& U,
     const volScalarField& rho,
     const volScalarField& p,
@@ -67,7 +66,6 @@ Foam::spray::spray
     runTime_(U.time()),
     time0_(runTime_.value()),
     mesh_(U.mesh()),
-    volPointInterpolation_(vpi),
     rndGen_(label(0)),
 
     U_(U),
@@ -263,7 +261,7 @@ Foam::spray::spray
         {
             FatalErrorIn
             (
-                "spray::spray(const pointMesh& pMesh, const volVectorField& U, "
+                "spray::spray(const volVectorField& U, "
                 "const volScalarField& rho, const volScalarField& p, "
                 "const volScalarField& T, const combustionMixture& composition,"
                 "const PtrList<specieProperties>& gaseousFuelProperties, "
diff --git a/src/lagrangian/dieselSpray/spray/spray.H b/src/lagrangian/dieselSpray/spray/spray.H
index 83c93c16f0..603d0c8b68 100644
--- a/src/lagrangian/dieselSpray/spray/spray.H
+++ b/src/lagrangian/dieselSpray/spray/spray.H
@@ -36,7 +36,6 @@ Description
 #include "parcel.H"
 #include "injector.H"
 #include "IOPtrList.H"
-#include "volPointInterpolation.H"
 #include "interpolation.H"
 #include "liquid.H"
 #include "sprayThermoTypes.H"
@@ -76,7 +75,6 @@ class spray
             const Time& runTime_;
             scalar time0_;
             const fvMesh& mesh_;
-            const volPointInterpolation& volPointInterpolation_;
 
             //- Random number generator
             Random rndGen_;
@@ -189,7 +187,6 @@ public:
         //- Construct from components
         spray
         (
-            const volPointInterpolation& vpi,
             const volVectorField& U,
             const volScalarField& rho,
             const volScalarField& p,
diff --git a/src/lagrangian/dieselSpray/spray/sprayOps.C b/src/lagrangian/dieselSpray/spray/sprayOps.C
index 048080ae0c..58199f3c72 100644
--- a/src/lagrangian/dieselSpray/spray/sprayOps.C
+++ b/src/lagrangian/dieselSpray/spray/sprayOps.C
@@ -49,33 +49,13 @@ void spray::evolve()
         srhos_[i].setSize(rho_.size());
     }
 
-    UInterpolator_ = interpolation<vector>::New
-    (
-        interpolationSchemes_,
-        volPointInterpolation_,
-        U_
-    );
+    UInterpolator_ = interpolation<vector>::New(interpolationSchemes_, U_);
 
-    rhoInterpolator_ = interpolation<scalar>::New
-    (
-        interpolationSchemes_,
-        volPointInterpolation_,
-        rho_
-    );
+    rhoInterpolator_ = interpolation<scalar>::New(interpolationSchemes_, rho_);
 
-    pInterpolator_ = interpolation<scalar>::New
-    (
-        interpolationSchemes_,
-        volPointInterpolation_,
-        p_
-    );
+    pInterpolator_ = interpolation<scalar>::New(interpolationSchemes_, p_);
 
-    TInterpolator_ = interpolation<scalar>::New
-    (
-        interpolationSchemes_,
-        volPointInterpolation_,
-        T_
-    );
+    TInterpolator_ = interpolation<scalar>::New(interpolationSchemes_, T_);
 
     calculateAmbientPressure();
     calculateAmbientTemperature();
diff --git a/src/lagrangian/intermediate/clouds/Templates/KinematicCloud/KinematicCloud.C b/src/lagrangian/intermediate/clouds/Templates/KinematicCloud/KinematicCloud.C
index 6ee04f1235..dc32224a00 100644
--- a/src/lagrangian/intermediate/clouds/Templates/KinematicCloud/KinematicCloud.C
+++ b/src/lagrangian/intermediate/clouds/Templates/KinematicCloud/KinematicCloud.C
@@ -29,10 +29,9 @@ License
 #include "DragModel.H"
 #include "InjectionModel.H"
 #include "WallInteractionModel.H"
-
 #include "IntegrationScheme.H"
+#include "interpolation.H"
 
-#include "interpolationCellPoint.H"
 
 // * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * * //
 
@@ -142,7 +141,6 @@ template<class ParcelType>
 Foam::KinematicCloud<ParcelType>::KinematicCloud
 (
     const word& cloudType,
-    const volPointInterpolation& vpi,
     const volScalarField& rho,
     const volVectorField& U,
     const volScalarField& mu,
@@ -153,7 +151,6 @@ Foam::KinematicCloud<ParcelType>::KinematicCloud
     kinematicCloud(),
     cloudType_(cloudType),
     mesh_(rho.mesh()),
-    vpi_(vpi),
     particleProperties_
     (
         IOobject
@@ -267,7 +264,7 @@ Foam::KinematicCloud<ParcelType>::KinematicCloud
         FatalErrorIn
         (
             "Foam::KinematicCloud<ParcelType>::KinematicCloud"
-            "(const word&, const volPointInterpolation&, const volScalarField&"
+            "(const word&, const volScalarField&"
             ", const volVectorField&, const volScalarField&, const "
             "dimensionedVector&)"
         )<< "parcelBasisType must be either 'number' or 'mass'" << nl
@@ -300,7 +297,6 @@ void Foam::KinematicCloud<ParcelType>::evolve()
         interpolation<scalar>::New
         (
             interpolationSchemes_,
-            vpi_,
             rho_
         );
 
@@ -308,7 +304,6 @@ void Foam::KinematicCloud<ParcelType>::evolve()
         interpolation<vector>::New
         (
             interpolationSchemes_,
-            vpi_,
             U_
         );
 
@@ -316,7 +311,6 @@ void Foam::KinematicCloud<ParcelType>::evolve()
         interpolation<scalar>::New
         (
             interpolationSchemes_,
-            vpi_,
             mu_
         );
 
diff --git a/src/lagrangian/intermediate/clouds/Templates/KinematicCloud/KinematicCloud.H b/src/lagrangian/intermediate/clouds/Templates/KinematicCloud/KinematicCloud.H
index da0f1738e5..ebd298c44e 100644
--- a/src/lagrangian/intermediate/clouds/Templates/KinematicCloud/KinematicCloud.H
+++ b/src/lagrangian/intermediate/clouds/Templates/KinematicCloud/KinematicCloud.H
@@ -50,7 +50,6 @@ SourceFiles
 #include "Random.H"
 #include "fvMesh.H"
 #include "volFields.H"
-#include "volPointInterpolation.H"
 #include "fvMatrices.H"
 #include "fvm.H"
 
@@ -110,9 +109,6 @@ private:
         //- References to the mesh and time databases
         const fvMesh& mesh_;
 
-        //- Reference to the interpolation for the carrier phase to the parcels
-        const volPointInterpolation& vpi_;
-
         //- Dictionary of particle properties
         IOdictionary particleProperties_;
 
@@ -268,7 +264,6 @@ public:
         KinematicCloud
         (
             const word& cloudType,
-            const volPointInterpolation& vpi,
             const volScalarField& rho,
             const volVectorField& U,
             const volScalarField& mu,
@@ -295,9 +290,6 @@ public:
                 //- Return refernce to the mesh
                 inline const fvMesh& mesh() const;
 
-                //- Retuen reference to the interpolation
-                inline const volPointInterpolation& vpi() const;
-
                 //- Return particle properties dictionary
                 inline const IOdictionary& particleProperties() const;
 
diff --git a/src/lagrangian/intermediate/clouds/Templates/KinematicCloud/KinematicCloudI.H b/src/lagrangian/intermediate/clouds/Templates/KinematicCloud/KinematicCloudI.H
index c7196c57cd..73a891dcb3 100644
--- a/src/lagrangian/intermediate/clouds/Templates/KinematicCloud/KinematicCloudI.H
+++ b/src/lagrangian/intermediate/clouds/Templates/KinematicCloud/KinematicCloudI.H
@@ -47,14 +47,6 @@ inline const Foam::fvMesh& Foam::KinematicCloud<ParcelType>::mesh() const
 }
 
 
-template<class ParcelType>
-inline const Foam::volPointInterpolation&
-Foam::KinematicCloud<ParcelType>::vpi() const
-{
-    return vpi_;
-}
-
-
 template<class ParcelType>
 inline const Foam::IOdictionary&
 Foam::KinematicCloud<ParcelType>::particleProperties() const
diff --git a/src/lagrangian/intermediate/clouds/Templates/ReactingCloud/ReactingCloud.C b/src/lagrangian/intermediate/clouds/Templates/ReactingCloud/ReactingCloud.C
index ffef30b10d..1f358d6f6c 100644
--- a/src/lagrangian/intermediate/clouds/Templates/ReactingCloud/ReactingCloud.C
+++ b/src/lagrangian/intermediate/clouds/Templates/ReactingCloud/ReactingCloud.C
@@ -29,15 +29,12 @@ License
 #include "MassTransferModel.H"
 #include "SurfaceReactionModel.H"
 
-#include "interpolationCellPoint.H"
-
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
 template<class ParcelType>
 Foam::ReactingCloud<ParcelType>::ReactingCloud
 (
     const word& cloudType,
-    const volPointInterpolation& vpi,
     const volScalarField& rho,
     const volVectorField& U,
     const dimensionedVector& g,
@@ -45,7 +42,7 @@ Foam::ReactingCloud<ParcelType>::ReactingCloud
     PtrList<specieReactingProperties>& gases
 )
 :
-    ThermoCloud<ParcelType>(cloudType, vpi, rho, U, g, thermo),
+    ThermoCloud<ParcelType>(cloudType, rho, U, g, thermo),
     reactingCloud(),
     constProps_(this->particleProperties()),
     carrierThermo_(thermo),
@@ -131,42 +128,36 @@ void Foam::ReactingCloud<ParcelType>::evolve()
     autoPtr<interpolation<scalar> > rhoInterpolator = interpolation<scalar>::New
     (
         this->interpolationSchemes(),
-        this->vpi(),
         this->rho()
     );
 
     autoPtr<interpolation<vector> > UInterpolator = interpolation<vector>::New
     (
         this->interpolationSchemes(),
-        this->vpi(),
         this->U()
     );
 
     autoPtr<interpolation<scalar> > muInterpolator = interpolation<scalar>::New
     (
         this->interpolationSchemes(),
-        this->vpi(),
         this->mu()
     );
 
     autoPtr<interpolation<scalar> > TInterpolator = interpolation<scalar>::New
     (
         this->interpolationSchemes(),
-        this->vpi(),
         T
     );
 
     autoPtr<interpolation<scalar> > cpInterpolator = interpolation<scalar>::New
     (
         this->interpolationSchemes(),
-        this->vpi(),
         cp
     );
 
     autoPtr<interpolation<scalar> > pInterpolator = interpolation<scalar>::New
     (
         this->interpolationSchemes(),
-        this->vpi(),
         p
     );
 
diff --git a/src/lagrangian/intermediate/clouds/Templates/ReactingCloud/ReactingCloud.H b/src/lagrangian/intermediate/clouds/Templates/ReactingCloud/ReactingCloud.H
index 6f7bb05e09..d1c60f5a97 100644
--- a/src/lagrangian/intermediate/clouds/Templates/ReactingCloud/ReactingCloud.H
+++ b/src/lagrangian/intermediate/clouds/Templates/ReactingCloud/ReactingCloud.H
@@ -133,7 +133,6 @@ public:
         ReactingCloud
         (
             const word& cloudType,
-            const volPointInterpolation& vpi,
             const volScalarField& rho,
             const volVectorField& U,
             const dimensionedVector& g,
diff --git a/src/lagrangian/intermediate/clouds/Templates/ThermoCloud/ThermoCloud.C b/src/lagrangian/intermediate/clouds/Templates/ThermoCloud/ThermoCloud.C
index ad0d520b74..c585d22fd3 100644
--- a/src/lagrangian/intermediate/clouds/Templates/ThermoCloud/ThermoCloud.C
+++ b/src/lagrangian/intermediate/clouds/Templates/ThermoCloud/ThermoCloud.C
@@ -36,7 +36,6 @@ template<class ParcelType>
 Foam::ThermoCloud<ParcelType>::ThermoCloud
 (
     const word& cloudType,
-    const volPointInterpolation& vpi,
     const volScalarField& rho,
     const volVectorField& U,
     const dimensionedVector& g,
@@ -46,7 +45,6 @@ Foam::ThermoCloud<ParcelType>::ThermoCloud
     KinematicCloud<ParcelType>
     (
         cloudType,
-        vpi,
         rho,
         U,
         thermo.mu(),
@@ -130,35 +128,30 @@ void Foam::ThermoCloud<ParcelType>::evolve()
     autoPtr<interpolation<scalar> > rhoInterpolator = interpolation<scalar>::New
     (
         this->interpolationSchemes(),
-        this->vpi(),
         this->rho()
     );
 
     autoPtr<interpolation<vector> > UInterpolator = interpolation<vector>::New
     (
         this->interpolationSchemes(),
-        this->vpi(),
         this->U()
     );
 
     autoPtr<interpolation<scalar> > muInterpolator = interpolation<scalar>::New
     (
         this->interpolationSchemes(),
-        this->vpi(),
         this->mu()
     );
 
     autoPtr<interpolation<scalar> > TInterpolator = interpolation<scalar>::New
     (
         this->interpolationSchemes(),
-        this->vpi(),
         T
     );
 
     autoPtr<interpolation<scalar> > cpInterpolator = interpolation<scalar>::New
     (
         this->interpolationSchemes(),
-        this->vpi(),
         cp
     );
 
diff --git a/src/lagrangian/intermediate/clouds/Templates/ThermoCloud/ThermoCloud.H b/src/lagrangian/intermediate/clouds/Templates/ThermoCloud/ThermoCloud.H
index 072c86165b..ba7930af30 100644
--- a/src/lagrangian/intermediate/clouds/Templates/ThermoCloud/ThermoCloud.H
+++ b/src/lagrangian/intermediate/clouds/Templates/ThermoCloud/ThermoCloud.H
@@ -135,7 +135,6 @@ public:
         ThermoCloud
         (
             const word& cloudType,
-            const volPointInterpolation& vpi,
             const volScalarField& rho,
             const volVectorField& U,
             const dimensionedVector& g,
diff --git a/src/lagrangian/intermediate/clouds/derived/basicKinematicCloud/basicKinematicCloud.C b/src/lagrangian/intermediate/clouds/derived/basicKinematicCloud/basicKinematicCloud.C
index 587edfda5a..a7d2d126be 100644
--- a/src/lagrangian/intermediate/clouds/derived/basicKinematicCloud/basicKinematicCloud.C
+++ b/src/lagrangian/intermediate/clouds/derived/basicKinematicCloud/basicKinematicCloud.C
@@ -39,14 +39,13 @@ namespace Foam
 Foam::basicKinematicCloud::basicKinematicCloud
 (
     const word& cloudType,
-    const volPointInterpolation& vpi,
     const volScalarField& rho,
     const volVectorField& U,
     const volScalarField& mu,
     const dimensionedVector& g
 )
 :
-    KinematicCloud<basicKinematicParcel>(cloudType, vpi, rho, U, mu, g)
+    KinematicCloud<basicKinematicParcel>(cloudType, rho, U, mu, g)
 {
     basicKinematicParcel::readFields(*this);
 }
diff --git a/src/lagrangian/intermediate/clouds/derived/basicKinematicCloud/basicKinematicCloud.H b/src/lagrangian/intermediate/clouds/derived/basicKinematicCloud/basicKinematicCloud.H
index a2b0c1663c..1ab9ac4ef6 100644
--- a/src/lagrangian/intermediate/clouds/derived/basicKinematicCloud/basicKinematicCloud.H
+++ b/src/lagrangian/intermediate/clouds/derived/basicKinematicCloud/basicKinematicCloud.H
@@ -74,7 +74,6 @@ public:
         basicKinematicCloud
         (
             const word& cloudType,
-            const volPointInterpolation& vpi,
             const volScalarField& rho,
             const volVectorField& U,
             const volScalarField& mu,
diff --git a/src/lagrangian/intermediate/clouds/derived/basicReactingCloud/basicReactingCloud.C b/src/lagrangian/intermediate/clouds/derived/basicReactingCloud/basicReactingCloud.C
index ed95352309..708b428542 100644
--- a/src/lagrangian/intermediate/clouds/derived/basicReactingCloud/basicReactingCloud.C
+++ b/src/lagrangian/intermediate/clouds/derived/basicReactingCloud/basicReactingCloud.C
@@ -39,7 +39,6 @@ namespace Foam
 Foam::basicReactingCloud::basicReactingCloud
 (
     const word& cloudType,
-    const volPointInterpolation& vpi,
     const volScalarField& rho,
     const volVectorField& U,
     const dimensionedVector& g,
@@ -50,7 +49,6 @@ Foam::basicReactingCloud::basicReactingCloud
     ReactingCloud<basicReactingParcel>
     (
         cloudType,
-        vpi,
         rho,
         U,
         g,
diff --git a/src/lagrangian/intermediate/clouds/derived/basicReactingCloud/basicReactingCloud.H b/src/lagrangian/intermediate/clouds/derived/basicReactingCloud/basicReactingCloud.H
index fe608d19c5..c547c783a9 100644
--- a/src/lagrangian/intermediate/clouds/derived/basicReactingCloud/basicReactingCloud.H
+++ b/src/lagrangian/intermediate/clouds/derived/basicReactingCloud/basicReactingCloud.H
@@ -73,7 +73,6 @@ public:
         basicReactingCloud
         (
             const word& cloudType,
-            const volPointInterpolation& vpi,
             const volScalarField& rho,
             const volVectorField& U,
             const dimensionedVector& g,
diff --git a/src/lagrangian/intermediate/clouds/derived/basicThermoCloud/basicThermoCloud.C b/src/lagrangian/intermediate/clouds/derived/basicThermoCloud/basicThermoCloud.C
index 118da0a00e..eb2450c724 100644
--- a/src/lagrangian/intermediate/clouds/derived/basicThermoCloud/basicThermoCloud.C
+++ b/src/lagrangian/intermediate/clouds/derived/basicThermoCloud/basicThermoCloud.C
@@ -39,14 +39,13 @@ namespace Foam
 Foam::basicThermoCloud::basicThermoCloud
 (
     const word& cloudType,
-    const volPointInterpolation& vpi,
     const volScalarField& rho,
     const volVectorField& U,
     const dimensionedVector& g,
     basicThermo& thermo
 )
 :
-    ThermoCloud<basicThermoParcel>(cloudType, vpi, rho, U, g, thermo)
+    ThermoCloud<basicThermoParcel>(cloudType, rho, U, g, thermo)
 {
     basicThermoParcel::readFields(*this);
 }
diff --git a/src/lagrangian/intermediate/clouds/derived/basicThermoCloud/basicThermoCloud.H b/src/lagrangian/intermediate/clouds/derived/basicThermoCloud/basicThermoCloud.H
index ba5f776c76..81f3c26302 100644
--- a/src/lagrangian/intermediate/clouds/derived/basicThermoCloud/basicThermoCloud.H
+++ b/src/lagrangian/intermediate/clouds/derived/basicThermoCloud/basicThermoCloud.H
@@ -76,7 +76,6 @@ public:
         basicThermoCloud
         (
             const word& cloudType,
-            const volPointInterpolation& vpi,
             const volScalarField& rho,
             const volVectorField& U,
             const dimensionedVector& g,
diff --git a/src/lagrangian/intermediate/parcels/Templates/KinematicParcel/KinematicParcelIO.C b/src/lagrangian/intermediate/parcels/Templates/KinematicParcel/KinematicParcelIO.C
index b000ed0237..c51524bc97 100644
--- a/src/lagrangian/intermediate/parcels/Templates/KinematicParcel/KinematicParcelIO.C
+++ b/src/lagrangian/intermediate/parcels/Templates/KinematicParcel/KinematicParcelIO.C
@@ -26,6 +26,8 @@ License
 
 #include "KinematicParcel.H"
 #include "IOstreams.H"
+#include "IOField.H"
+#include "Cloud.H"
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
@@ -97,25 +99,25 @@ void Foam::KinematicParcel<ParcelType>::readFields
         return;
     }
 
-    IOField<label> typeId(c.fieldIOobject("typeId"));
+    IOField<label> typeId(c.fieldIOobject("typeId", IOobject::MUST_READ));
     c.checkFieldIOobject(c, typeId);
 
-    IOField<scalar> d(c.fieldIOobject("d"));
+    IOField<scalar> d(c.fieldIOobject("d", IOobject::MUST_READ));
     c.checkFieldIOobject(c, d);
 
-    IOField<vector> U(c.fieldIOobject("U"));
+    IOField<vector> U(c.fieldIOobject("U", IOobject::MUST_READ));
     c.checkFieldIOobject(c, U);
 
-    IOField<scalar> nParticle(c.fieldIOobject("nParticle"));
+    IOField<scalar> nParticle(c.fieldIOobject("nParticle", IOobject::MUST_READ));
     c.checkFieldIOobject(c, nParticle);
 
-    IOField<scalar> rho(c.fieldIOobject("rho"));
+    IOField<scalar> rho(c.fieldIOobject("rho", IOobject::MUST_READ));
     c.checkFieldIOobject(c, rho);
 
-    IOField<scalar> tTurb(c.fieldIOobject("tTurb"));
+    IOField<scalar> tTurb(c.fieldIOobject("tTurb", IOobject::MUST_READ));
     c.checkFieldIOobject(c, tTurb);
 
-    IOField<vector> UTurb(c.fieldIOobject("UTurb"));
+    IOField<vector> UTurb(c.fieldIOobject("UTurb", IOobject::MUST_READ));
     c.checkFieldIOobject(c, UTurb);
 
     label i = 0;
@@ -145,13 +147,17 @@ void Foam::KinematicParcel<ParcelType>::writeFields
 
     label np =  c.size();
 
-    IOField<label> typeId(c.fieldIOobject("typeId"), np);
-    IOField<scalar> d(c.fieldIOobject("d"), np);
-    IOField<vector> U(c.fieldIOobject("U"), np);
-    IOField<scalar> nParticle(c.fieldIOobject("nParticle"), np);
-    IOField<scalar> rho(c.fieldIOobject("rho"), np);
-    IOField<scalar> tTurb(c.fieldIOobject("tTurb"), np);
-    IOField<vector> UTurb(c.fieldIOobject("UTurb"), np);
+    IOField<label> typeId(c.fieldIOobject("typeId", IOobject::NO_READ), np);
+    IOField<scalar> d(c.fieldIOobject("d", IOobject::NO_READ), np);
+    IOField<vector> U(c.fieldIOobject("U", IOobject::NO_READ), np);
+    IOField<scalar> nParticle
+    (
+        c.fieldIOobject("nParticle", IOobject::NO_READ),
+        np
+    );
+    IOField<scalar> rho(c.fieldIOobject("rho", IOobject::NO_READ), np);
+    IOField<scalar> tTurb(c.fieldIOobject("tTurb", IOobject::NO_READ), np);
+    IOField<vector> UTurb(c.fieldIOobject("UTurb", IOobject::NO_READ), np);
 
     label i = 0;
     forAllConstIter(typename Cloud<ParcelType>, c, iter)
diff --git a/src/lagrangian/intermediate/parcels/Templates/ReactingParcel/ReactingParcelIO.C b/src/lagrangian/intermediate/parcels/Templates/ReactingParcel/ReactingParcelIO.C
index b1797b97de..c971b2658a 100644
--- a/src/lagrangian/intermediate/parcels/Templates/ReactingParcel/ReactingParcelIO.C
+++ b/src/lagrangian/intermediate/parcels/Templates/ReactingParcel/ReactingParcelIO.C
@@ -103,7 +103,7 @@ void Foam::ReactingParcel<ParcelType>::readFields
 
     ThermoParcel<ParcelType>::readFields(c);
 
-    IOField<scalar> mass0(c.fieldIOobject("mass0"));
+    IOField<scalar> mass0(c.fieldIOobject("mass0", IOobject::MUST_READ));
     c.checkFieldIOobject(c, mass0);
 
     label i = 0;
@@ -136,7 +136,10 @@ void Foam::ReactingParcel<ParcelType>::readFields
     // Populate YMixture for each parcel
     forAll(compositionNames, j)
     {
-        IOField<scalar> YMixture(c.fieldIOobject("Y" + compositionNames[j]));
+        IOField<scalar> YMixture
+        (
+            c.fieldIOobject("Y" + compositionNames[j], IOobject::MUST_READ)
+        );
 
         label i = 0;
         forAllIter(typename Cloud<ParcelType>, c, iter)
@@ -148,7 +151,10 @@ void Foam::ReactingParcel<ParcelType>::readFields
     // Populate YGas for each parcel
     forAll(gasNames, j)
     {
-        IOField<scalar> YGas(c.fieldIOobject("Y" + gasNames[j]));
+        IOField<scalar> YGas
+        (
+            c.fieldIOobject("Y" + gasNames[j], IOobject::MUST_READ)
+        );
 
         label i = 0;
         forAllIter(typename Cloud<ParcelType>, c, iter)
@@ -160,7 +166,10 @@ void Foam::ReactingParcel<ParcelType>::readFields
     // Populate YLiquid for each parcel
     forAll(liquidNames, j)
     {
-        IOField<scalar> YLiquid(c.fieldIOobject("Y" + liquidNames[j]));
+        IOField<scalar> YLiquid
+        (
+            c.fieldIOobject("Y" + liquidNames[j], IOobject::MUST_READ)
+        );
 
         label i = 0;
         forAllIter(typename Cloud<ParcelType>, c, iter)
@@ -172,7 +181,10 @@ void Foam::ReactingParcel<ParcelType>::readFields
     // Populate YSolid for each parcel
     forAll(solidNames, j)
     {
-        IOField<scalar> YSolid(c.fieldIOobject("Y" + solidNames[j]));
+        IOField<scalar> YSolid
+        (
+            c.fieldIOobject("Y" + solidNames[j], IOobject::MUST_READ)
+        );
 
         label i = 0;
         forAllIter(typename Cloud<ParcelType>, c, iter)
@@ -194,7 +206,7 @@ void Foam::ReactingParcel<ParcelType>::writeFields
 
     label np =  c.size();
 
-    IOField<scalar> mass0(c.fieldIOobject("mass0"), np);
+    IOField<scalar> mass0(c.fieldIOobject("mass0", IOobject::NO_READ), np);
 
     label i = 0;
     forAllConstIter(typename Cloud<ParcelType>, c, iter)
@@ -213,7 +225,8 @@ void Foam::ReactingParcel<ParcelType>::writeFields
         {
             IOField<scalar> YMixture
             (
-                c.fieldIOobject("Y" + compositionNames[j]), np
+                c.fieldIOobject("Y" + compositionNames[j], IOobject::NO_READ),
+                np
             );
 
             label i = 0;
@@ -228,7 +241,11 @@ void Foam::ReactingParcel<ParcelType>::writeFields
         const wordList& gasNames = c.composition().gasNames();
         forAll(gasNames, j)
         {
-            IOField<scalar> YGas(c.fieldIOobject("Y" + gasNames[j]), np);
+            IOField<scalar> YGas
+            (
+                c.fieldIOobject("Y" + gasNames[j], IOobject::NO_READ),
+                np
+            );
 
             label i = 0;
             forAllConstIter(typename Cloud<ParcelType>, c, iter)
@@ -242,7 +259,11 @@ void Foam::ReactingParcel<ParcelType>::writeFields
         const wordList& liquidNames = c.composition().liquidNames();
         forAll(liquidNames, j)
         {
-            IOField<scalar> YLiquid(c.fieldIOobject("Y" + liquidNames[j]), np);
+            IOField<scalar> YLiquid
+            (
+                c.fieldIOobject("Y" + liquidNames[j], IOobject::NO_READ),
+                np
+            );
 
             label i = 0;
             forAllConstIter(typename Cloud<ParcelType>, c, iter)
@@ -256,7 +277,11 @@ void Foam::ReactingParcel<ParcelType>::writeFields
         const wordList& solidNames = c.composition().solidNames();
         forAll(solidNames, j)
         {
-            IOField<scalar> YSolid(c.fieldIOobject("Y" + solidNames[j]), np);
+            IOField<scalar> YSolid
+            (
+                c.fieldIOobject("Y" + solidNames[j], IOobject::NO_READ),
+                np
+            );
 
             label i = 0;
             forAllConstIter(typename Cloud<ParcelType>, c, iter)
diff --git a/src/lagrangian/intermediate/parcels/Templates/ThermoParcel/ThermoParcelIO.C b/src/lagrangian/intermediate/parcels/Templates/ThermoParcel/ThermoParcelIO.C
index d0242e5e51..6c704e1a14 100644
--- a/src/lagrangian/intermediate/parcels/Templates/ThermoParcel/ThermoParcelIO.C
+++ b/src/lagrangian/intermediate/parcels/Templates/ThermoParcel/ThermoParcelIO.C
@@ -82,10 +82,10 @@ void Foam::ThermoParcel<ParcelType>::readFields
 
     KinematicParcel<ParcelType>::readFields(c);
 
-    IOField<scalar> T(c.fieldIOobject("T"));
+    IOField<scalar> T(c.fieldIOobject("T", IOobject::MUST_READ));
     c.checkFieldIOobject(c, T);
 
-    IOField<scalar> cp(c.fieldIOobject("cp"));
+    IOField<scalar> cp(c.fieldIOobject("cp", IOobject::MUST_READ));
     c.checkFieldIOobject(c, cp);
 
 
@@ -111,8 +111,8 @@ void Foam::ThermoParcel<ParcelType>::writeFields
 
     label np =  c.size();
 
-    IOField<scalar> T(c.fieldIOobject("T"), np);
-    IOField<scalar> cp(c.fieldIOobject("cp"), np);
+    IOField<scalar> T(c.fieldIOobject("T", IOobject::NO_READ), np);
+    IOField<scalar> cp(c.fieldIOobject("cp", IOobject::NO_READ), np);
 
     label i = 0;
     forAllConstIter(typename Cloud<ParcelType>, c, iter)
diff --git a/src/lagrangian/molecularDynamics/molecule/molecule/moleculeIO.C b/src/lagrangian/molecularDynamics/molecule/molecule/moleculeIO.C
index f6b50b848e..103fe2b33c 100644
--- a/src/lagrangian/molecularDynamics/molecule/molecule/moleculeIO.C
+++ b/src/lagrangian/molecularDynamics/molecule/molecule/moleculeIO.C
@@ -85,22 +85,25 @@ void molecule::readFields(moleculeCloud& mC)
         return;
     }
 
-    IOField<label> id(mC.fieldIOobject("id"));
+    IOField<label> id(mC.fieldIOobject("id", IOobject::MUST_READ));
     mC.checkFieldIOobject(mC, id);
 
-    IOField<scalar> mass(mC.fieldIOobject("mass"));
+    IOField<scalar> mass(mC.fieldIOobject("mass", IOobject::MUST_READ));
     mC.checkFieldIOobject(mC, mass);
 
-    IOField<vector> U(mC.fieldIOobject("U"));
+    IOField<vector> U(mC.fieldIOobject("U", IOobject::MUST_READ));
     mC.checkFieldIOobject(mC, U);
 
-    IOField<vector> A(mC.fieldIOobject("A"));
+    IOField<vector> A(mC.fieldIOobject("A", IOobject::MUST_READ));
     mC.checkFieldIOobject(mC, A);
 
-    IOField<label> tethered(mC.fieldIOobject("tethered"));
+    IOField<label> tethered(mC.fieldIOobject("tethered", IOobject::MUST_READ));
     mC.checkFieldIOobject(mC, tethered);
 
-    IOField<vector> tetherPositions(mC.fieldIOobject("tetherPositions"));
+    IOField<vector> tetherPositions
+    (
+        mC.fieldIOobject("tetherPositions", IOobject::MUST_READ)
+    );
     mC.checkFieldIOobject(mC, tetherPositions);
 
     label i = 0;
@@ -127,12 +130,20 @@ void molecule::writeFields(const moleculeCloud& mC)
 
     label np =  mC.size();
 
-    IOField<label> id(mC.fieldIOobject("id"), np);
-    IOField<scalar> mass(mC.fieldIOobject("mass"), np);
-    IOField<vector> U(mC.fieldIOobject("U"), np);
-    IOField<vector> A(mC.fieldIOobject("A"), np);
-    IOField<label> tethered(mC.fieldIOobject("tethered"), np);
-    IOField<vector> tetherPositions(mC.fieldIOobject("tetherPositions"), np);
+    IOField<label> id(mC.fieldIOobject("id", IOobject::NO_READ), np);
+    IOField<scalar> mass(mC.fieldIOobject("mass", IOobject::NO_READ), np);
+    IOField<vector> U(mC.fieldIOobject("U", IOobject::NO_READ), np);
+    IOField<vector> A(mC.fieldIOobject("A", IOobject::NO_READ), np);
+    IOField<label> tethered
+    (
+        mC.fieldIOobject("tethered", IOobject::NO_READ),
+        np
+    );
+    IOField<vector> tetherPositions
+    (
+        mC.fieldIOobject("tetherPositions", IOobject::NO_READ),
+        np
+    );
 
     label i = 0;
     forAllConstIter(moleculeCloud, mC, iter)
diff --git a/src/lagrangian/solidParticle/solidParticleCloud.C b/src/lagrangian/solidParticle/solidParticleCloud.C
index 09c2fc6380..1cdc137a1b 100644
--- a/src/lagrangian/solidParticle/solidParticleCloud.C
+++ b/src/lagrangian/solidParticle/solidParticleCloud.C
@@ -28,7 +28,6 @@ License
 #include "fvMesh.H"
 #include "volFields.H"
 #include "interpolationCellPoint.H"
-#include "volPointInterpolation.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
@@ -75,12 +74,9 @@ void Foam::solidParticleCloud::move(const dimensionedVector& g)
     const volVectorField& U = mesh_.lookupObject<const volVectorField>("U");
     const volScalarField& nu = mesh_.lookupObject<const volScalarField>("nu");
 
-    pointMesh pMesh(U.mesh());
-    volPointInterpolation vpi(U.mesh(), pMesh);
-
-    interpolationCellPoint<scalar> rhoInterp(vpi, rho);
-    interpolationCellPoint<vector> UInterp(vpi, U);
-    interpolationCellPoint<scalar> nuInterp(vpi, nu);
+    interpolationCellPoint<scalar> rhoInterp(rho);
+    interpolationCellPoint<vector> UInterp(U);
+    interpolationCellPoint<scalar> nuInterp(nu);
 
     solidParticle::trackData td(*this, rhoInterp, UInterp, nuInterp, g.value());
 
diff --git a/src/lagrangian/solidParticle/solidParticleIO.C b/src/lagrangian/solidParticle/solidParticleIO.C
index 67f4ea8db5..d03b125a03 100644
--- a/src/lagrangian/solidParticle/solidParticleIO.C
+++ b/src/lagrangian/solidParticle/solidParticleIO.C
@@ -66,10 +66,10 @@ void Foam::solidParticle::readFields(Cloud<solidParticle>& c)
     {
         return;
     }
-    IOField<scalar> d(c.fieldIOobject("d"));
+    IOField<scalar> d(c.fieldIOobject("d", IOobject::MUST_READ));
     c.checkFieldIOobject(c, d);
 
-    IOField<vector> U(c.fieldIOobject("U"));
+    IOField<vector> U(c.fieldIOobject("U", IOobject::MUST_READ));
     c.checkFieldIOobject(c, U);
 
     label i = 0;
@@ -90,8 +90,8 @@ void Foam::solidParticle::writeFields(const Cloud<solidParticle>& c)
 
     label np = c.size();
 
-    IOField<scalar> d(c.fieldIOobject("d"), np);
-    IOField<vector> U(c.fieldIOobject("U"), np);
+    IOField<scalar> d(c.fieldIOobject("d", IOobject::NO_READ), np);
+    IOField<vector> U(c.fieldIOobject("U", IOobject::NO_READ), np);
 
     label i = 0;
     forAllConstIter(Cloud<solidParticle>, c, iter)
diff --git a/src/meshTools/PointEdgeWave/PointEdgeWave.C b/src/meshTools/PointEdgeWave/PointEdgeWave.C
index c0c45d93fb..31d1026f0a 100644
--- a/src/meshTools/PointEdgeWave/PointEdgeWave.C
+++ b/src/meshTools/PointEdgeWave/PointEdgeWave.C
@@ -25,7 +25,7 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "PointEdgeWave.H"
-#include "pointMesh.H"
+#include "polyMesh.H"
 #include "processorPolyPatch.H"
 #include "cyclicPolyPatch.H"
 #include "OPstream.H"
@@ -33,7 +33,6 @@ License
 #include "PstreamCombineReduceOps.H"
 #include "debug.H"
 #include "typeInfo.H"
-#include "ListOps.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
@@ -61,13 +60,11 @@ void Foam::PointEdgeWave<Type>::offset(const label val, labelList& elems)
 template <class Type>
 void Foam::PointEdgeWave<Type>::calcCyclicAddressing()
 {
-    const polyMesh& mesh = pMesh_();
-
     label cycHalf = 0;
 
-    forAll(mesh.boundaryMesh(), patchI)
+    forAll(mesh_.boundaryMesh(), patchI)
     {
-        const polyPatch& patch = mesh.boundaryMesh()[patchI];
+        const polyPatch& patch = mesh_.boundaryMesh()[patchI];
 
         if (isA<cyclicPolyPatch>(patch))
         {
@@ -75,7 +72,7 @@ void Foam::PointEdgeWave<Type>::calcCyclicAddressing()
 
             SubList<face> halfAFaces
             (
-                mesh.faces(),
+                mesh_.faces(),
                 halfSize,
                 patch.start()
             );
@@ -83,12 +80,12 @@ void Foam::PointEdgeWave<Type>::calcCyclicAddressing()
             cycHalves_.set
             (
                 cycHalf++,
-                new primitivePatch(halfAFaces, mesh.points())
+                new primitivePatch(halfAFaces, mesh_.points())
             );
 
             SubList<face> halfBFaces
             (
-                mesh.faces(),
+                mesh_.faces(),
                 halfSize,
                 patch.start() + halfSize
             );
@@ -96,7 +93,7 @@ void Foam::PointEdgeWave<Type>::calcCyclicAddressing()
             cycHalves_.set
             (
                 cycHalf++,
-                new primitivePatch(halfBFaces, mesh.points())
+                new primitivePatch(halfBFaces, mesh_.points())
             );
         }
     }
@@ -203,7 +200,7 @@ bool Foam::PointEdgeWave<Type>::updatePoint
     bool propagate =
         pointInfo.updatePoint
         (
-            pMesh_(),
+            mesh_,
             pointI,
             neighbourEdgeI,
             neighbourInfo,
@@ -249,7 +246,7 @@ bool Foam::PointEdgeWave<Type>::updatePoint
     bool propagate =
         pointInfo.updatePoint
         (
-            pMesh_(),
+            mesh_,
             pointI,
             neighbourInfo,
             tol
@@ -295,7 +292,7 @@ bool Foam::PointEdgeWave<Type>::updateEdge
     bool propagate =
         edgeInfo.updateEdge
         (
-            pMesh_(),
+            mesh_,
             edgeI,
             neighbourPointI,
             neighbourInfo,
@@ -327,9 +324,9 @@ Foam::label Foam::PointEdgeWave<Type>::countPatchType() const
 {
     label nPatches = 0;
 
-    forAll(pMesh_().boundaryMesh(), patchI)
+    forAll(mesh_.boundaryMesh(), patchI)
     {
-        if (isA<PatchType>(pMesh_().boundaryMesh()[patchI]))
+        if (isA<PatchType>(mesh_.boundaryMesh()[patchI]))
         {
             nPatches++;
         }
@@ -433,15 +430,12 @@ void Foam::PointEdgeWave<Type>::updateFromPatchInfo
 template <class Type>
 void Foam::PointEdgeWave<Type>::handleProcPatches()
 {
-    const polyMesh& mesh = pMesh_();
-
-
     // 1. Send all point info on processor patches. Send as
     // face label + offset in face.
 
-    forAll(mesh.boundaryMesh(), patchI)
+    forAll(mesh_.boundaryMesh(), patchI)
     {
-        const polyPatch& patch = mesh.boundaryMesh()[patchI];
+        const polyPatch& patch = mesh_.boundaryMesh()[patchI];
 
         if (isA<processorPolyPatch>(patch))
         {
@@ -491,9 +485,9 @@ void Foam::PointEdgeWave<Type>::handleProcPatches()
     // 2. Receive all point info on processor patches.
     //
 
-    forAll(mesh.boundaryMesh(), patchI)
+    forAll(mesh_.boundaryMesh(), patchI)
     {
-        const polyPatch& patch = mesh.boundaryMesh()[patchI];
+        const polyPatch& patch = mesh_.boundaryMesh()[patchI];
 
         if (isA<processorPolyPatch>(patch))
         {
@@ -544,7 +538,7 @@ void Foam::PointEdgeWave<Type>::handleProcPatches()
     //    (Note:irrespective if changed or not for now)
     //
 
-    const globalMeshData& pd = mesh.globalData();
+    const globalMeshData& pd = mesh_.globalData();
 
     List<Type> sharedData(pd.nGlobalPoints());
 
@@ -579,16 +573,14 @@ void Foam::PointEdgeWave<Type>::handleProcPatches()
 template <class Type>
 void Foam::PointEdgeWave<Type>::handleCyclicPatches()
 {
-    const polyMesh& mesh = pMesh_();
-
     // 1. Send all point info on cyclic patches. Send as
     // face label + offset in face.
 
     label cycHalf = 0;
 
-    forAll(mesh.boundaryMesh(), patchI)
+    forAll(mesh_.boundaryMesh(), patchI)
     {
-        const polyPatch& patch = mesh.boundaryMesh()[patchI];
+        const polyPatch& patch = mesh_.boundaryMesh()[patchI];
 
         if (isA<cyclicPolyPatch>(patch))
         {
@@ -692,7 +684,7 @@ void Foam::PointEdgeWave<Type>::handleCyclicPatches()
 template <class Type>
 Foam::PointEdgeWave<Type>::PointEdgeWave
 (
-    const pointMesh& pMesh,
+    const polyMesh& mesh,
     const labelList& changedPoints,
     const List<Type>& changedPointsInfo,
 
@@ -702,45 +694,45 @@ Foam::PointEdgeWave<Type>::PointEdgeWave
     const label maxIter
 )
 :
-    pMesh_(pMesh),
+    mesh_(mesh),
     allPointInfo_(allPointInfo),
     allEdgeInfo_(allEdgeInfo),
-    changedPoint_(pMesh_().nPoints(), false),
-    changedPoints_(pMesh_().nPoints()),
+    changedPoint_(mesh_.nPoints(), false),
+    changedPoints_(mesh_.nPoints()),
     nChangedPoints_(0),
-    changedEdge_(pMesh_().nEdges(), false),
-    changedEdges_(pMesh_().nEdges()),
+    changedEdge_(mesh_.nEdges(), false),
+    changedEdges_(mesh_.nEdges()),
     nChangedEdges_(0),
     nCyclicPatches_(countPatchType<cyclicPolyPatch>()),
     cycHalves_(2*nCyclicPatches_),
     nEvals_(0),
-    nUnvisitedPoints_(pMesh_().nPoints()),
-    nUnvisitedEdges_(pMesh_().nEdges())
+    nUnvisitedPoints_(mesh_.nPoints()),
+    nUnvisitedEdges_(mesh_.nEdges())
 {
-    if (allPointInfo_.size() != pMesh_().nPoints())
+    if (allPointInfo_.size() != mesh_.nPoints())
     {
         FatalErrorIn
         (
             "PointEdgeWave<Type>::PointEdgeWave"
-            "(const pointMesh&, const labelList&, const List<Type>,"
+            "(const polyMesh&, const labelList&, const List<Type>,"
             " List<Type>&, List<Type>&, const label maxIter)"
         )   << "size of pointInfo work array is not equal to the number"
             << " of points in the mesh" << endl
             << "    pointInfo   :" << allPointInfo_.size() << endl
-            << "    mesh.nPoints:" << pMesh_().nPoints()
+            << "    mesh.nPoints:" << mesh_.nPoints()
             << exit(FatalError);
     }
-    if (allEdgeInfo_.size() != pMesh_().nEdges())
+    if (allEdgeInfo_.size() != mesh_.nEdges())
     {
         FatalErrorIn
         (
             "PointEdgeWave<Type>::PointEdgeWave"
-            "(const pointMesh&, const labelList&, const List<Type>,"
+            "(const polyMesh&, const labelList&, const List<Type>,"
             " List<Type>&, List<Type>&, const label maxIter)"
         )   << "size of edgeInfo work array is not equal to the number"
             << " of edges in the mesh" << endl
             << "    edgeInfo   :" << allEdgeInfo_.size() << endl
-            << "    mesh.nEdges:" << pMesh_().nEdges()
+            << "    mesh.nEdges:" << mesh_.nEdges()
             << exit(FatalError);
     }
 
@@ -768,7 +760,7 @@ Foam::PointEdgeWave<Type>::PointEdgeWave
         FatalErrorIn
         (
             "PointEdgeWave<Type>::PointEdgeWave"
-            "(const pointMesh&, const labelList&, const List<Type>,"
+            "(const polyMesh&, const labelList&, const List<Type>,"
             " List<Type>&, List<Type>&, const label maxIter)"
         )   << "Maximum number of iterations reached. Increase maxIter." << endl
             << "    maxIter:" << maxIter << endl
@@ -863,7 +855,7 @@ Foam::label Foam::PointEdgeWave<Type>::edgeToPoint()
         const Type& neighbourWallInfo = allEdgeInfo_[edgeI];
 
         // Evaluate all connected points (= edge endpoints)
-        const edge& e = pMesh_().edges()[edgeI];
+        const edge& e = mesh_.edges()[edgeI];
 
         forAll(e, eI)
         {
@@ -918,7 +910,7 @@ Foam::label Foam::PointEdgeWave<Type>::edgeToPoint()
 template <class Type>
 Foam::label Foam::PointEdgeWave<Type>::pointToEdge()
 {
-    const labelListList& pointEdges = pMesh_().pointEdges();
+    const labelListList& pointEdges = mesh_.pointEdges();
 
     for
     (
diff --git a/src/meshTools/PointEdgeWave/PointEdgeWave.H b/src/meshTools/PointEdgeWave/PointEdgeWave.H
index 22943926f8..c52f9a9ef3 100644
--- a/src/meshTools/PointEdgeWave/PointEdgeWave.H
+++ b/src/meshTools/PointEdgeWave/PointEdgeWave.H
@@ -61,7 +61,6 @@ SourceFiles
 
 #include "label.H"
 #include "boolList.H"
-#include "labelList.H"
 #include "scalarField.H"
 #include "pointFields.H"
 #include "tensor.H"
@@ -74,7 +73,7 @@ namespace Foam
 {
 
 // Forward declaration of classes
-class pointMesh;
+class polyMesh;
 
 
 /*---------------------------------------------------------------------------*\
@@ -104,7 +103,7 @@ class PointEdgeWave
     // Private data
 
         //- Reference to mesh
-        const pointMesh& pMesh_;
+        const polyMesh& mesh_;
 
         //- Wall information for all points
         List<Type>& allPointInfo_;
@@ -272,7 +271,7 @@ public:
         //  (maxIter can be 0)
         PointEdgeWave
         (
-            const pointMesh& pMesh,
+            const polyMesh& mesh,
             const labelList& initialPoints,
             const List<Type>& initialPointsInfo,
             List<Type>& allPointInfo,
diff --git a/src/sampling/meshToMeshInterpolation/meshToMesh/meshToMesh.C b/src/sampling/meshToMeshInterpolation/meshToMesh/meshToMesh.C
index 678beee799..97cc835275 100644
--- a/src/sampling/meshToMeshInterpolation/meshToMesh/meshToMesh.C
+++ b/src/sampling/meshToMeshInterpolation/meshToMesh/meshToMesh.C
@@ -52,7 +52,6 @@ meshToMesh::meshToMesh
     fromMesh_(meshFrom),
     toMesh_(meshTo),
     patchMap_(patchMap),
-    fromPointMesh_(meshFrom),
     cellAddressing_(toMesh_.nCells()),
     boundaryAddressing_(toMesh_.boundaryMesh().size()),
     inverseDistanceWeightsPtr_(NULL)
@@ -123,7 +122,6 @@ meshToMesh::meshToMesh
 :
     fromMesh_(meshFrom),
     toMesh_(meshTo),
-    fromPointMesh_(meshFrom),
     cellAddressing_(toMesh_.nCells()),
     boundaryAddressing_(toMesh_.boundaryMesh().size()),
     inverseDistanceWeightsPtr_(NULL)
diff --git a/src/sampling/meshToMeshInterpolation/meshToMesh/meshToMesh.H b/src/sampling/meshToMeshInterpolation/meshToMesh/meshToMesh.H
index 173295e53f..14770a0daa 100644
--- a/src/sampling/meshToMeshInterpolation/meshToMesh/meshToMesh.H
+++ b/src/sampling/meshToMeshInterpolation/meshToMesh/meshToMesh.H
@@ -40,7 +40,6 @@ SourceFiles
 #define meshtoMesh_H
 
 #include "fvMesh.H"
-#include "pointMesh.H"
 #include "HashTable.H"
 #include "fvPatchMapper.H"
 #include "scalarList.H"
@@ -81,9 +80,6 @@ class meshToMesh
         //- toMesh patch labels which cut the from-mesh
         HashTable<label> cuttingPatches_;
 
-        //- Point mesh used for interpolation
-        pointMesh fromPointMesh_;
-
         //- Cell addressing
         labelList cellAddressing_;
 
diff --git a/src/sampling/meshToMeshInterpolation/meshToMesh/meshToMeshInterpolate.C b/src/sampling/meshToMeshInterpolation/meshToMesh/meshToMeshInterpolate.C
index b9755cb25d..712bb4854c 100644
--- a/src/sampling/meshToMeshInterpolation/meshToMesh/meshToMeshInterpolate.C
+++ b/src/sampling/meshToMeshInterpolation/meshToMesh/meshToMeshInterpolate.C
@@ -26,7 +26,6 @@ License
 
 #include "meshToMesh.H"
 #include "volFields.H"
-#include "volPointInterpolation.H"
 #include "interpolationCellPoint.H"
 #include "SubField.H"
 #include "mixedFvPatchField.H"
@@ -102,13 +101,7 @@ void meshToMesh::interpolateField
 ) const
 {
     // Cell-Point interpolation
-    volPointInterpolation vpi(fromMesh_, fromPointMesh_);
-
-    interpolationCellPoint<Type> interpolator
-    (
-        vpi,
-        fromVf
-    );
+    interpolationCellPoint<Type> interpolator(fromVf);
 
     forAll (toF, celli)
     {
diff --git a/src/sampling/sampledSet/sampledSets/sampledSets.C b/src/sampling/sampledSet/sampledSets/sampledSets.C
index f9bb7a2067..b5518732cb 100644
--- a/src/sampling/sampledSet/sampledSets/sampledSets.C
+++ b/src/sampling/sampledSet/sampledSets/sampledSets.C
@@ -30,7 +30,7 @@ License
 #include "volFields.H"
 #include "ListListOps.H"
 #include "SortableList.H"
-
+#include "volPointInterpolation.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
@@ -236,8 +236,8 @@ Foam::sampledSets::sampledSets
     loadFromFiles_(loadFromFiles),
     outputPath_(fileName::null),
     searchEngine_(mesh_, true),
-    pMeshPtr_(NULL),
-    pInterpPtr_(NULL),
+//    pMeshPtr_(NULL),
+//    pInterpPtr_(NULL),
     fieldNames_(),
     interpolationScheme_(word::null),
     writeFormat_(word::null)
@@ -330,8 +330,10 @@ void Foam::sampledSets::read(const dictionary& dict)
 
 void Foam::sampledSets::correct()
 {
-    pMeshPtr_.clear();
-    pInterpPtr_.clear();
+    // reset interpolation
+    pointMesh::Delete(mesh_);
+    volPointInterpolation::Delete(mesh_);
+
     searchEngine_.correct();
 
     PtrList<sampledSet> newList
diff --git a/src/sampling/sampledSet/sampledSets/sampledSets.H b/src/sampling/sampledSet/sampledSets/sampledSets.H
index 2885c61f93..17469fd367 100644
--- a/src/sampling/sampledSet/sampledSets/sampledSets.H
+++ b/src/sampling/sampledSet/sampledSets/sampledSets.H
@@ -52,7 +52,6 @@ namespace Foam
 class objectRegistry;
 class dictionary;
 class fvMesh;
-class volPointInterpolation;
 
 /*---------------------------------------------------------------------------*\
                       Class sampledSets Declaration
@@ -104,7 +103,6 @@ class sampledSets
             //- Construct interpolating field to the sampleSets
             volFieldSampler
             (
-                const volPointInterpolation&,
                 const word& interpolationScheme,
                 const GeometricField<Type, fvPatchField, volMesh>& field,
                 const PtrList<sampledSet>&
@@ -159,12 +157,6 @@ class sampledSets
         //- Mesh search engine
         meshSearch searchEngine_;
 
-        //- pointMesh for interpolation
-        autoPtr<pointMesh> pMeshPtr_;
-
-        //- volPointInterpolation for interpolation
-        autoPtr<volPointInterpolation> pInterpPtr_;
-
 
         // Read from dictonary
 
diff --git a/src/sampling/sampledSet/sampledSets/sampledSetsTemplates.C b/src/sampling/sampledSet/sampledSets/sampledSetsTemplates.C
index fbfb3a798b..a29afe5dde 100644
--- a/src/sampling/sampledSet/sampledSets/sampledSetsTemplates.C
+++ b/src/sampling/sampledSet/sampledSets/sampledSetsTemplates.C
@@ -26,7 +26,6 @@ License
 
 #include "sampledSets.H"
 #include "volFields.H"
-#include "volPointInterpolation.H"
 #include "ListListOps.H"
 
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
@@ -34,7 +33,6 @@ License
 template <class Type>
 Foam::sampledSets::volFieldSampler<Type>::volFieldSampler
 (
-    const volPointInterpolation& pInterp,
     const word& interpolationScheme,
     const GeometricField<Type, fvPatchField, volMesh>& field,
     const PtrList<sampledSet>& samplers
@@ -45,7 +43,7 @@ Foam::sampledSets::volFieldSampler<Type>::volFieldSampler
 {
     autoPtr<interpolation<Type> > interpolator
     (
-        interpolation<Type>::New(interpolationScheme, pInterp, field)
+        interpolation<Type>::New(interpolationScheme, field)
     );
 
     forAll(samplers, seti)
@@ -228,13 +226,6 @@ void Foam::sampledSets::sampleAndWrite
     {
         bool interpolate = interpolationScheme_ != "cell";
 
-        if (interpolate && (!pMeshPtr_.valid() || !pInterpPtr_.valid()))
-        {
-            // set up interpolation
-            pMeshPtr_.reset(new pointMesh(mesh_));
-            pInterpPtr_.reset(new volPointInterpolation(mesh_, pMeshPtr_()));
-        }
-
         // Create or use existing writer
         if (!fields.formatter.valid())
         {
@@ -275,7 +266,6 @@ void Foam::sampledSets::sampleAndWrite
                         fieldi,
                         new volFieldSampler<Type>
                         (
-                            pInterpPtr_(),
                             interpolationScheme_,
                             vf,
                             *this
@@ -300,7 +290,6 @@ void Foam::sampledSets::sampleAndWrite
                         fieldi,
                         new volFieldSampler<Type>
                         (
-                            pInterpPtr_(),
                             interpolationScheme_,
                             mesh_.lookupObject
                             <GeometricField<Type, fvPatchField, volMesh> >
diff --git a/src/sampling/sampledSurface/sampledSurfaces/sampledSurfaces.C b/src/sampling/sampledSurface/sampledSurfaces/sampledSurfaces.C
index 0de0bc1d86..a0fa28793a 100644
--- a/src/sampling/sampledSurface/sampledSurfaces/sampledSurfaces.C
+++ b/src/sampling/sampledSurface/sampledSurfaces/sampledSurfaces.C
@@ -31,6 +31,7 @@ License
 #include "IOmanip.H"
 #include "ListListOps.H"
 #include "mergePoints.H"
+#include "volPointInterpolation.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
@@ -270,8 +271,6 @@ Foam::sampledSurfaces::sampledSurfaces
     mesh_(refCast<const fvMesh>(obr)),
     loadFromFiles_(loadFromFiles),
     outputPath_(fileName::null),
-    pMeshPtr_(NULL),
-    pInterpPtr_(NULL),
     fieldNames_(),
     interpolationScheme_(word::null),
     writeFormat_(word::null),
@@ -369,9 +368,9 @@ void Foam::sampledSurfaces::correct()
         operator[](surfI).correct(true);
     }
 
-    // reset interpolation for later
-    pMeshPtr_.clear();
-    pInterpPtr_.clear();
+    // reset interpolation
+    pointMesh::Delete(mesh_);
+    volPointInterpolation::Delete(mesh_);
 
     mergeSurfaces();
 }
diff --git a/src/sampling/sampledSurface/sampledSurfaces/sampledSurfaces.H b/src/sampling/sampledSurface/sampledSurfaces/sampledSurfaces.H
index cbe665674b..b0fee65858 100644
--- a/src/sampling/sampledSurface/sampledSurfaces/sampledSurfaces.H
+++ b/src/sampling/sampledSurface/sampledSurfaces/sampledSurfaces.H
@@ -41,7 +41,6 @@ SourceFiles
 #include "sampledSurface.H"
 #include "surfaceWriter.H"
 #include "volFieldsFwd.H"
-#include "volPointInterpolation.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -130,23 +129,17 @@ class sampledSurfaces
 
         //- Name of this set of surfaces,
         //  Also used as the name of the sampledSurfaces directory.
-        word name_;
+        const word name_;
 
         //- Const reference to fvMesh
         const fvMesh& mesh_;
 
         //- Load fields from files (not from objectRegistry)
-        bool loadFromFiles_;
+        const bool loadFromFiles_;
 
         //- output path
         fileName outputPath_;
 
-        //- pointMesh for interpolation
-        autoPtr<pointMesh> pMeshPtr_;
-
-        //- volPointInterpolation for interpolation
-        autoPtr<volPointInterpolation> pInterpPtr_;
-
 
         // Read from dictonary
 
@@ -192,13 +185,6 @@ class sampledSurfaces
             const wordList& fieldTypes
         ) const;
 
-        //- Set interpolator for the field
-        template<class Type>
-        autoPtr<interpolation<Type> > setInterpolator
-        (
-            const GeometricField<Type, fvPatchField, volMesh>&
-        );
-
         //- Sample and write a particular volume field
         template<class Type>
         void sampleAndWrite
diff --git a/src/sampling/sampledSurface/sampledSurfaces/sampledSurfacesTemplates.C b/src/sampling/sampledSurface/sampledSurfaces/sampledSurfacesTemplates.C
index 9e536ef53b..827bab2ae3 100644
--- a/src/sampling/sampledSurface/sampledSurfaces/sampledSurfacesTemplates.C
+++ b/src/sampling/sampledSurface/sampledSurfaces/sampledSurfacesTemplates.C
@@ -59,30 +59,6 @@ Foam::label Foam::sampledSurfaces::grep
 }
 
 
-template<class Type>
-Foam::autoPtr<Foam::interpolation<Type> >
-Foam::sampledSurfaces::setInterpolator
-(
-    const GeometricField<Type, fvPatchField, volMesh>& vField
-)
-{
-    if (!pMeshPtr_.valid() || !pInterpPtr_.valid())
-    {
-        // set up interpolation
-        pMeshPtr_.reset(new pointMesh(mesh_));
-        pInterpPtr_.reset(new volPointInterpolation(mesh_, pMeshPtr_()));
-    }
-
-    // interpolator for this field
-    return interpolation<Type>::New
-    (
-        interpolationScheme_,
-        pInterpPtr_(),
-        vField
-    );
-}
-
-
 template<class Type>
 void Foam::sampledSurfaces::sampleAndWrite
 (
@@ -106,7 +82,11 @@ void Foam::sampledSurfaces::sampleAndWrite
         {
             if (!interpolator.valid())
             {
-                interpolator = setInterpolator(vField);
+                interpolator = interpolation<Type>::New
+                (
+                    interpolationScheme_,
+                    vField
+                );
             }
 
             values = s.interpolate(interpolator());
diff --git a/tutorials/rhoTurbTwinParcelFoam/rhoTurbTwinParcelFoam/createFields.H b/tutorials/rhoTurbTwinParcelFoam/rhoTurbTwinParcelFoam/createFields.H
index 15dadd08d1..a824308f13 100644
--- a/tutorials/rhoTurbTwinParcelFoam/rhoTurbTwinParcelFoam/createFields.H
+++ b/tutorials/rhoTurbTwinParcelFoam/rhoTurbTwinParcelFoam/createFields.H
@@ -57,14 +57,10 @@
     volScalarField DpDt =
         fvc::DDt(surfaceScalarField("phiU", phi/fvc::interpolate(rho)), p);
 
-    pointMesh pMesh(mesh);
-    volPointInterpolation vpi(mesh, pMesh);
-
     Info<< "Constructing thermoCloud1" << endl;
     basicThermoCloud thermoCloud1
     (
         "thermoCloud1",
-        vpi,
         rho,
         U,
         g,
@@ -75,7 +71,6 @@
     basicKinematicCloud kinematicCloud1
     (
         "kinematicCloud1",
-        vpi,
         rho,
         U,
         thermo().mu(),

From 4c5ebb4cb19519b65c8da4868bf8df27e4b8cfdd Mon Sep 17 00:00:00 2001
From: mattijs <mattijs@hunt.opencfd.co.uk>
Date: Tue, 21 Oct 2008 15:03:13 +0100
Subject: [PATCH 09/10] added isoSurface

---
 src/sampling/Make/files | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/sampling/Make/files b/src/sampling/Make/files
index b5f1a258c6..f17e7222bd 100644
--- a/src/sampling/Make/files
+++ b/src/sampling/Make/files
@@ -22,6 +22,8 @@ cuttingPlane/cuttingPlane.C
 
 sampledSurface/patch/sampledPatch.C
 sampledSurface/plane/sampledPlane.C
+sampledSurface/isoSurface/isoSurface.C
+sampledSurface/isoSurface/sampledIsoSurface.C
 sampledSurface/sampledSurface/sampledSurface.C
 sampledSurface/sampledSurfaces/sampledSurfaces.C
 sampledSurface/sampledSurfacesFunctionObject/sampledSurfacesFunctionObject.C

From 3efb4ebe20152c396f7fe25c5a9debe4c6c5db8d Mon Sep 17 00:00:00 2001
From: mattijs <mattijs@hunt.opencfd.co.uk>
Date: Tue, 21 Oct 2008 15:04:18 +0100
Subject: [PATCH 10/10] merge from master

---
 .../test/DynamicList/DynamicListTest.C        | 50 +++++++++++--
 applications/test/xfer/xferListTest.C         | 32 ++++++---
 etc/settings.csh                              |  2 +-
 etc/settings.sh                               |  2 +-
 .../HashTables/HashTable/HashTable.C          |  2 +-
 .../StaticHashTable/StaticHashTable.C         |  2 +-
 .../Lists/CompactListList/CompactListList.C   |  2 +-
 .../Lists/DynamicList/DynamicList.H           | 48 ++++++-------
 .../Lists/DynamicList/DynamicListI.H          | 54 +++++++-------
 src/OpenFOAM/containers/Lists/List/List.C     |  5 +-
 .../containers/Lists/PackedList/PackedList.C  |  2 +-
 .../containers/Lists/PtrList/PtrList.C        |  2 +-
 .../Lists/SortableList/SortableList.C         |  4 +-
 src/OpenFOAM/containers/Lists/UList/UList.C   |  2 +-
 .../containers/Lists/UPtrList/UPtrList.C      |  2 +-
 src/OpenFOAM/db/IOobjects/IOField/IOField.C   | 19 +++++
 src/OpenFOAM/db/IOobjects/IOField/IOField.H   |  7 +-
 src/OpenFOAM/db/IOobjects/IOList/IOList.C     | 19 +++++
 src/OpenFOAM/db/IOobjects/IOList/IOList.H     |  3 +
 src/OpenFOAM/db/IOobjects/IOMap/IOMap.C       | 19 +++++
 src/OpenFOAM/db/IOobjects/IOMap/IOMap.H       |  7 +-
 .../db/IOobjects/IOPtrList/IOPtrList.C        | 19 +++++
 .../db/IOobjects/IOPtrList/IOPtrList.H        |  3 +
 .../DimensionedField/DimensionedField.C       | 35 ++++++++--
 .../DimensionedField/DimensionedField.H       | 15 +++-
 .../FieldFields/FieldField/FieldField.H       |  1 +
 src/OpenFOAM/fields/Fields/Field/Field.C      | 21 ++++++
 src/OpenFOAM/fields/Fields/Field/Field.H      | 10 +++
 src/OpenFOAM/memory/xfer/xfer.H               | 70 +++++++++++--------
 src/OpenFOAM/memory/xfer/xferI.H              | 16 ++---
 src/OpenFOAM/meshes/MeshObject/MeshObject.C   | 47 ++++++++++++-
 src/OpenFOAM/meshes/MeshObject/MeshObject.H   | 34 ++++++++-
 src/OpenFOAM/meshes/polyMesh/polyMesh.H       | 43 ++++++++++++
 .../meshes/polyMesh/polyMeshInitMesh.C        |  6 ++
 .../meshes/primitiveMesh/primitiveMesh.C      | 58 +++++++++------
 .../meshes/primitiveMesh/primitiveMesh.H      | 11 +++
 src/conversion/meshReader/calcPointCells.C    | 20 ++----
 src/conversion/meshReader/meshReader.C        |  2 +-
 src/conversion/meshReader/meshReader.H        |  7 --
 src/finiteVolume/fvMesh/fvMesh.H              | 26 ++++++-
 .../schemes/quadraticFit/quadraticFit.H       | 13 +++-
 .../schemes/quadraticFit/quadraticFitData.C   | 28 +++-----
 .../schemes/quadraticFit/quadraticFitData.H   | 24 ++++---
 wmake/wmakeScheduler                          | 20 +-----
 44 files changed, 589 insertions(+), 225 deletions(-)

diff --git a/applications/test/DynamicList/DynamicListTest.C b/applications/test/DynamicList/DynamicListTest.C
index 0233dbd474..6cdbb84890 100644
--- a/applications/test/DynamicList/DynamicListTest.C
+++ b/applications/test/DynamicList/DynamicListTest.C
@@ -43,20 +43,58 @@ int main(int argc, char *argv[])
     ldl[0](3) = 3;
     ldl[0](1) = 1;
 
-    ldl[1](0) = 1;
-    ldl[1](1) = 2;
+    ldl[0].setSize(5);     // increase allocated size
+    ldl[1].setSize(10);    // increase allocated size
+    ldl[1](2) = 2;
 
     ldl[1] = 3;
 
-    Info<< ldl[1];
+    Info<< "<ldl>" << ldl << "</ldl>" << nl << "sizes: ";
+    forAll(ldl, i)
+    {
+        Info<< " " << ldl[i].size() << "/" << ldl[i].allocSize();
+    }
+    Info<< endl;
 
     List<List<label> > ll(2);
-    ll[0].transfer(ldl[0].shrink());
+    ll[0].transfer(ldl[0]);
     ll[1].transfer(ldl[1].shrink());
 
-    Info<< ll << endl;
+    Info<< "<ldl>" << ldl << "</ldl>" << nl << "sizes: ";
+    forAll(ldl, i)
+    {
+        Info<< " " << ldl[i].size() << "/" << ldl[i].allocSize();
+    }
+    Info<< endl;
+
+    Info<< "<ll>" << ll << "</ll>" << nl << endl;
+
+
+    // test the transfer between DynamicLists
+    DynamicList<label, 1, 0> dlA;
+    DynamicList<label, 1, 0> dlB;
+
+    for (label i = 0; i < 5; i++)
+    {
+        dlA.append(i);
+    }
+    dlA.setSize(10);
+
+    Info<< "<dlA>" << dlA << "</dlA>" << nl << "sizes: "
+        << " " << dlA.size() << "/" << dlA.allocSize() << endl;
+
+    dlB.transfer(dlA);
+
+    // provokes memory error if previous transfer did not maintain
+    // the correct allocated space
+    dlB[6] = 6;
+
+    Info<< "Transferred to dlB" << endl;
+    Info<< "<dlA>" << dlA << "</dlA>" << nl << "sizes: "
+        << " " << dlA.size() << "/" << dlA.allocSize() << endl;
+    Info<< "<dlB>" << dlB << "</dlB>" << nl << "sizes: "
+        << " " << dlB.size() << "/" << dlB.allocSize() << endl;
 
-    Info << "\nEnd\n" << endl;
 
     return 0;
 }
diff --git a/applications/test/xfer/xferListTest.C b/applications/test/xfer/xferListTest.C
index 6fce6b2bd0..0089569394 100644
--- a/applications/test/xfer/xferListTest.C
+++ b/applications/test/xfer/xferListTest.C
@@ -52,34 +52,48 @@ int main(int argc, char *argv[])
     Info<< "lstA: " << lstA << endl;
     Info<< "lstC: " << lstC << endl;
 
-    xfer<List<label> > xA(lstA, true);
+    xfer<List<label> > xA = xferMove(lstA);
     xfer<List<label> > xB;
 
-//    List<label> lstB( xferTmp(List<label>, lstC) );
-//    List<label> lstB( xfer<List<label> >(lstC) );
     List<label> lstB( xA );
 
-    Info<< "xA: " << *xA << endl;
-    Info<< "xB: " << *xB << endl;
+    Info<< "xA: " << xA() << endl;
+    Info<< "xB: " << xB() << endl;
     Info<< "lstA: " << lstA << endl;
     Info<< "lstB: " << lstB << endl;
     Info<< "lstC: " << lstC << endl;
 
     xA = lstB;
 
-    Info<< "xA: " << *xA << endl;
-    Info<< "xB: " << *xB << endl;
+    Info<< "xA: " << xA() << endl;
+    Info<< "xB: " << xB() << endl;
     Info<< "lstA: " << lstA << endl;
     Info<< "lstB: " << lstB << endl;
     Info<< "lstC: " << lstC << endl;
 
     xB = xA;
+    
+    List<label> lstD(xferCopy(lstC));
+    List<label> lstE(xferMove(lstC));
+    
+    // this must be empty
+    List<label> lstF = xferCopy(lstC);
 
-    Info<< "xA: " << *xA << endl;
-    Info<< "xB: " << *xB << endl;
+    Info<< "xA: " << xA() << endl;
+    Info<< "xB: " << xB() << endl;
     Info<< "lstA: " << lstA << endl;
     Info<< "lstB: " << lstB << endl;
     Info<< "lstC: " << lstC << endl;
+    Info<< "lstD: " << lstD << endl;
+    Info<< "lstE: " << lstE << endl;
+    Info<< "lstF: " << lstF << endl;
+
+    Info<< "xB size: " << xB->size() << endl;
+
+    // clear the underlying List
+    xB->clear();
+
+    Info<< "xB size: " << xB->size() << endl;
 
     return 0;
 }
diff --git a/etc/settings.csh b/etc/settings.csh
index 1958e71787..0a38b78f6a 100644
--- a/etc/settings.csh
+++ b/etc/settings.csh
@@ -121,7 +121,7 @@ unset MPI_ARCH_PATH
 
 switch ("$WM_MPLIB")
 case OPENMPI:
-    set mpi_version=openmpi-1.2.6
+    set mpi_version=openmpi-1.2.8
     setenv MPI_HOME $WM_THIRD_PARTY_DIR/$mpi_version
     setenv MPI_ARCH_PATH $MPI_HOME/platforms/$WM_OPTIONS
 
diff --git a/etc/settings.sh b/etc/settings.sh
index 133137d3a4..6519bd9682 100644
--- a/etc/settings.sh
+++ b/etc/settings.sh
@@ -151,7 +151,7 @@ unset MPI_ARCH_PATH
 
 case "$WM_MPLIB" in
 OPENMPI)
-    mpi_version=openmpi-1.2.6
+    mpi_version=openmpi-1.2.8
     export MPI_HOME=$WM_THIRD_PARTY_DIR/$mpi_version
     export MPI_ARCH_PATH=$MPI_HOME/platforms/$WM_OPTIONS
 
diff --git a/src/OpenFOAM/containers/HashTables/HashTable/HashTable.C b/src/OpenFOAM/containers/HashTables/HashTable/HashTable.C
index 676d579bb8..d9d74fd1ad 100644
--- a/src/OpenFOAM/containers/HashTables/HashTable/HashTable.C
+++ b/src/OpenFOAM/containers/HashTables/HashTable/HashTable.C
@@ -93,7 +93,7 @@ HashTable<T, Key, Hash>::HashTable(const xfer<HashTable<T, Key, Hash> >& ht)
     endIter_(*this, NULL, 0),
     endConstIter_(*this, NULL, 0)
 {
-    transfer(*ht);
+    transfer(ht());
 }
 
 
diff --git a/src/OpenFOAM/containers/HashTables/StaticHashTable/StaticHashTable.C b/src/OpenFOAM/containers/HashTables/StaticHashTable/StaticHashTable.C
index 688abd467d..c4afe4c044 100644
--- a/src/OpenFOAM/containers/HashTables/StaticHashTable/StaticHashTable.C
+++ b/src/OpenFOAM/containers/HashTables/StaticHashTable/StaticHashTable.C
@@ -90,7 +90,7 @@ StaticHashTable<T, Key, Hash>::StaticHashTable
     endIter_(*this, 0, 0),
     endConstIter_(*this, 0, 0)
 {
-    transfer(*ht);
+    transfer(ht());
 }
 
 
diff --git a/src/OpenFOAM/containers/Lists/CompactListList/CompactListList.C b/src/OpenFOAM/containers/Lists/CompactListList/CompactListList.C
index 1f683d98a5..614bcc08f1 100644
--- a/src/OpenFOAM/containers/Lists/CompactListList/CompactListList.C
+++ b/src/OpenFOAM/containers/Lists/CompactListList/CompactListList.C
@@ -95,7 +95,7 @@ CompactListList<T>::CompactListList(const UList<label>& rowSizes, const T& t)
 template<class T>
 CompactListList<T>::CompactListList(const xfer<CompactListList<T> >& lst)
 {
-    transfer(*lst);
+    transfer(lst());
 }
 
 template<class T>
diff --git a/src/OpenFOAM/containers/Lists/DynamicList/DynamicList.H b/src/OpenFOAM/containers/Lists/DynamicList/DynamicList.H
index 3891ad0ea8..214c780620 100644
--- a/src/OpenFOAM/containers/Lists/DynamicList/DynamicList.H
+++ b/src/OpenFOAM/containers/Lists/DynamicList/DynamicList.H
@@ -115,39 +115,36 @@ public:
 
         // Access
 
-            //- Size of the underlying storage.
-            inline label allocSize() const;
+        //- Size of the underlying storage.
+        inline label allocSize() const;
 
 
         // Edit
 
-            //- Alter the list size.
-            //  When the new size is greater than the addressed list size, the
-            //  allocated list sizes is adjusted and the
-            //  addressed size does not change.
-            //  Otherwise the addressed list size is just reduced and the
-            //  allocated size does not change.
-            inline void setSize(const label);
+        //- Alter the list size.
+        //  When the new size is greater than the addressed list size, the
+        //  allocated list sizes is adjusted and the
+        //  addressed size does not change.
+        //  Otherwise the addressed list size is just reduced and the
+        //  allocated size does not change.
+        inline void setSize(const label);
 
-            //- Clear the list, i.e. set the size to zero.
-            //  Allocated size does not change
-            inline void clear();
+        //- Clear the list, i.e. set the size to zero.
+        //  Allocated size does not change
+        inline void clear();
 
-            //- Clear the list and delete storage.
-            inline void clearStorage();
+        //- Clear the list and delete storage.
+        inline void clearStorage();
 
-            //- Shrink the List<T> to the number of elements used
-            inline DynamicList<T, SizeInc, SizeMult, SizeDiv>& shrink();
+        //- Shrink the allocated space to the number of elements used.
+        //  Returns a reference to the DynamicList.
+        inline DynamicList<T, SizeInc, SizeMult, SizeDiv>& shrink();
 
-            //- Transfer the contents of the argument List into this List
-            //  and annull the argument list. Is same as List::transfer except
-            //  checks that you're not changing the underlying list to something
-            //  smaller than allocSize_.
-            inline void transfer(List<T>&);
+        //- Transfer contents of the argument List into this DynamicList
+        inline void transfer(List<T>&);
 
-            //- Transfer the contents of the argument DynamicList into this
-            //  DynamicList and annull the argument list.
-            inline void transfer(DynamicList<T, SizeInc, SizeMult, SizeDiv>&);
+        //- Transfer contents of the argument DynamicList into this DynamicList
+        inline void transfer(DynamicList<T, SizeInc, SizeMult, SizeDiv>&);
 
 
     // Member Operators
@@ -158,8 +155,7 @@ public:
         //- Remove and return the top element
         inline T remove();
 
-        //- Return non-const access to an element,
-        //  resizing the list if necessary
+        //- Return non-const access to an element, resizing list if necessary
         inline T& operator()(const label);
 
         //- Assignment of all addressed entries to the given value
diff --git a/src/OpenFOAM/containers/Lists/DynamicList/DynamicListI.H b/src/OpenFOAM/containers/Lists/DynamicList/DynamicListI.H
index 434dfcb468..1a40bdd0ac 100644
--- a/src/OpenFOAM/containers/Lists/DynamicList/DynamicListI.H
+++ b/src/OpenFOAM/containers/Lists/DynamicList/DynamicListI.H
@@ -26,7 +26,6 @@ License
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
-//- Construct null
 template<class T, unsigned SizeInc, unsigned SizeMult, unsigned SizeDiv>
 inline Foam::DynamicList<T, SizeInc, SizeMult, SizeDiv>::DynamicList()
 :
@@ -37,7 +36,6 @@ inline Foam::DynamicList<T, SizeInc, SizeMult, SizeDiv>::DynamicList()
 }
 
 
-//- Construct given size
 template<class T, unsigned SizeInc, unsigned SizeMult, unsigned SizeDiv>
 inline Foam::DynamicList<T, SizeInc, SizeMult, SizeDiv>::DynamicList
 (
@@ -51,15 +49,14 @@ inline Foam::DynamicList<T, SizeInc, SizeMult, SizeDiv>::DynamicList
 }
 
 
-//- Construct given size
 template<class T, unsigned SizeInc, unsigned SizeMult, unsigned SizeDiv>
 inline Foam::DynamicList<T, SizeInc, SizeMult, SizeDiv>::DynamicList
 (
-    const UList<T>& s
+    const UList<T>& lst
 )
 :
-    List<T>(s),
-    allocSize_(s.size())
+    List<T>(lst),
+    allocSize_(lst.size())
 {}
 
 
@@ -114,31 +111,24 @@ template<class T, unsigned SizeInc, unsigned SizeMult, unsigned SizeDiv>
 inline Foam::DynamicList<T, SizeInc, SizeMult, SizeDiv>&
 Foam::DynamicList<T, SizeInc, SizeMult, SizeDiv>::shrink()
 {
-    allocSize_ = List<T>::size();
-    List<T>::setSize(allocSize_);
+    if (allocSize_ > List<T>::size())
+    {
+        allocSize_ = List<T>::size();
+        // force re-allocation/copying in List<T>::setSize() by temporarily
+        // faking a larger list size that will be truncated
+        List<T>::size(allocSize_+1);
+        List<T>::setSize(allocSize_);
+    }
     return *this;
 }
 
 
 template<class T, unsigned SizeInc, unsigned SizeMult, unsigned SizeDiv>
 inline void
-Foam::DynamicList<T, SizeInc, SizeMult, SizeDiv>::transfer(List<T>& l)
+Foam::DynamicList<T, SizeInc, SizeMult, SizeDiv>::transfer(List<T>& lst)
 {
-    if (l.size() < List<T>::size())
-    {
-        FatalErrorIn
-        (
-            "void DynamicList<T, SizeInc, SizeMult"
-            ", SizeDiv>::transfer(List<T>&)"
-        )   << "Cannot replace the underlying storage of this DynamicList"
-            << " of which " << List<T>::size() << " elements are used" << nl
-            << "with a List of size " << l.size() << abort(FatalError);
-    }
-    else
-    {
-        allocSize_ = l.size();
-        List<T>::transfer(l);   // take over storage
-    }
+    allocSize_ = lst.size();
+    List<T>::transfer(lst);   // take over storage, clear addressing for lst.
 }
 
 
@@ -146,11 +136,14 @@ template<class T, unsigned SizeInc, unsigned SizeMult, unsigned SizeDiv>
 inline void
 Foam::DynamicList<T, SizeInc, SizeMult, SizeDiv>::transfer
 (
-    DynamicList<T, SizeInc, SizeMult, SizeDiv>& l
+    DynamicList<T, SizeInc, SizeMult, SizeDiv>& lst
 )
 {
-    allocSize_ = l.allocSize();
-    List<T>::transfer(l);       // take over storage. Null l.
+    // take over storage as-is (without shrink), clear addressing for lst.
+    allocSize_ = lst.allocSize_;
+    lst.allocSize_ = 0;
+
+    List<T>::transfer(static_cast<List<T>&>(lst));
 }
 
 
@@ -240,10 +233,13 @@ inline void Foam::DynamicList<T, SizeInc, SizeMult, SizeDiv>::operator=
 template<class T, unsigned SizeInc, unsigned SizeMult, unsigned SizeDiv>
 inline void Foam::DynamicList<T, SizeInc, SizeMult, SizeDiv>::operator=
 (
-    const List<T>& l
+    const List<T>& lst
 )
 {
-    List<T>::operator=(l);
+    // make the entire storage available for the copy operation:
+    List<T>::size(allocSize_);
+
+    List<T>::operator=(lst);
     allocSize_ = List<T>::size();
 }
 
diff --git a/src/OpenFOAM/containers/Lists/List/List.C b/src/OpenFOAM/containers/Lists/List/List.C
index 02e83b011b..d9a929f1a9 100644
--- a/src/OpenFOAM/containers/Lists/List/List.C
+++ b/src/OpenFOAM/containers/Lists/List/List.C
@@ -129,7 +129,7 @@ Foam::List<T>::List(const List<T>& a)
 template<class T>
 Foam::List<T>::List(const xfer<List<T> >& lst)
 {
-    transfer(*lst);
+    transfer(lst());
 }
 
 
@@ -430,6 +430,9 @@ template<class T>
 template<unsigned SizeInc, unsigned SizeMult, unsigned SizeDiv>
 void Foam::List<T>::transfer(DynamicList<T, SizeInc, SizeMult, SizeDiv>& a)
 {
+    // shrink the allocated space to the number of elements used
+    a.shrink();
+
     if (this->v_) delete[] this->v_;
     this->size_ = a.size_;
     this->v_ = a.v_;
diff --git a/src/OpenFOAM/containers/Lists/PackedList/PackedList.C b/src/OpenFOAM/containers/Lists/PackedList/PackedList.C
index 23e72713bf..8c31ea0854 100644
--- a/src/OpenFOAM/containers/Lists/PackedList/PackedList.C
+++ b/src/OpenFOAM/containers/Lists/PackedList/PackedList.C
@@ -57,7 +57,7 @@ PackedList<nBits>::PackedList(const PackedList<nBits>& PList)
 template<int nBits>
 PackedList<nBits>::PackedList(const xfer<PackedList<nBits> >& lst)
 {
-    transfer(*lst);
+    transfer(lst());
 }
 
 
diff --git a/src/OpenFOAM/containers/Lists/PtrList/PtrList.C b/src/OpenFOAM/containers/Lists/PtrList/PtrList.C
index 68c5d613a0..561dff8b25 100644
--- a/src/OpenFOAM/containers/Lists/PtrList/PtrList.C
+++ b/src/OpenFOAM/containers/Lists/PtrList/PtrList.C
@@ -74,7 +74,7 @@ Foam::PtrList<T>::PtrList(const PtrList<T>& a, const CloneArg& cloneArg)
 template<class T>
 Foam::PtrList<T>::PtrList(const xfer<PtrList<T> >& lst)
 {
-    transfer(*lst);
+    transfer(lst());
 }
 
 
diff --git a/src/OpenFOAM/containers/Lists/SortableList/SortableList.C b/src/OpenFOAM/containers/Lists/SortableList/SortableList.C
index 1f3f53a165..7ebfa9de9e 100644
--- a/src/OpenFOAM/containers/Lists/SortableList/SortableList.C
+++ b/src/OpenFOAM/containers/Lists/SortableList/SortableList.C
@@ -45,9 +45,9 @@ template <class Type>
 Foam::SortableList<Type>::SortableList(const xfer<List<Type> >& values)
 :
     List<Type>(),
-    indices_((*values).size())
+    indices_(values->size())
 {
-    List<Type>::transfer(*values);
+    List<Type>::transfer(values());
     sort();
 }
 
diff --git a/src/OpenFOAM/containers/Lists/UList/UList.C b/src/OpenFOAM/containers/Lists/UList/UList.C
index 85ee1bb4ad..c77e6bfb80 100644
--- a/src/OpenFOAM/containers/Lists/UList/UList.C
+++ b/src/OpenFOAM/containers/Lists/UList/UList.C
@@ -45,7 +45,7 @@ void Foam::UList<T>::assign(const UList<T>& a)
 {
     if (a.size_ != this->size_)
     {
-        FatalErrorIn("UList<T>::operator=(const UList<T>&)")
+        FatalErrorIn("UList<T>::assign(const UList<T>&)")
             << "ULists have different sizes: "
             << this->size_ << " " << a.size_
             << abort(FatalError);
diff --git a/src/OpenFOAM/containers/Lists/UPtrList/UPtrList.C b/src/OpenFOAM/containers/Lists/UPtrList/UPtrList.C
index 8a2336922c..7321f791b8 100644
--- a/src/OpenFOAM/containers/Lists/UPtrList/UPtrList.C
+++ b/src/OpenFOAM/containers/Lists/UPtrList/UPtrList.C
@@ -53,7 +53,7 @@ UPtrList<T>::UPtrList(const label s)
 template<class T>
 UPtrList<T>::UPtrList(const xfer<UPtrList<T> >& lst)
 {
-    transfer(*lst);
+    transfer(lst());
 }
 
 
diff --git a/src/OpenFOAM/db/IOobjects/IOField/IOField.C b/src/OpenFOAM/db/IOobjects/IOField/IOField.C
index 973f7de1c1..3e927fd3d0 100644
--- a/src/OpenFOAM/db/IOobjects/IOField/IOField.C
+++ b/src/OpenFOAM/db/IOobjects/IOField/IOField.C
@@ -87,6 +87,25 @@ Foam::IOField<Type>::IOField(const IOobject& io, const Field<Type>& f)
 }
 
 
+template<class Type>
+Foam::IOField<Type>::IOField(const IOobject& io, const xfer<Field<Type> >& f)
+:
+    regIOobject(io)
+{
+    Field<Type>::transfer(f());
+
+    if
+    (
+        io.readOpt() == IOobject::MUST_READ
+     || (io.readOpt() == IOobject::READ_IF_PRESENT && headerOk())
+    )
+    {
+        readStream(typeName) >> *this;
+        close();
+    }
+}
+
+
 // * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * * //
 
 template<class Type>
diff --git a/src/OpenFOAM/db/IOobjects/IOField/IOField.H b/src/OpenFOAM/db/IOobjects/IOField/IOField.H
index e42cca65db..0cd06bdb09 100644
--- a/src/OpenFOAM/db/IOobjects/IOField/IOField.H
+++ b/src/OpenFOAM/db/IOobjects/IOField/IOField.H
@@ -65,11 +65,14 @@ public:
         //- Construct from IOobject
         IOField(const IOobject&);
 
+        //- Construct from IOobject and size (does not set values)
+        IOField(const IOobject&, const label size);
+
         //- Construct from components
         IOField(const IOobject&, const Field<Type>&);
 
-        //- Construct from IOobject and size (does not set values)
-        IOField(const IOobject&, const label size);
+        //- Construct by transferring the Field contents
+        IOField(const IOobject&, const xfer<Field<Type> >&);
 
 
     // Destructor
diff --git a/src/OpenFOAM/db/IOobjects/IOList/IOList.C b/src/OpenFOAM/db/IOobjects/IOList/IOList.C
index 11a80cbb2c..fc9f4498d4 100644
--- a/src/OpenFOAM/db/IOobjects/IOList/IOList.C
+++ b/src/OpenFOAM/db/IOobjects/IOList/IOList.C
@@ -87,6 +87,25 @@ Foam::IOList<T>::IOList(const IOobject& io, const List<T>& list)
 }
 
 
+template<class T>
+Foam::IOList<T>::IOList(const IOobject& io, const xfer<List<T> >& list)
+:
+    regIOobject(io)
+{
+    List<T>::transfer(list());
+
+    if
+    (
+        io.readOpt() == IOobject::MUST_READ
+     || (io.readOpt() == IOobject::READ_IF_PRESENT && headerOk())
+    )
+    {
+        readStream(typeName) >> *this;
+        close();
+    }
+}
+
+
 // * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * * //
 
 template<class T>
diff --git a/src/OpenFOAM/db/IOobjects/IOList/IOList.H b/src/OpenFOAM/db/IOobjects/IOList/IOList.H
index d7ab7ec688..1bf7f34fcc 100644
--- a/src/OpenFOAM/db/IOobjects/IOList/IOList.H
+++ b/src/OpenFOAM/db/IOobjects/IOList/IOList.H
@@ -72,6 +72,9 @@ public:
         //- Construct from IOobject and a List
         IOList(const IOobject&, const List<T>&);
 
+        //- Construct by transferring the List contents
+        IOList(const IOobject&, const xfer<List<T> >&);
+
 
     // Destructor
 
diff --git a/src/OpenFOAM/db/IOobjects/IOMap/IOMap.C b/src/OpenFOAM/db/IOobjects/IOMap/IOMap.C
index dffbda46d6..1c15804a4d 100644
--- a/src/OpenFOAM/db/IOobjects/IOMap/IOMap.C
+++ b/src/OpenFOAM/db/IOobjects/IOMap/IOMap.C
@@ -86,6 +86,25 @@ Foam::IOMap<T>::IOMap(const IOobject& io, const Map<T>& map)
 }
 
 
+template<class T>
+Foam::IOMap<T>::IOMap(const IOobject& io, const xfer<Map<T> >& map)
+:
+    regIOobject(io)
+{
+    Map<T>::transfer(map());
+
+    if
+    (
+        io.readOpt() == IOobject::MUST_READ
+     || (io.readOpt() == IOobject::READ_IF_PRESENT && headerOk())
+    )
+    {
+        readStream(typeName) >> *this;
+        close();
+    }
+}
+
+
 // * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * * //
 
 template<class T>
diff --git a/src/OpenFOAM/db/IOobjects/IOMap/IOMap.H b/src/OpenFOAM/db/IOobjects/IOMap/IOMap.H
index e2c503ae46..dd86337f3f 100644
--- a/src/OpenFOAM/db/IOobjects/IOMap/IOMap.H
+++ b/src/OpenFOAM/db/IOobjects/IOMap/IOMap.H
@@ -66,11 +66,14 @@ public:
         //- Construct from IOobject
         IOMap(const IOobject&);
 
+        //- Construct from IOobject and size of Map
+        IOMap(const IOobject&, const label);
+
         //- Construct from IOobject and a Map
         IOMap(const IOobject&, const Map<T>&);
 
-        //- Construct from IOobject and size of Map
-        IOMap(const IOobject&, const label);
+        //- Construct by transferring the Map contents
+        IOMap(const IOobject&, const xfer<Map<T> >&);
 
 
     // Destructor
diff --git a/src/OpenFOAM/db/IOobjects/IOPtrList/IOPtrList.C b/src/OpenFOAM/db/IOobjects/IOPtrList/IOPtrList.C
index e6fae97c27..4197a74ee9 100644
--- a/src/OpenFOAM/db/IOobjects/IOPtrList/IOPtrList.C
+++ b/src/OpenFOAM/db/IOobjects/IOPtrList/IOPtrList.C
@@ -84,6 +84,25 @@ Foam::IOPtrList<T>::IOPtrList(const IOobject& io, const PtrList<T>& list)
 }
 
 
+template<class T>
+Foam::IOPtrList<T>::IOPtrList(const IOobject& io, const xfer<PtrList<T> >& list)
+:
+    regIOobject(io)
+{
+    PtrList<T>::transfer(list());
+
+    if
+    (
+        io.readOpt() == IOobject::MUST_READ
+     || (io.readOpt() == IOobject::READ_IF_PRESENT && headerOk())
+    )
+    {
+        PtrList<T>::read(readStream(typeName), INew<T>());
+        close();
+    }
+}
+
+
 // * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * * //
 
 template<class T>
diff --git a/src/OpenFOAM/db/IOobjects/IOPtrList/IOPtrList.H b/src/OpenFOAM/db/IOobjects/IOPtrList/IOPtrList.H
index 27ab0bbb5a..cb23363c05 100644
--- a/src/OpenFOAM/db/IOobjects/IOPtrList/IOPtrList.H
+++ b/src/OpenFOAM/db/IOobjects/IOPtrList/IOPtrList.H
@@ -73,6 +73,9 @@ public:
         //- Construct from IOobject and a PtrList
         IOPtrList(const IOobject&, const PtrList<T>&);
 
+        //- Construct by transferring the PtrList contents
+        IOPtrList(const IOobject&, const xfer<PtrList<T> >&);
+
 
     // Destructor
 
diff --git a/src/OpenFOAM/fields/DimensionedFields/DimensionedField/DimensionedField.C b/src/OpenFOAM/fields/DimensionedFields/DimensionedField/DimensionedField.C
index 67100f518b..41e0bcf131 100644
--- a/src/OpenFOAM/fields/DimensionedFields/DimensionedField/DimensionedField.C
+++ b/src/OpenFOAM/fields/DimensionedFields/DimensionedField/DimensionedField.C
@@ -138,6 +138,19 @@ DimensionedField<Type, GeoMesh>::DimensionedField
 {}
 
 
+template<class Type, class GeoMesh>
+DimensionedField<Type, GeoMesh>::DimensionedField
+(
+    const xfer<DimensionedField<Type, GeoMesh> >& df
+)
+:
+    regIOobject(df(), true),
+    Field<Type>(df),
+    mesh_(df->mesh_),
+    dimensions_(df->dimensions_)
+{}
+
+
 #ifdef ConstructFromTmp
 template<class Type, class GeoMesh>
 DimensionedField<Type, GeoMesh>::DimensionedField
@@ -202,6 +215,20 @@ DimensionedField<Type, GeoMesh>::DimensionedField
 {}
 
 
+template<class Type, class GeoMesh>
+DimensionedField<Type, GeoMesh>::DimensionedField
+(
+    const word& newName,
+    const xfer<DimensionedField<Type, GeoMesh> >& df
+)
+:
+    regIOobject(IOobject(newName, df->time().timeName(), df->db())),
+    Field<Type>(df),
+    mesh_(df->mesh_),
+    dimensions_(df->dimensions_)
+{}
+
+
 #ifdef ConstructFromTmp
 template<class Type, class GeoMesh>
 DimensionedField<Type, GeoMesh>::DimensionedField
@@ -248,7 +275,7 @@ DimensionedField<Type, GeoMesh>::~DimensionedField()
 template<class Type, class GeoMesh>
 const DimensionedField<Type, GeoMesh>& DimensionedField<Type, GeoMesh>::null()
 {
-    DimensionedField<Type, GeoMesh>* nullPtr = 
+    DimensionedField<Type, GeoMesh>* nullPtr =
         reinterpret_cast<DimensionedField<Type, GeoMesh>*>(NULL);
     return *nullPtr;
 }
@@ -258,8 +285,8 @@ template<class Type, class GeoMesh>
 tmp
 <
     DimensionedField
-        <typename DimensionedField<Type, GeoMesh>::cmptType, GeoMesh> 
-> 
+        <typename DimensionedField<Type, GeoMesh>::cmptType, GeoMesh>
+>
 DimensionedField<Type, GeoMesh>::component
 (
     const direction d
@@ -315,7 +342,7 @@ void DimensionedField<Type, GeoMesh>::replace
 
 
 template<class Type, class GeoMesh>
-tmp<DimensionedField<Type, GeoMesh> > 
+tmp<DimensionedField<Type, GeoMesh> >
 DimensionedField<Type, GeoMesh>::T() const
 {
     tmp<DimensionedField<Type, GeoMesh> > result
diff --git a/src/OpenFOAM/fields/DimensionedFields/DimensionedField/DimensionedField.H b/src/OpenFOAM/fields/DimensionedFields/DimensionedField/DimensionedField.H
index 8a3fbea757..0035427672 100644
--- a/src/OpenFOAM/fields/DimensionedFields/DimensionedField/DimensionedField.H
+++ b/src/OpenFOAM/fields/DimensionedFields/DimensionedField/DimensionedField.H
@@ -49,7 +49,7 @@ namespace Foam
 {
 
 // Forward declaration of friend functions and operators
- 
+
 template<class Type, class GeoMesh> class DimensionedField;
 
 template<class Type, class GeoMesh> Ostream& operator<<
@@ -156,6 +156,12 @@ public:
             bool reUse
         );
 
+        //- Construct by transferring the DimensionedField
+        DimensionedField
+        (
+            const xfer<DimensionedField<Type, GeoMesh> >&
+        );
+
         //- Construct as copy of tmp<DimensionedField> deleting argument
 #       ifdef ConstructFromTmp
         DimensionedField
@@ -186,6 +192,13 @@ public:
             bool reUse
         );
 
+        //- Construct by transferring the DimensionedField with a new name
+        DimensionedField
+        (
+            const word& newName,
+            const xfer<DimensionedField<Type, GeoMesh> >&
+        );
+
         //- Construct as copy resetting name
 #       ifdef ConstructFromTmp
         DimensionedField
diff --git a/src/OpenFOAM/fields/FieldFields/FieldField/FieldField.H b/src/OpenFOAM/fields/FieldFields/FieldField/FieldField.H
index 958e2f259b..4d7bb8552d 100644
--- a/src/OpenFOAM/fields/FieldFields/FieldField/FieldField.H
+++ b/src/OpenFOAM/fields/FieldFields/FieldField/FieldField.H
@@ -37,6 +37,7 @@ SourceFiles
 #define FieldField_H
 
 #include "tmp.H"
+#include "xfer.H"
 #include "PtrList.H"
 #include "scalar.H"
 #include "direction.H"
diff --git a/src/OpenFOAM/fields/Fields/Field/Field.C b/src/OpenFOAM/fields/Fields/Field/Field.C
index c14b08b2b9..994f8ee630 100644
--- a/src/OpenFOAM/fields/Fields/Field/Field.C
+++ b/src/OpenFOAM/fields/Fields/Field/Field.C
@@ -155,6 +155,13 @@ Field<Type>::Field(Field<Type>& f, bool reUse)
 {}
 
 
+template<class Type>
+Field<Type>::Field(const xfer<Field<Type> >& f)
+:
+    List<Type>(f)
+{}
+
+
 template<class Type>
 Field<Type>::Field(const typename Field<Type>::subField& sf)
 :
@@ -568,6 +575,20 @@ void Field<Type>::replace
 }
 
 
+template<class Type>
+void Field<Type>::transfer(Field<Type>& f)
+{
+    List<Type>::transfer(f);
+}
+
+
+template<class Type>
+void Field<Type>::transfer(List<Type>& lst)
+{
+    List<Type>::transfer(lst);
+}
+
+
 template<class Type>
 tmp<Field<Type> > Field<Type>::T() const
 {
diff --git a/src/OpenFOAM/fields/Fields/Field/Field.H b/src/OpenFOAM/fields/Fields/Field/Field.H
index 3c60dcf126..8e168cb0ac 100644
--- a/src/OpenFOAM/fields/Fields/Field/Field.H
+++ b/src/OpenFOAM/fields/Fields/Field/Field.H
@@ -43,6 +43,7 @@ SourceFiles
 #define Field_H
 
 #include "tmp.H"
+#include "xfer.H"
 #include "direction.H"
 #include "VectorSpace.H"
 #include "scalarList.H"
@@ -164,6 +165,9 @@ public:
         //- Construct as copy or re-use as specified.
         Field(Field<Type>&, bool reUse);
 
+        //- Construct by transferring the Field contents
+        Field(const xfer<Field<Type> >&);
+
         //- Construct as copy of subField
         Field(const typename Field<Type>::subField&);
 
@@ -293,6 +297,12 @@ public:
         //- Replace a component field of the field
         void replace(const direction, const cmptType&);
 
+        //- Transfer the contents of the argument Field into this Field
+        void transfer(Field<Type>&);
+
+        //- Transfer the contents of the argument List into this Field
+        void transfer(List<Type>&);
+
         //- Return the field transpose (only defined for second rank tensors)
         tmp<Field<Type> > T() const;
 
diff --git a/src/OpenFOAM/memory/xfer/xfer.H b/src/OpenFOAM/memory/xfer/xfer.H
index 45912d39a8..e13782c9f4 100644
--- a/src/OpenFOAM/memory/xfer/xfer.H
+++ b/src/OpenFOAM/memory/xfer/xfer.H
@@ -30,7 +30,7 @@ Description
     of objects of type \<T\>.
 
     Since it is decided upon construction of the xfer object whether the
-    parameter is to be copied or transferred, the contents of resulting
+    parameter is to be copied or transferred, the contents of the resulting
     object can be transferred unconditionally.
 
     This greatly simplifies defining the constructors for other classes
@@ -39,10 +39,6 @@ Description
     The wrapped object of type \<T\> must implement a transfer() method and
     an operator=() copy method.
 
-Note
-    The macros xferCopy(T,arg) and xferMove(T,arg) can be used as
-    workarounds for passing temporaries to copy-constructors.
-
 SourceFiles
     xferI.H
 
@@ -56,6 +52,9 @@ SourceFiles
 namespace Foam
 {
 
+// Forward declaration of classes
+template<class T> class tmp;
+
 /*---------------------------------------------------------------------------*\
                            Class xfer Declaration
 \*---------------------------------------------------------------------------*/
@@ -97,52 +96,65 @@ public:
         //- Transfer the contents into the object
         inline void operator=(const xfer<T>&);
 
-        //- Return a non-const reference to const object
-        //  @sa xferCopy, xferMove macros alternatives for copy-constructors
-        inline const xfer<T>& operator()() const;
-
         //- Reference to the underlying datatype
-        inline T& operator*() const;
+        inline T& operator()() const;
+
+        //- Pointer to the underlying datatype
+        inline T* operator->() const;
 
 };
 
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-} // End namespace Foam
-
 /**
- * @def xferCopy(T,arg)
+ * @fn template<class T> xferCopy(const T&)
  * Construct by copying the contents of the @a arg
- * and return a const reference to an xfer of type \<T\>
  *
- * Useful for constructors where the argument is temporary.
- * This is a workaround for a template resolution issue.
- *
- * @sa xferMove and Foam::xfer
+ * @sa xferMove, xferTmp and Foam::xfer
 */
-#define xferCopy(T,arg) \
-    (static_cast<const Foam::xfer< T >&>(Foam::xfer< T >(arg)()))
+template<class T>
+Foam::xfer<T> xferCopy(const T& t)
+{
+    return Foam::xfer<T>(t);
+}
+
 
 /**
- * @def xferMove(T,arg)
+ * @fn template<class T> xferMove(T&)
  * Construct by transferring the contents of the @a arg
- * and return a const reference to an xfer of type \<T\>
- *
- * Useful for constructors where the argument is temporary.
- * This is a workaround for a template resolution issue.
  *
  * @par Example Use
  * @code
  *     List<label> a;
  *     ...
- *     List<label> b(xferMove(List<label>, a));
+ *     List<label> b(xferMove(a));
  * @endcode
  *
- * @sa xferCopy and Foam::xfer
+ * @sa xferCopy, xferTmp and Foam::xfer
 */
-#define xferMove(T,arg) \
-    (static_cast<const Foam::xfer< T >&>(Foam::xfer< T >(arg, true)()))
+template<class T>
+Foam::xfer<T> xferMove(T& t)
+{
+    return Foam::xfer<T>(t, true);
+}
+
+
+/**
+ * @fn template<class T> xferTmp(tmp<T>&)
+ * Construct by transferring the contents of the @a arg
+ *
+ * @sa xferCopy, xferMove and Foam::xfer
+*/
+template<class T>
+Foam::xfer<T> xferTmp(Foam::tmp<T>& tt)
+{
+    return Foam::xfer<T>(tt(), tt.isTmp());
+}
+
+
+} // End namespace Foam
+
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
diff --git a/src/OpenFOAM/memory/xfer/xferI.H b/src/OpenFOAM/memory/xfer/xferI.H
index 8ad7ceb3aa..55830008a9 100644
--- a/src/OpenFOAM/memory/xfer/xferI.H
+++ b/src/OpenFOAM/memory/xfer/xferI.H
@@ -98,16 +98,16 @@ inline void Foam::xfer<T>::operator=(const xfer<T>& t)
 
 
 template<class T>
-inline const Foam::xfer<T>& Foam::xfer<T>::operator()() const
-{
-    return *this;
-}
-
-
-template<class T>
-inline T& Foam::xfer<T>::operator*() const
+inline T& Foam::xfer<T>::operator()() const
 {
     return *ptr_;
 }
 
+
+template<class T>
+inline T* Foam::xfer<T>::operator->() const
+{
+    return ptr_;
+}
+
 // ************************************************************************* //
diff --git a/src/OpenFOAM/meshes/MeshObject/MeshObject.C b/src/OpenFOAM/meshes/MeshObject/MeshObject.C
index ba67517700..340df29e67 100644
--- a/src/OpenFOAM/meshes/MeshObject/MeshObject.C
+++ b/src/OpenFOAM/meshes/MeshObject/MeshObject.C
@@ -65,11 +65,11 @@ const Type& Foam::MeshObject<Mesh, Type>::New
 
 
 template<class Mesh, class Type>
-template<class Data>
+template<class Data1>
 const Type& Foam::MeshObject<Mesh, Type>::New
 (
     const Mesh& mesh,
-    const Data& d
+    const Data1& d
 )
 {
     if (!mesh.db().objectRegistry::foundObject<Type>(Type::typeName))
@@ -103,6 +103,49 @@ const Type& Foam::MeshObject<Mesh, Type>::New
 }
 
 
+template<class Mesh, class Type>
+template<class Data1, class Data2, class Data3>
+const Type& Foam::MeshObject<Mesh, Type>::New
+(
+    const Mesh& mesh,
+    const Data1& d1,
+    const Data2& d2,
+    const Data3& d3
+)
+{
+    if (!mesh.db().objectRegistry::foundObject<Type>(Type::typeName))
+    {
+        return store(new Type(mesh, d1, d2, d3));
+    }
+    else
+    {
+        return mesh.db().objectRegistry::lookupObject<Type>(Type::typeName);
+    }
+}
+
+
+template<class Mesh, class Type>
+template<class Data1, class Data2, class Data3, class Data4>
+const Type& Foam::MeshObject<Mesh, Type>::New
+(
+    const Mesh& mesh,
+    const Data1& d1,
+    const Data2& d2,
+    const Data3& d3,
+    const Data4& d4
+)
+{
+    if (!mesh.db().objectRegistry::foundObject<Type>(Type::typeName))
+    {
+        return store(new Type(mesh, d3, d4));
+    }
+    else
+    {
+        return mesh.db().objectRegistry::lookupObject<Type>(Type::typeName);
+    }
+}
+
+
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * //
 
 template<class Mesh, class Type>
diff --git a/src/OpenFOAM/meshes/MeshObject/MeshObject.H b/src/OpenFOAM/meshes/MeshObject/MeshObject.H
index ee20ccfa3e..3bf11b5f6a 100644
--- a/src/OpenFOAM/meshes/MeshObject/MeshObject.H
+++ b/src/OpenFOAM/meshes/MeshObject/MeshObject.H
@@ -69,11 +69,39 @@ public:
 
         static const Type& New(const Mesh& mesh);
 
-        template<class Data>
-        static const Type& New(const Mesh& mesh, const Data& d);
+        template<class Data1>
+        static const Type& New
+        (
+            const Mesh& mesh,
+            const Data1& d
+        );
 
         template<class Data1, class Data2>
-        static const Type& New(const Mesh& mesh, const Data1&, const Data2&);
+        static const Type& New
+        (
+            const Mesh& mesh,
+            const Data1&,
+            const Data2&
+        );
+
+        template<class Data1, class Data2, class Data3>
+        static const Type& New
+        (
+            const Mesh& mesh,
+            const Data1&,
+            const Data2&,
+            const Data3&
+        );
+
+        template<class Data1, class Data2, class Data3, class Data4>
+        static const Type& New
+        (
+            const Mesh& mesh,
+            const Data1&,
+            const Data2&,
+            const Data3&,
+            const Data4&
+        );
 
 
     // Destructor
diff --git a/src/OpenFOAM/meshes/polyMesh/polyMesh.H b/src/OpenFOAM/meshes/polyMesh/polyMesh.H
index b813aa7c68..d794705216 100644
--- a/src/OpenFOAM/meshes/polyMesh/polyMesh.H
+++ b/src/OpenFOAM/meshes/polyMesh/polyMesh.H
@@ -170,6 +170,9 @@ private:
         //- Initialise the polyMesh from the given set of cells
         void initMesh(cellList& c);
 
+        //- Initialise the polyMesh from the given set of cells
+        void initMesh(const xfer<cellList>& c);
+
         //- Calculate the valid directions in the mesh from the boundaries
         void calcDirections() const;
 
@@ -226,6 +229,18 @@ public:
             const bool syncPar = true
         );
 
+        //- Construct without boundary from components.
+        //  Boundary is added using addPatches() member function
+        polyMesh
+        (
+            const IOobject& io,
+            const xfer<pointField>& points,
+            const xfer<faceList>& faces,
+            const xfer<labelList>& owner,
+            const xfer<labelList>& neighbour,
+            const bool syncPar = true
+        );
+
         //- Construct without boundary with cells rather than owner/neighbour.
         //  Boundary is added using addPatches() member function
         polyMesh
@@ -237,6 +252,17 @@ public:
             const bool syncPar = true
         );
 
+        //- Construct without boundary with cells rather than owner/neighbour.
+        //  Boundary is added using addPatches() member function
+        polyMesh
+        (
+            const IOobject& io,
+            const xfer<pointField>& points,
+            const xfer<faceList>& faces,
+            const xfer<cellList>& cells,
+            const bool syncPar = true
+        );
+
         //- Construct from cell shapes
         polyMesh
         (
@@ -444,6 +470,23 @@ public:
                 const bool validBoundary = true
             );
 
+            //- Reset mesh primitive data. Assumes all patch info correct
+            //  (so does e.g. parallel communication). If not use
+            //  validBoundary=false
+            //  (still assumes patchStarts[0] = nInternalFaces and last
+            //  patch ends at nActiveFaces) and change patches with addPatches.
+            void resetPrimitives
+            (
+                const label nUsedFaces,
+                const xfer<pointField>& points,
+                const xfer<faceList>& faces,
+                const xfer<labelList>& owner,
+                const xfer<labelList>& neighbour,
+                const labelList& patchSizes,
+                const labelList& patchStarts,
+                const bool validBoundary = true
+            );
+
 
         //  Storage management
 
diff --git a/src/OpenFOAM/meshes/polyMesh/polyMeshInitMesh.C b/src/OpenFOAM/meshes/polyMesh/polyMeshInitMesh.C
index a1cfa9c63a..d4d74ee22d 100644
--- a/src/OpenFOAM/meshes/polyMesh/polyMeshInitMesh.C
+++ b/src/OpenFOAM/meshes/polyMesh/polyMeshInitMesh.C
@@ -155,4 +155,10 @@ void Foam::polyMesh::initMesh(cellList& c)
 }
 
 
+void Foam::polyMesh::initMesh(const xfer<cellList>& clst)
+{
+    initMesh(clst());
+}
+
+
 // ************************************************************************* //
diff --git a/src/OpenFOAM/meshes/primitiveMesh/primitiveMesh.C b/src/OpenFOAM/meshes/primitiveMesh/primitiveMesh.C
index 6bcc2af56f..fece5b2220 100644
--- a/src/OpenFOAM/meshes/primitiveMesh/primitiveMesh.C
+++ b/src/OpenFOAM/meshes/primitiveMesh/primitiveMesh.C
@@ -29,16 +29,15 @@ License
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 namespace Foam
 {
-
-// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
-
-defineTypeNameAndDebug(primitiveMesh, 0);
+    defineTypeNameAndDebug(primitiveMesh, 0);
+}
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
-primitiveMesh::primitiveMesh()
+Foam::primitiveMesh::primitiveMesh()
 :
     nInternalPoints_(0),    // note: points are considered ordered on empty mesh
     nPoints_(0),
@@ -76,8 +75,8 @@ primitiveMesh::primitiveMesh()
 
 
 // Construct from components
-// WARNING: ASSUMES CORRECT ORDERING OF DATA. 
-primitiveMesh::primitiveMesh
+// WARNING: ASSUMES CORRECT ORDERING OF DATA.
+Foam::primitiveMesh::primitiveMesh
 (
     const label nPoints,
     const label nInternalFaces,
@@ -114,14 +113,12 @@ primitiveMesh::primitiveMesh
     faceCentresPtr_(NULL),
     cellVolumesPtr_(NULL),
     faceAreasPtr_(NULL)
-{
-    
-}
+{}
 
 
 // * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 
-primitiveMesh::~primitiveMesh()
+Foam::primitiveMesh::~primitiveMesh()
 {
     clearOut();
 }
@@ -129,7 +126,7 @@ primitiveMesh::~primitiveMesh()
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
-bool primitiveMesh::calcPointOrder
+bool Foam::primitiveMesh::calcPointOrder
 (
     label& nInternalPoints,
     labelList& oldToNew,
@@ -208,7 +205,7 @@ bool primitiveMesh::calcPointOrder
 }
 
 
-void primitiveMesh::reset
+void Foam::primitiveMesh::reset
 (
     const label nPoints,
     const label nInternalFaces,
@@ -264,13 +261,13 @@ void primitiveMesh::reset
 }
 
 
-void primitiveMesh::reset
+void Foam::primitiveMesh::reset
 (
     const label nPoints,
     const label nInternalFaces,
     const label nFaces,
     const label nCells,
-    cellList& c
+    cellList& clst
 )
 {
     reset
@@ -281,11 +278,32 @@ void primitiveMesh::reset
         nCells
     );
 
-    cfPtr_ = new cellList(c, true);
+    cfPtr_ = new cellList(clst, true);
 }
 
 
-tmp<scalarField> primitiveMesh::movePoints
+void Foam::primitiveMesh::reset
+(
+    const label nPoints,
+    const label nInternalFaces,
+    const label nFaces,
+    const label nCells,
+    const xfer<cellList>& clst
+)
+{
+    reset
+    (
+        nPoints,
+        nInternalFaces,
+        nFaces,
+        nCells
+    );
+
+    cfPtr_ = new cellList(clst);
+}
+
+
+Foam::tmp<Foam::scalarField> Foam::primitiveMesh::movePoints
 (
     const pointField& newPoints,
     const pointField& oldPoints
@@ -320,7 +338,7 @@ tmp<scalarField> primitiveMesh::movePoints
 }
 
 
-const cellShapeList& primitiveMesh::cellShapes() const
+const Foam::cellShapeList& Foam::primitiveMesh::cellShapes() const
 {
     if (!cellShapesPtr_)
     {
@@ -331,8 +349,4 @@ const cellShapeList& primitiveMesh::cellShapes() const
 }
 
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
-
 // ************************************************************************* //
diff --git a/src/OpenFOAM/meshes/primitiveMesh/primitiveMesh.H b/src/OpenFOAM/meshes/primitiveMesh/primitiveMesh.H
index 6f24944cbc..6150670a7f 100644
--- a/src/OpenFOAM/meshes/primitiveMesh/primitiveMesh.H
+++ b/src/OpenFOAM/meshes/primitiveMesh/primitiveMesh.H
@@ -375,6 +375,17 @@ public:
         );
 
 
+        //- Reset this primitiveMesh given the primitive array sizes and cells
+        void reset
+        (
+            const label nPoints,
+            const label nInternalFaces,
+            const label nFaces,
+            const label nCells,
+            const xfer<cellList>& cells
+        );
+
+
         // Access
 
             // Mesh size parameters
diff --git a/src/conversion/meshReader/calcPointCells.C b/src/conversion/meshReader/calcPointCells.C
index 59d47a2f3b..03a92afe22 100644
--- a/src/conversion/meshReader/calcPointCells.C
+++ b/src/conversion/meshReader/calcPointCells.C
@@ -30,9 +30,6 @@ Description
 
 #include "meshReader.H"
 
-// for transition - in case someone really relied on the old behaviour
-#undef LEAVE_UNUSED_POINTS
-
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 void Foam::meshReader::calcPointCells() const
@@ -46,7 +43,7 @@ void Foam::meshReader::calcPointCells() const
             << abort(FatalError);
     }
 
-    label nPoints = points().size();
+    label nPoints = points_.size();
 
     pointCellsPtr_ = new labelListList(nPoints);
     labelListList& ptCells = *pointCellsPtr_;
@@ -132,19 +129,15 @@ void Foam::meshReader::calcPointCells() const
     // report unused points
     if (nPoints > pointI)
     {
-#ifdef LEAVE_UNUSED_POINTS
-        FatalErrorIn("meshReader::calcPointCells() const")
-            << "mesh has " << (nPoints - pointI)
-            << " points that were declared but not used" << endl;
-#else
-
         Info<< "removing " << (nPoints - pointI) << " unused points" << endl;
 
         nPoints = pointI;
 
-        // adjust points and truncate
-        inplaceReorder(oldToNew, points());
-        points().setSize(nPoints);
+        // adjust points and truncate - bend const-ness
+        pointField& adjustedPoints = const_cast<pointField&>(points_);
+
+        inplaceReorder(oldToNew, adjustedPoints);
+        adjustedPoints.setSize(nPoints);
 
         // adjust pointCells and truncate
         inplaceReorder(oldToNew, ptCells);
@@ -162,7 +155,6 @@ void Foam::meshReader::calcPointCells() const
                 inplaceRenumber(oldToNew, faces[i]);
             }
         }
-#endif
     }
 }
 
diff --git a/src/conversion/meshReader/meshReader.C b/src/conversion/meshReader/meshReader.C
index 8449c93e22..d35429c8db 100644
--- a/src/conversion/meshReader/meshReader.C
+++ b/src/conversion/meshReader/meshReader.C
@@ -142,7 +142,7 @@ Foam::autoPtr<Foam::polyMesh> Foam::meshReader::mesh
                 "constant",
                 registry
             ),
-            points(),
+            points_,
             meshFaces_,
             cellPolys_
         )
diff --git a/src/conversion/meshReader/meshReader.H b/src/conversion/meshReader/meshReader.H
index e14ef19137..422eb6c58d 100644
--- a/src/conversion/meshReader/meshReader.H
+++ b/src/conversion/meshReader/meshReader.H
@@ -291,13 +291,6 @@ protected:
         //- Subclasses are required to supply this information
         virtual bool readGeometry(const scalar scaleFactor = 1.0) = 0;
 
-        //- Return mesh points
-        pointField& points() const
-        {
-            return const_cast<pointField&>(points_);
-        }
-
-
 public:
 
     // Static Members
diff --git a/src/finiteVolume/fvMesh/fvMesh.H b/src/finiteVolume/fvMesh/fvMesh.H
index f28c72ad4e..d89b92a82d 100644
--- a/src/finiteVolume/fvMesh/fvMesh.H
+++ b/src/finiteVolume/fvMesh/fvMesh.H
@@ -180,6 +180,18 @@ public:
             const bool syncPar = true
         );
 
+        //- Construct from components without boundary.
+        //  Boundary is added using addFvPatches() member function
+        fvMesh
+        (
+            const IOobject& io,
+            const xfer<pointField>& points,
+            const xfer<faceList>& faces,
+            const xfer<labelList>& allOwner,
+            const xfer<labelList>& allNeighbour,
+            const bool syncPar = true
+        );
+
         //- Construct from components with cells rather than owner
         //  and neighbourwithout boundary.
         //  Boundary is added using addPatches() member function
@@ -192,6 +204,18 @@ public:
             const bool syncPar = true
         );
 
+        //- Construct from components with cells rather than owner
+        //  and neighbourwithout boundary.
+        //  Boundary is added using addPatches() member function
+        fvMesh
+        (
+            const IOobject& io,
+            const xfer<pointField>& points,
+            const xfer<faceList>& faces,
+            const xfer<cellList>& cells,
+            const bool syncPar = true
+        );
+
 
     // Destructor
 
@@ -295,7 +319,7 @@ public:
             virtual void updateMesh(const mapPolyMesh& mpm);
 
             //- Move points, returns volumes swept by faces in motion
-            virtual tmp<scalarField> movePoints(const vectorField&);
+            virtual tmp<scalarField> movePoints(const pointField&);
 
             //- Map all fields in time using given map.
             virtual void mapFields(const mapPolyMesh& mpm);
diff --git a/src/finiteVolume/interpolation/surfaceInterpolation/schemes/quadraticFit/quadraticFit.H b/src/finiteVolume/interpolation/surfaceInterpolation/schemes/quadraticFit/quadraticFit.H
index ff9a668f3d..c1308c6ba3 100644
--- a/src/finiteVolume/interpolation/surfaceInterpolation/schemes/quadraticFit/quadraticFit.H
+++ b/src/finiteVolume/interpolation/surfaceInterpolation/schemes/quadraticFit/quadraticFit.H
@@ -23,7 +23,7 @@ License
     Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 
 Class
-    quadraticFit
+    Foam::quadraticFit
 
 Description
     Quadratic fit interpolation scheme which applies an explicit correction to
@@ -56,8 +56,16 @@ class quadraticFit
     public linear<Type>
 {
     // Private Data
+
+        //- Factor the fit is allowed to deviate from linear.
+        //  This limits the amount of high-order correction and increases
+        //  stability on bad meshes
+        const scalar linearLimitFactor_;
+
+        //- Weights for central stencil
         const scalar centralWeight_;
 
+
     // Private Member Functions
 
         //- Disallow default bitwise copy construct
@@ -79,6 +87,7 @@ public:
         quadraticFit(const fvMesh& mesh, Istream& is)
         :
             linear<Type>(mesh),
+            linearLimitFactor_(readScalar(is)),
             centralWeight_(readScalar(is))
         {}
 
@@ -92,6 +101,7 @@ public:
         )
         :
             linear<Type>(mesh),
+            linearLimitFactor_(readScalar(is)),
             centralWeight_(readScalar(is))
         {}
 
@@ -123,6 +133,7 @@ public:
             (
                 mesh,
                 stencil,
+                linearLimitFactor_,
                 centralWeight_
             );
 
diff --git a/src/finiteVolume/interpolation/surfaceInterpolation/schemes/quadraticFit/quadraticFitData.C b/src/finiteVolume/interpolation/surfaceInterpolation/schemes/quadraticFit/quadraticFitData.C
index c5269877d8..868d33b6f3 100644
--- a/src/finiteVolume/interpolation/surfaceInterpolation/schemes/quadraticFit/quadraticFitData.C
+++ b/src/finiteVolume/interpolation/surfaceInterpolation/schemes/quadraticFit/quadraticFitData.C
@@ -41,16 +41,16 @@ namespace Foam
 
 // * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
 
-static int count = 0;
-
 Foam::quadraticFitData::quadraticFitData
 (
     const fvMesh& mesh,
     const extendedCentredStencil& stencil,
+    const scalar linearLimitFactor,
     const scalar cWeight
 )
 :
     MeshObject<fvMesh, quadraticFitData>(mesh),
+    linearLimitFactor_(linearLimitFactor),
     centralWeight_(cWeight),
 #   ifdef SPHERICAL_GEOMETRY
     dim_(2),
@@ -61,7 +61,7 @@ Foam::quadraticFitData::quadraticFitData
     (
         dim_ == 1 ? 3 :
         dim_ == 2 ? 6 :
-        dim_ == 3 ? 9 : 0
+        dim_ == 3 ? 7 : 0
     ),
     fit_(mesh.nInternalFaces())
 {
@@ -116,8 +116,6 @@ Foam::quadraticFitData::quadraticFitData
         interpPolySize[faci] = calcFit(stencilPoints[faci], faci);
     }
 
-    Pout<< "count = " << count << endl;
-
     if (debug)
     {
         Info<< "quadraticFitData::quadraticFitData() :"
@@ -243,14 +241,14 @@ Foam::label Foam::quadraticFitData::calcFit
         {
             B[ip][is++] = wts[ip]*py;
             B[ip][is++] = wts[ip]*px*py;
-            B[ip][is++] = wts[ip]*sqr(py);
+            //B[ip][is++] = wts[ip]*sqr(py);
         }
         if (dim_ == 3)
         {
             B[ip][is++] = wts[ip]*pz;
             B[ip][is++] = wts[ip]*px*pz;
             //B[ip][is++] = wts[ip]*py*pz;
-            B[ip][is++] = wts[ip]*sqr(pz);
+            //B[ip][is++] = wts[ip]*sqr(pz);
         }
     }
 
@@ -274,15 +272,15 @@ Foam::label Foam::quadraticFitData::calcFit
         //goodFit = (fit0 > 0 && fit1 > 0);
 
         goodFit =
-            (mag(fit0 - w[faci])/w[faci] < 0.15)
-         && (mag(fit1 - (1 - w[faci]))/(1 - w[faci]) < 0.15);
+            (mag(fit0 - w[faci])/w[faci] < linearLimitFactor_)
+         && (mag(fit1 - (1 - w[faci]))/(1 - w[faci]) < linearLimitFactor_);
 
         //scalar w0Err = fit0/w[faci];
         //scalar w1Err = fit1/(1 - w[faci]);
 
         //goodFit =
-        //    (w0Err > 0.5 && w0Err < 1.5)
-        // && (w1Err > 0.5 && w1Err < 1.5);
+        //    (w0Err > linearLimitFactor_ && w0Err < (1 + linearLimitFactor_))
+        // && (w1Err > linearLimitFactor_ && w1Err < (1 + linearLimitFactor_));
 
         if (goodFit)
         {
@@ -324,13 +322,6 @@ Foam::label Foam::quadraticFitData::calcFit
 
     if (goodFit)
     {
-         if ((mag(fit_[faci][0] - w[faci])/w[faci] < 0.15)
-         && (mag(fit_[faci][1] - (1 - w[faci]))/(1 - w[faci]) < 0.15))
-         {
-             count++;
-             //Pout<< "fit " << mag(fit_[faci][0] - w[faci])/w[faci] << " " << mag(fit_[faci][1] - (1 - w[faci]))/(1 - w[faci]) << endl;
-         }
-
         // scalar limiter =
         // max
         // (
@@ -358,6 +349,7 @@ Foam::label Foam::quadraticFitData::calcFit
         Pout<< "Could not fit face " << faci
             << " " << fit_[faci][0] << " " << w[faci]
             << " " << fit_[faci][1] << " " << 1 - w[faci]<< endl;
+
         fit_[faci] = 0;
     }
 
diff --git a/src/finiteVolume/interpolation/surfaceInterpolation/schemes/quadraticFit/quadraticFitData.H b/src/finiteVolume/interpolation/surfaceInterpolation/schemes/quadraticFit/quadraticFitData.H
index b44a2e4d90..f0da60901d 100644
--- a/src/finiteVolume/interpolation/surfaceInterpolation/schemes/quadraticFit/quadraticFitData.H
+++ b/src/finiteVolume/interpolation/surfaceInterpolation/schemes/quadraticFit/quadraticFitData.H
@@ -23,7 +23,7 @@ License
     Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 
 Class
-    quadraticFitData
+    Foam::quadraticFitData
 
 Description
     Data for the quadratic fit correction interpolation scheme
@@ -56,13 +56,18 @@ class quadraticFitData
 {
     // Private data
 
-        //- weights for central stencil
+        //- Factor the fit is allowed to deviate from linear.
+        //  This limits the amount of high-order correction and increases
+        //  stability on bad meshes
+        const scalar linearLimitFactor_;
+
+        //- Weights for central stencil
         const scalar centralWeight_;
 
-        //- dimensionality of the geometry
+        //- Dimensionality of the geometry
         const label dim_;
 
-        //- minimum stencil size
+        //- Minimum stencil size
         const label minSize_;
 
         //- For each cell in the mesh store the values which multiply the
@@ -96,19 +101,18 @@ public:
         (
             const fvMesh& mesh,
             const extendedCentredStencil& stencil,
-            scalar cWeightDim
+            const scalar linearLimitFactor,
+            const scalar centralWeight
         );
 
 
-    // Destructor
-
-        virtual ~quadraticFitData()
-        {}
+    //- Destructor
+    virtual ~quadraticFitData()
+    {}
 
 
     // Member functions
 
-
         //- Return reference to fit coefficients
         const List<scalarList>& fit() const
         {
diff --git a/wmake/wmakeScheduler b/wmake/wmakeScheduler
index a4c88624ab..17a7a2b748 100755
--- a/wmake/wmakeScheduler
+++ b/wmake/wmakeScheduler
@@ -163,18 +163,6 @@ colourPipe()
 }
 
 
-#
-# prefix message with [HOSTNAME]
-#
-prefixPipe()
-{
-   while read line
-   do
-      echo "[$@] $line"
-   done
-}
-
-
 colourIndex=0
 
 while :
@@ -202,19 +190,15 @@ do
 
                if [ "$host" = "$HOST" ]; then
                   eval $* 2>&1 | colourPipe "$colour"
-               elif [ -n "$JOB_ID" ]; then
-                  qrsh -inherit -v PWD $host "$rcmd"
                else
                   ssh $host "$sourceFoam 2>/dev/null; cd $PWD && $rcmd" 2>&1 | colourPipe "$colour"
                fi
                retval=$?
             else
                if [ "$host" = "$HOST" ]; then
-                  eval $* 2>&1 | prefixPipe "$host"
-               elif [ -n "$JOB_ID" ]; then
-                  qrsh -inherit -v PWD $host "$rcmd" | prefixPipe "$host"
+                  eval $* 2>&1
                else
-                  ssh $host "$sourceFoam 2>/dev/null; cd $PWD && $rcmd" 2>&1 | prefixPipe "$host"
+                  ssh $host "$sourceFoam 2>/dev/null; cd $PWD && $rcmd" 2>&1
                fi
                retval=$?
             fi