ENH: FieldMapper: extend with unmapped checking flag

applications/utilities/parallelProcessing/decomposePar/dimFieldDecomposer.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -37,7 +37,6 @@ SourceFiles
 #define dimFieldDecomposer_H
 
 #include "fvMesh.H"
-#include "fvPatchFieldMapper.H"
 #include "surfaceFields.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

applications/utilities/parallelProcessing/decomposePar/pointFieldDecomposer.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -39,7 +39,8 @@ Foam::pointFieldDecomposer::patchFieldDecomposer::patchFieldDecomposer
         completeMeshPatch,
         procMeshPatch
     ),
-    directAddressing_(procMeshPatch.size(), -1)
+    directAddressing_(procMeshPatch.size(), -1),
+    hasUnmapped_(false)
 {
     // Create the inverse-addressing of the patch point labels.
     labelList pointMap(completeMeshPatch.boundaryMesh().mesh().size(), -1);
@@ -64,6 +65,8 @@ Foam::pointFieldDecomposer::patchFieldDecomposer::patchFieldDecomposer
     // Check that all the patch point addresses are set
     if (directAddressing_.size() && min(directAddressing_) < 0)
     {
+        hasUnmapped_ = true;
+
         FatalErrorIn
         (
             "pointFieldDecomposer::patchFieldDecomposer()"

applications/utilities/parallelProcessing/decomposePar/pointFieldDecomposer.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -63,6 +63,9 @@ public:
 
                 labelList directAddressing_;
 
+                //- Does map contain any unmapped values
+                bool hasUnmapped_;
+
         public:
 
             // Constructors
@@ -88,6 +91,11 @@ public:
                     return true;
                 }
 
+                bool hasUnmapped() const
+                {
+                    return hasUnmapped_;
+                }
+
                 const labelUList& directAddressing() const
                 {
                     return directAddressing_;

src/OpenFOAM/fields/Fields/Field/FieldMapper.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -64,6 +64,10 @@ public:
 
         virtual bool direct() const = 0;
 
+        //- Are there unmapped values? I.e. do all size() elements get
+        //  get value
+        virtual bool hasUnmapped() const = 0;
+
         virtual const labelUList& directAddressing() const
         {
             FatalErrorIn("FieldMapper::directAddressing() const")

src/OpenFOAM/fields/Fields/Field/directFieldMapper.H

@@ -0,0 +1,104 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::directFieldMapper
+
+Description
+    FieldMapper with direct mapping.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef directFieldMapper_H
+#define directFieldMapper_H
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                           Class directFieldMapper Declaration
+\*---------------------------------------------------------------------------*/
+
+class directFieldMapper
+:
+    public FieldMapper
+{
+    const labelUList& directAddressing_;
+
+    bool hasUnmapped_;
+
+public:
+
+    // Constructors
+
+        //- Construct given addressing
+        patchFieldSubset(const labelUList& directAddressing)
+        :
+            directAddressing_(directAddressing),
+            hasUnmapped_(false)
+        {
+            if (directAddressing_.size() && min(directAddressing_) < 0)
+            {
+                hasUnmapped_ = true;
+            }
+        }
+
+    //- Destructor
+    virtual ~directFieldMapper()
+    {}
+
+
+    // Member Functions
+
+        label size() const
+        {
+            return directAddressing_.size();
+        }
+
+        bool direct() const
+        {
+            return true;
+        }
+
+        bool hasUnmapped() const
+        {
+            return hasUnmapped_;
+        }
+
+        const labelUList& directAddressing() const
+        {
+            return directAddressing_;
+        }
+};
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/OpenFOAM/fields/pointPatchFields/pointPatchField/directPointPatchFieldMapper.H

@@ -0,0 +1,111 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::directPointPatchFieldMapper
+
+Description
+    direct pointPatchFieldMapper
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef directPointPatchFieldMapper_H
+#define directPointPatchFieldMapper_H
+
+#include "pointPatchFieldMapper.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                       Class directPointPatchFieldMapper Declaration
+\*---------------------------------------------------------------------------*/
+
+class directPointPatchFieldMapper
+:
+    public pointPatchFieldMapper
+{
+
+    //- Addressing from new back to old
+    const labelUList& directAddressing_;
+
+    //- Does map contain any unmapped values
+    bool hasUnmapped_;
+
+
+public:
+
+    // Constructors
+
+        //- Construct given addressing
+        directPointPatchFieldMapper(const labelUList& directAddressing)
+        :
+            directAddressing_(directAddressing),
+            hasUnmapped_(false)
+        {
+            if (directAddressing_.size() && min(directAddressing_) < 0)
+            {
+                hasUnmapped_ = true;
+            }
+        }
+
+    //- Destructor
+    virtual ~directPointPatchFieldMapper()
+    {}
+
+
+    // Member Functions
+
+        label size() const
+        {
+            return directAddressing_.size();
+        }
+
+        bool direct() const
+        {
+            return true;
+        }
+
+        bool hasUnmapped() const
+        {
+            return hasUnmapped_;
+        }
+
+        const labelUList& directAddressing() const
+        {
+            return directAddressing_;
+        }
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/OpenFOAM/meshes/pointMesh/pointMeshMapper/pointMapper.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -129,6 +129,13 @@ public:
             return direct_;
         }
 
+        //- Are there unmapped values? I.e. do all size() elements get
+        //  get value
+        virtual bool hasUnmapped() const
+        {
+            return insertedObjects();
+        }
+
         //- Return direct addressing
         virtual const labelUList& directAddressing() const;
 

src/OpenFOAM/meshes/pointMesh/pointMeshMapper/pointPatchMapper.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -47,6 +47,8 @@ void Foam::pointPatchMapper::calcAddressing() const
             << abort(FatalError);
     }
 
+    hasUnmapped_ = false;
+
     if (direct())
     {
         // Direct mapping.
@@ -57,7 +59,7 @@ void Foam::pointPatchMapper::calcAddressing() const
         {
             if (addr[i] < 0)
             {
-                addr[i] = 0;
+                hasUnmapped_ = true;
             }
         }
     }
@@ -87,9 +89,11 @@ void Foam::pointPatchMapper::calcAddressing() const
             }
             else
             {
-                // Inserted point. Map from point0 (arbitrary choice)
+                // Inserted point.
-                addr[i] = labelList(1, label(0));
+                ///// Map from point0 (arbitrary choice)
-                w[i] = scalarList(1, 1.0);
+                //addr[i] = labelList(1, label(0));
+                //w[i] = scalarList(1, 1.0);
+                hasUnmapped_ = true;
             }
         }
     }
@@ -101,6 +105,7 @@ void Foam::pointPatchMapper::clearOut()
     deleteDemandDrivenData(directAddrPtr_);
     deleteDemandDrivenData(interpolationAddrPtr_);
     deleteDemandDrivenData(weightsPtr_);
+    hasUnmapped_ = false;
 }
 
 
@@ -124,6 +129,7 @@ Foam::pointPatchMapper::pointPatchMapper
       ? mpm_.oldPatchNMeshPoints()[patch_.index()]
       : 0
     ),
+    hasUnmapped_(false),
     directAddrPtr_(NULL),
     interpolationAddrPtr_(NULL),
     weightsPtr_(NULL)

src/OpenFOAM/meshes/pointMesh/pointMeshMapper/pointPatchMapper.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -74,6 +74,8 @@ class pointPatchMapper
 
     // Demand-driven private data
 
+        mutable bool hasUnmapped_;
+
         //- Direct addressing (only one for of addressing is used)
         mutable labelList* directAddrPtr_;
 
@@ -130,6 +132,11 @@ public:
             return patch_.size();
         }
 
+        virtual bool hasUnmapped() const
+        {
+            return hasUnmapped_;
+        }
+
         //- Return size of field before mapping
         virtual label sizeBeforeMapping() const
         {

src/OpenFOAM/meshes/polyMesh/mapPolyMesh/cellMapper/cellMapper.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -130,6 +130,11 @@ public:
             return direct_;
         }
 
+        virtual bool hasUnmapped() const
+        {
+            return insertedObjects();
+        }
+
         //- Return direct addressing
         virtual const labelUList& directAddressing() const;
 
@@ -140,13 +145,13 @@ public:
         virtual const scalarListList& weights() const;
 
         //- Are there any inserted cells
-        bool insertedObjects() const
+        virtual bool insertedObjects() const
         {
             return insertedCells_;
         }
 
         //- Return list of inserted cells
-        const labelList& insertedObjectLabels() const;
+        const virtual labelList& insertedObjectLabels() const;
 };
 
 

src/OpenFOAM/meshes/polyMesh/mapPolyMesh/faceMapper/faceMapper.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -134,6 +134,11 @@ public:
             return direct_;
         }
 
+        virtual bool hasUnmapped() const
+        {
+            return insertedObjects();
+        }
+
         //- Return direct addressing
         virtual const labelUList& directAddressing() const;
 

src/dynamicMesh/fvMeshAdder/fvMeshAdder.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -67,53 +67,6 @@ class fvMeshAdder
 
 private:
 
-
-    // Private class
-
-    class directFvPatchFieldMapper
-    :
-        public fvPatchFieldMapper
-    {
-        // Private data
-
-            const labelList& directAddressing_;
-
-    public:
-
-        // Constructors
-
-            //- Construct from components
-            directFvPatchFieldMapper(const labelList& directAddressing)
-            :
-                fvPatchFieldMapper(),
-                directAddressing_(directAddressing)
-            {}
-
-
-        //- Destructor
-        virtual ~directFvPatchFieldMapper()
-        {}
-
-
-        // Member Functions
-
-            label size() const
-            {
-                return directAddressing_.size();
-            }
-
-            bool direct() const
-            {
-                return true;
-            }
-
-            const labelUList& directAddressing() const
-            {
-                return directAddressing_;
-            }
-    };
-
-
     // Private Member Functions
 
         //- Calculate map from new patch faces to old patch faces. -1 where

src/dynamicMesh/fvMeshAdder/fvMeshAdderTemplates.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -23,10 +23,10 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-
 #include "volFields.H"
 #include "surfaceFields.H"
 #include "emptyFvPatchField.H"
+#include "directFvPatchFieldMapper.H"
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 

src/finiteVolume/fields/fvPatchFields/derived/fixedFluxPressure/fixedFluxPressureFvPatchScalarField.C

@@ -53,8 +53,13 @@ Foam::fixedFluxPressureFvPatchScalarField::fixedFluxPressureFvPatchScalarField
     fixedGradientFvPatchScalarField(p, iF),
     curTimeIndex_(-1)
 {
+    patchType() = ptf.patchType();
+
     // Map value. Set unmapped values and overwrite with mapped ptf
-    fvPatchField<scalar>::operator=(patchInternalField());
+    if (&iF && iF.size())
+    {
+        fvPatchField<scalar>::operator=(patchInternalField());
+    }
     map(ptf, mapper);
     // Map gradient. Set unmapped values and overwrite with mapped ptf
     gradient() = 0.0;

src/finiteVolume/fields/fvPatchFields/fvPatchField/directFvPatchFieldMapper.H

@@ -0,0 +1,111 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::directFvPatchFieldMapper
+
+Description
+    direct fvPatchFieldMapper
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef directFvPatchFieldMapper_H
+#define directFvPatchFieldMapper_H
+
+#include "fvPatchFieldMapper.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                       Class directFvPatchFieldMapper Declaration
+\*---------------------------------------------------------------------------*/
+
+class directFvPatchFieldMapper
+:
+    public fvPatchFieldMapper
+{
+
+    //- Addressing from new back to old
+    const labelUList& directAddressing_;
+
+    //- Does map contain any unmapped values
+    bool hasUnmapped_;
+
+
+public:
+
+    // Constructors
+
+        //- Construct given addressing
+        directFvPatchFieldMapper(const labelUList& directAddressing)
+        :
+            directAddressing_(directAddressing),
+            hasUnmapped_(false)
+        {
+            if (directAddressing_.size() && min(directAddressing_) < 0)
+            {
+                hasUnmapped_ = true;
+            }
+        }
+
+    //- Destructor
+    virtual ~directFvPatchFieldMapper()
+    {}
+
+
+    // Member Functions
+
+        label size() const
+        {
+            return directAddressing_.size();
+        }
+
+        bool direct() const
+        {
+            return true;
+        }
+
+        bool hasUnmapped() const
+        {
+            return hasUnmapped_;
+        }
+
+        const labelUList& directAddressing() const
+        {
+            return directAddressing_;
+        }
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/finiteVolume/fvMesh/fvMeshMapper/fvPatchMapper.C

@@ -55,6 +55,8 @@ void Foam::fvPatchMapper::calcAddressing() const
     const label oldPatchEnd =
         oldPatchStart + faceMap_.oldPatchSizes()[patch_.index()];
 
+    hasUnmapped_ = false;
+
     // Assemble the maps: slice to patch
     if (direct())
     {
@@ -84,6 +86,7 @@ void Foam::fvPatchMapper::calcAddressing() const
             {
                 //addr[faceI] = 0;
                 addr[faceI] = -1;
+                hasUnmapped_ = true;
             }
         }
 
@@ -175,6 +178,10 @@ void Foam::fvPatchMapper::calcAddressing() const
                 {
                     newWeights /= sum(newWeights);
                 }
+                else
+                {
+                    hasUnmapped_ = true;
+                }
 
                 // Reset addressing and weights
                 curAddr = newAddr;
@@ -206,6 +213,7 @@ void Foam::fvPatchMapper::clearOut()
     deleteDemandDrivenData(directAddrPtr_);
     deleteDemandDrivenData(interpolationAddrPtr_);
     deleteDemandDrivenData(weightsPtr_);
+    hasUnmapped_ = false;
 }
 
 
@@ -221,6 +229,7 @@ Foam::fvPatchMapper::fvPatchMapper
     patch_(patch),
     faceMap_(faceMap),
     sizeBeforeMapping_(faceMap.oldPatchSizes()[patch_.index()]),
+    hasUnmapped_(false),
     directAddrPtr_(NULL),
     interpolationAddrPtr_(NULL),
     weightsPtr_(NULL)

src/finiteVolume/fvMesh/fvMeshMapper/fvPatchMapper.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -71,6 +71,8 @@ class fvPatchMapper
 
     // Demand-driven private data
 
+        mutable bool hasUnmapped_;
+
         //- Direct addressing (only one for of addressing is used)
         mutable labelList* directAddrPtr_;
 
@@ -138,6 +140,11 @@ public:
             return faceMap_.direct();
         }
 
+        virtual bool hasUnmapped() const
+        {
+            return hasUnmapped_;
+        }
+
         //- Return direct addressing
         virtual const labelUList& directAddressing() const;
 

src/finiteVolume/fvMesh/fvMeshMapper/fvSurfaceMapper.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -133,6 +133,12 @@ public:
             return faceMap_.direct();
         }
 
+        //- Has unmapped elements
+        virtual bool hasUnmapped() const
+        {
+            return insertedObjects();
+        }
+
         //- Return direct addressing
         virtual const labelUList& directAddressing() const;
 

src/finiteVolume/fvMesh/fvMeshSubset/fvMeshSubset.H

@@ -56,8 +56,6 @@ SourceFiles
 
 #include "fvMesh.H"
 #include "pointMesh.H"
-#include "fvPatchFieldMapper.H"
-#include "pointPatchFieldMapper.H"
 #include "GeometricField.H"
 #include "HashSet.H"
 #include "surfaceMesh.H"
@@ -74,90 +72,6 @@ namespace Foam
 class fvMeshSubset
 {
 
-public:
-
-    //- Patch-field subset interpolation class
-    class patchFieldSubset
-    :
-        public fvPatchFieldMapper
-    {
-        const labelList& directAddressing_;
-
-    public:
-
-        // Constructors
-
-            //- Construct given addressing
-            patchFieldSubset(const labelList& directAddressing)
-            :
-                directAddressing_(directAddressing)
-            {}
-
-        //- Destructor
-        virtual ~patchFieldSubset()
-        {}
-
-
-        // Member Functions
-
-            label size() const
-            {
-                return directAddressing_.size();
-            }
-
-            bool direct() const
-            {
-                return true;
-            }
-
-            const labelUList& directAddressing() const
-            {
-                return directAddressing_;
-            }
-    };
-
-
-    //- Patch-field subset interpolation class
-    class pointPatchFieldSubset
-    :
-        public pointPatchFieldMapper
-    {
-        const labelList& directAddressing_;
-
-    public:
-
-        // Constructors
-
-            //- Construct given addressing
-            pointPatchFieldSubset(const labelList& directAddressing)
-            :
-                directAddressing_(directAddressing)
-            {}
-
-        //- Destructor
-        virtual ~pointPatchFieldSubset()
-        {}
-
-
-        // Member Functions
-
-            label size() const
-            {
-                return directAddressing_.size();
-            }
-
-            bool direct() const
-            {
-                return true;
-            }
-
-            const labelUList& directAddressing() const
-            {
-                return directAddressing_;
-            }
-    };
-
-
 private:
 
     // Private data

src/finiteVolume/fvMesh/fvMeshSubset/fvMeshSubsetInterpolate.C

@@ -27,6 +27,8 @@ License
 #include "emptyFvsPatchField.H"
 #include "emptyPointPatchField.H"
 #include "emptyFvPatchFields.H"
+#include "directFvPatchFieldMapper.H"
+#include "directPointPatchFieldMapper.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -70,8 +72,9 @@ tmp<GeometricField<Type, fvPatchField, volMesh> > fvMeshSubset::interpolate
             patchFields.set
             (
                 patchI,
-                new calculatedFvPatchField<Type>
+                fvPatchField<Type>::New
                 (
+                    calculatedFvPatchField<Type>::typeName,
                     sMesh.boundary()[patchI],
                     DimensionedField<Type, volMesh>::null()
                 )
@@ -142,7 +145,7 @@ tmp<GeometricField<Type, fvPatchField, volMesh> > fvMeshSubset::interpolate
                     vf.boundaryField()[patchMap[patchI]],
                     subPatch,
                     resF.dimensionedInternalField(),
-                    patchFieldSubset(directAddressing)
+                    directFvPatchFieldMapper(directAddressing)
                 )
             );
         }
@@ -203,8 +206,9 @@ tmp<GeometricField<Type, fvsPatchField, surfaceMesh> > fvMeshSubset::interpolate
             patchFields.set
             (
                 patchI,
-                new calculatedFvsPatchField<Type>
+                fvsPatchField<Type>::New
                 (
+                    calculatedFvsPatchField<Type>::typeName,
                     sMesh.boundary()[patchI],
                     DimensionedField<Type, surfaceMesh>::null()
                 )
@@ -285,7 +289,7 @@ tmp<GeometricField<Type, fvsPatchField, surfaceMesh> > fvMeshSubset::interpolate
                     vf.boundaryField()[patchMap[patchI]],
                     subPatch,
                     resF.dimensionedInternalField(),
-                    patchFieldSubset(directAddressing)
+                    directFvPatchFieldMapper(directAddressing)
                 )
             );
 
@@ -348,10 +352,7 @@ fvMeshSubset::interpolate
     const labelList& pointMap
 )
 {
-    // Create and map the internal-field values
+    // 1. Create the complete field with dummy patch fields
-    Field<Type> internalField(vf.internalField(), pointMap);
-
-    // Create and map the patch field values
     PtrList<pointPatchField<Type> > patchFields(patchMap.size());
 
     forAll(patchFields, patchI)
@@ -372,6 +373,54 @@ fvMeshSubset::interpolate
             );
         }
         else
+        {
+            patchFields.set
+            (
+                patchI,
+                pointPatchField<Type>::New
+                (
+                    calculatedPointPatchField<Type>::typeName,
+                    sMesh.boundary()[patchI],
+                    DimensionedField<Type, pointMesh>::null()
+                )
+            );
+        }
+    }
+
+    // Create the complete field from the pieces
+    tmp<GeometricField<Type, pointPatchField, pointMesh> > tresF
+    (
+        new GeometricField<Type, pointPatchField, pointMesh>
+        (
+            IOobject
+            (
+                "subset"+vf.name(),
+                sMesh.time().timeName(),
+                sMesh.thisDb(),
+                IOobject::NO_READ,
+                IOobject::NO_WRITE
+            ),
+            sMesh,
+            vf.dimensions(),
+            Field<Type>(vf.internalField(), pointMap),
+            patchFields
+        )
+    );
+    GeometricField<Type, pointPatchField, pointMesh>& resF = tresF();
+
+
+    // 2. Change the pointPatchFields to the correct type using a mapper
+    //  constructor (with reference to the now correct internal field)
+
+    typename GeometricField<Type, pointPatchField, pointMesh>::
+        GeometricBoundaryField& bf = resF.boundaryField();
+
+    forAll(bf, patchI)
+    {
+        // Set the first one by hand as it corresponds to the
+        // exposed internal faces.  Additional interpolation can be put here
+        // as necessary.
+        if (patchMap[patchI] != -1)
         {
             // Construct addressing
             const pointPatch& basePatch =
@@ -406,40 +455,20 @@ fvMeshSubset::interpolate
                 }
             }
 
-            patchFields.set
+            bf.set
             (
                 patchI,
                 pointPatchField<Type>::New
                 (
                     vf.boundaryField()[patchMap[patchI]],
                     subPatch,
-                    DimensionedField<Type, pointMesh>::null(),
+                    resF.dimensionedInternalField(),
-                    pointPatchFieldSubset(directAddressing)
+                    directPointPatchFieldMapper(directAddressing)
                 )
             );
         }
     }
 
-    // Create the complete field from the pieces
-    tmp<GeometricField<Type, pointPatchField, pointMesh> > tresF
-    (
-        new GeometricField<Type, pointPatchField, pointMesh>
-        (
-            IOobject
-            (
-                "subset"+vf.name(),
-                vf.time().timeName(),
-                sMesh.thisDb(),
-                IOobject::NO_READ,
-                IOobject::NO_WRITE
-            ),
-            sMesh,
-            vf.dimensions(),
-            internalField,
-            patchFields
-        )
-    );
-
     return tresF;
 }
 

src/finiteVolume/fvMesh/singleCellFvMesh/singleCellFvMesh.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -87,39 +87,6 @@ class singleCellFvMesh
 
 public:
 
-        //- Patch field mapper class for non-agglomerated meshes
-        class directPatchFieldMapper
-        :
-            public fvPatchFieldMapper
-        {
-            // Private data
-
-                const labelUList& directAddressing_;
-
-        public:
-
-                //- Construct given addressing
-                directPatchFieldMapper(const labelUList& directAddressing)
-                :
-                    directAddressing_(directAddressing)
-                {}
-
-                virtual label size() const
-                {
-                    return directAddressing_.size();
-                }
-
-                virtual bool direct() const
-                {
-                    return true;
-                }
-
-                virtual const labelUList& directAddressing() const
-                {
-                    return directAddressing_;
-                }
-        };
-
         //- Patch field mapper class for agglomerated meshes
         class agglomPatchFieldMapper
         :
@@ -129,6 +96,7 @@ public:
 
                 const labelListList& addressing_;
                 const scalarListList& weights_;
+                bool hasUnmapped_;
 
         public:
 
@@ -140,8 +108,18 @@ public:
                 )
                 :
                     addressing_(addressing),
-                    weights_(weights)
+                    weights_(weights),
-                {}
+                    hasUnmapped_(false)
+                {
+                    forAll(addressing_, i)
+                    {
+                        if (addressing_[i].empty())
+                        {
+                            hasUnmapped_ = true;
+                            break;
+                        }
+                    }
+                }
 
                 virtual label size() const
                 {
@@ -153,6 +131,11 @@ public:
                     return false;
                 }
 
+                bool hasUnmapped() const
+                {
+                    return hasUnmapped_;
+                }
+
                 virtual const labelListList& addressing() const
                 {
                     return addressing_;

src/finiteVolume/fvMesh/singleCellFvMesh/singleCellFvMeshInterpolate.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -24,6 +24,8 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "singleCellFvMesh.H"
+#include "calculatedFvPatchFields.H"
+#include "directFvPatchFieldMapper.H"
 #include "Time.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@@ -39,12 +41,51 @@ tmp<GeometricField<Type, fvPatchField, volMesh> > singleCellFvMesh::interpolate
     const GeometricField<Type, fvPatchField, volMesh>& vf
 ) const
 {
-    // Create internal-field values
+    // 1. Create the complete field with dummy patch fields
-    Field<Type> internalField(1, gAverage(vf));
-
-    // Create and map the patch field values
     PtrList<fvPatchField<Type> > patchFields(vf.boundaryField().size());
 
+    forAll(patchFields, patchI)
+    {
+        patchFields.set
+        (
+            patchI,
+            fvPatchField<Type>::New
+            (
+                calculatedFvPatchField<Type>::typeName,
+                boundary()[patchI],
+                DimensionedField<Type, volMesh>::null()
+            )
+        );
+    }
+
+    // Create the complete field from the pieces
+    tmp<GeometricField<Type, fvPatchField, volMesh> > tresF
+    (
+        new GeometricField<Type, fvPatchField, volMesh>
+        (
+            IOobject
+            (
+                vf.name(),
+                time().timeName(),
+                *this,
+                IOobject::NO_READ,
+                IOobject::NO_WRITE
+            ),
+            *this,
+            vf.dimensions(),
+            Field<Type>(1, gAverage(vf)),
+            patchFields
+        )
+    );
+    GeometricField<Type, fvPatchField, volMesh>& resF = tresF();
+
+
+    // 2. Change the fvPatchFields to the correct type using a mapper
+    //  constructor (with reference to the now correct internal field)
+
+    typename GeometricField<Type, fvPatchField, volMesh>::
+        GeometricBoundaryField& bf = resF.boundaryField();
+
     if (agglomerate())
     {
         forAll(vf.boundaryField(), patchI)
@@ -67,14 +108,14 @@ tmp<GeometricField<Type, fvPatchField, volMesh> > singleCellFvMesh::interpolate
                 );
             }
 
-            patchFields.set
+            bf.set
             (
                 patchI,
                 fvPatchField<Type>::New
                 (
                     vf.boundaryField()[patchI],
                     boundary()[patchI],
-                    DimensionedField<Type, volMesh>::null(),
+                    resF.dimensionedInternalField(),
                     agglomPatchFieldMapper(coarseToFine, coarseWeights)
                 )
             );
@@ -86,40 +127,20 @@ tmp<GeometricField<Type, fvPatchField, volMesh> > singleCellFvMesh::interpolate
         {
             labelList map(identity(vf.boundaryField()[patchI].size()));
 
-            patchFields.set
+            bf.set
             (
                 patchI,
                 fvPatchField<Type>::New
                 (
                     vf.boundaryField()[patchI],
                     boundary()[patchI],
-                    DimensionedField<Type, volMesh>::null(),
+                    resF.dimensionedInternalField(),
-                    directPatchFieldMapper(map)
+                    directFvPatchFieldMapper(map)
                 )
             );
         }
     }
 
-    // Create the complete field from the pieces
-    tmp<GeometricField<Type, fvPatchField, volMesh> > tresF
-    (
-        new GeometricField<Type, fvPatchField, volMesh>
-        (
-            IOobject
-            (
-                vf.name(),
-                time().timeName(),
-                *this,
-                IOobject::NO_READ,
-                IOobject::NO_WRITE
-            ),
-            *this,
-            vf.dimensions(),
-            internalField,
-            patchFields
-        )
-    );
-
     return tresF;
 }
 

src/parallel/decompose/decompose/fvFieldDecomposer.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -88,6 +88,12 @@ public:
                     return true;
                 }
 
+                //- Are there unmapped values
+                bool hasUnmapped() const
+                {
+                    return false;
+                }
+
                 const labelUList& directAddressing() const
                 {
                     return directAddressing_;
@@ -128,6 +134,12 @@ public:
                     return true;
                 }
 
+                //- Are there unmapped values
+                bool hasUnmapped() const
+                {
+                    return false;
+                }
+
                 const labelUList& directAddressing() const
                 {
                     return directAddressing_;
@@ -165,6 +177,12 @@ public:
                     return false;
                 }
 
+                //- Are there unmapped values
+                bool hasUnmapped() const
+                {
+                    return false;
+                }
+
                 const labelListList& addressing() const
                 {
                     return addressing_;

src/parallel/decompose/decompose/fvFieldDecomposerDecomposeFields.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -40,83 +40,25 @@ Foam::fvFieldDecomposer::decomposeField
     const bool allowUnknownPatchFields
 ) const
 {
-    // Create and map the internal field values
+    // 1. Create the complete field with dummy patch fields
-    Field<Type> internalField(field.internalField(), cellAddressing_);
-
-    // Create and map the patch field values
     PtrList<fvPatchField<Type> > patchFields(boundaryAddressing_.size());
 
     forAll(boundaryAddressing_, patchi)
     {
-        if (patchFieldDecomposerPtrs_[patchi])
+        patchFields.set
-        {
+        (
-            patchFields.set
+            patchi,
+            fvPatchField<Type>::New
             (
-                patchi,
+                calculatedFvPatchField<Type>::typeName,
-                fvPatchField<Type>::New
+                procMesh_.boundary()[patchi],
-                (
+                DimensionedField<Type, volMesh>::null()
-                    field.boundaryField()[boundaryAddressing_[patchi]],
+            )
-                    procMesh_.boundary()[patchi],
+        );
-                    DimensionedField<Type, volMesh>::null(),
-                    *patchFieldDecomposerPtrs_[patchi]
-                )
-            );
-        }
-        else if (isA<processorCyclicFvPatch>(procMesh_.boundary()[patchi]))
-        {
-            patchFields.set
-            (
-                patchi,
-                new processorCyclicFvPatchField<Type>
-                (
-                    procMesh_.boundary()[patchi],
-                    DimensionedField<Type, volMesh>::null(),
-                    Field<Type>
-                    (
-                        field.internalField(),
-                        *processorVolPatchFieldDecomposerPtrs_[patchi]
-                    )
-                )
-            );
-        }
-        else if (isA<processorFvPatch>(procMesh_.boundary()[patchi]))
-        {
-            patchFields.set
-            (
-                patchi,
-                new processorFvPatchField<Type>
-                (
-                    procMesh_.boundary()[patchi],
-                    DimensionedField<Type, volMesh>::null(),
-                    Field<Type>
-                    (
-                        field.internalField(),
-                        *processorVolPatchFieldDecomposerPtrs_[patchi]
-                    )
-                )
-            );
-        }
-        else if (allowUnknownPatchFields)
-        {
-            patchFields.set
-            (
-                patchi,
-                new emptyFvPatchField<Type>
-                (
-                    procMesh_.boundary()[patchi],
-                    DimensionedField<Type, volMesh>::null()
-                )
-            );
-        }
-        else
-        {
-            FatalErrorIn("fvFieldDecomposer::decomposeField()")
-                << "Unknown type." << abort(FatalError);
-        }
     }
 
     // Create the field for the processor
-    return tmp<GeometricField<Type, fvPatchField, volMesh> >
+    tmp<GeometricField<Type, fvPatchField, volMesh> > tresF
     (
         new GeometricField<Type, fvPatchField, volMesh>
         (
@@ -130,10 +72,90 @@ Foam::fvFieldDecomposer::decomposeField
             ),
             procMesh_,
             field.dimensions(),
-            internalField,
+            Field<Type>(field.internalField(), cellAddressing_),
             patchFields
         )
     );
+    GeometricField<Type, fvPatchField, volMesh>& resF = tresF();
+
+
+    // 2. Change the fvPatchFields to the correct type using a mapper
+    //  constructor (with reference to the now correct internal field)
+
+    typename GeometricField<Type, fvPatchField, volMesh>::
+        GeometricBoundaryField& bf = resF.boundaryField();
+
+    forAll(bf, patchi)
+    {
+        if (patchFieldDecomposerPtrs_[patchi])
+        {
+            bf.set
+            (
+                patchi,
+                fvPatchField<Type>::New
+                (
+                    field.boundaryField()[boundaryAddressing_[patchi]],
+                    procMesh_.boundary()[patchi],
+                    resF.dimensionedInternalField(),
+                    *patchFieldDecomposerPtrs_[patchi]
+                )
+            );
+        }
+        else if (isA<processorCyclicFvPatch>(procMesh_.boundary()[patchi]))
+        {
+            bf.set
+            (
+                patchi,
+                new processorCyclicFvPatchField<Type>
+                (
+                    procMesh_.boundary()[patchi],
+                    resF.dimensionedInternalField(),
+                    Field<Type>
+                    (
+                        field.internalField(),
+                        *processorVolPatchFieldDecomposerPtrs_[patchi]
+                    )
+                )
+            );
+        }
+        else if (isA<processorFvPatch>(procMesh_.boundary()[patchi]))
+        {
+            bf.set
+            (
+                patchi,
+                new processorFvPatchField<Type>
+                (
+                    procMesh_.boundary()[patchi],
+                    resF.dimensionedInternalField(),
+                    Field<Type>
+                    (
+                        field.internalField(),
+                        *processorVolPatchFieldDecomposerPtrs_[patchi]
+                    )
+                )
+            );
+        }
+        else if (allowUnknownPatchFields)
+        {
+            bf.set
+            (
+                patchi,
+                new emptyFvPatchField<Type>
+                (
+                    procMesh_.boundary()[patchi],
+                    resF.dimensionedInternalField()
+                )
+            );
+        }
+        else
+        {
+            FatalErrorIn("fvFieldDecomposer::decomposeField()")
+                << "Unknown type." << abort(FatalError);
+        }
+    }
+
+    // Create the field for the processor
+    return tresF;
 }
 
 
@@ -188,34 +210,76 @@ Foam::fvFieldDecomposer::decomposeField
         }
     }
 
-    // Create and map the patch field values
+
+    // 1. Create the complete field with dummy patch fields
     PtrList<fvsPatchField<Type> > patchFields(boundaryAddressing_.size());
 
+    forAll(boundaryAddressing_, patchi)
+    {
+        patchFields.set
+        (
+            patchi,
+            fvsPatchField<Type>::New
+            (
+                calculatedFvsPatchField<Type>::typeName,
+                procMesh_.boundary()[patchi],
+                DimensionedField<Type, surfaceMesh>::null()
+            )
+        );
+    }
+
+    tmp<GeometricField<Type, fvsPatchField, surfaceMesh> > tresF
+    (
+        new GeometricField<Type, fvsPatchField, surfaceMesh>
+        (
+            IOobject
+            (
+                field.name(),
+                procMesh_.time().timeName(),
+                procMesh_,
+                IOobject::NO_READ,
+                IOobject::NO_WRITE
+            ),
+            procMesh_,
+            field.dimensions(),
+            Field<Type>(field.internalField(), mapAddr),
+            patchFields
+        )
+    );
+    GeometricField<Type, fvsPatchField, surfaceMesh>& resF = tresF();
+
+
+    // 2. Change the fvsPatchFields to the correct type using a mapper
+    //  constructor (with reference to the now correct internal field)
+
+    typename GeometricField<Type, fvsPatchField, surfaceMesh>::
+        GeometricBoundaryField& bf = resF.boundaryField();
+
     forAll(boundaryAddressing_, patchi)
     {
         if (patchFieldDecomposerPtrs_[patchi])
         {
-            patchFields.set
+            bf.set
             (
                 patchi,
                 fvsPatchField<Type>::New
                 (
                     field.boundaryField()[boundaryAddressing_[patchi]],
                     procMesh_.boundary()[patchi],
-                    DimensionedField<Type, surfaceMesh>::null(),
+                    resF.dimensionedInternalField(),
                     *patchFieldDecomposerPtrs_[patchi]
                 )
             );
         }
         else if (isA<processorCyclicFvPatch>(procMesh_.boundary()[patchi]))
         {
-            patchFields.set
+            bf.set
             (
                 patchi,
                 new processorCyclicFvsPatchField<Type>
                 (
                     procMesh_.boundary()[patchi],
-                    DimensionedField<Type, surfaceMesh>::null(),
+                    resF.dimensionedInternalField(),
                     Field<Type>
                     (
                         allFaceField,
@@ -226,13 +290,13 @@ Foam::fvFieldDecomposer::decomposeField
         }
         else if (isA<processorFvPatch>(procMesh_.boundary()[patchi]))
         {
-            patchFields.set
+            bf.set
             (
                 patchi,
                 new processorFvsPatchField<Type>
                 (
                     procMesh_.boundary()[patchi],
-                    DimensionedField<Type, surfaceMesh>::null(),
+                    resF.dimensionedInternalField(),
                     Field<Type>
                     (
                         allFaceField,
@@ -249,24 +313,7 @@ Foam::fvFieldDecomposer::decomposeField
     }
 
     // Create the field for the processor
-    return tmp<GeometricField<Type, fvsPatchField, surfaceMesh> >
+    return tresF;
-    (
-        new GeometricField<Type, fvsPatchField, surfaceMesh>
-        (
-            IOobject
-            (
-                field.name(),
-                procMesh_.time().timeName(),
-                procMesh_,
-                IOobject::NO_READ,
-                IOobject::NO_WRITE
-            ),
-            procMesh_,
-            field.dimensions(),
-            internalField,
-            patchFields
-        )
-    );
 }
 
 

src/parallel/reconstruct/reconstruct/fvFieldReconstructor.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -116,6 +116,11 @@ public:
                     return true;
                 }
 
+                bool hasUnmapped() const
+                {
+                    return false;
+                }
+
                 const labelUList& directAddressing() const
                 {
                     return labelUList::null();

src/parallel/reconstruct/reconstruct/pointFieldReconstructor.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -112,6 +112,11 @@ public:
                     return true;
                 }
 
+                bool hasUnmapped() const
+                {
+                    return false;
+                }
+
                 const labelUList& directAddressing() const
                 {
                     return labelUList::null();

src/sampling/meshToMeshInterpolation/meshToMesh/meshToMesh.H

@@ -175,48 +175,6 @@ public:
     ~meshToMesh();
 
 
-    //- Patch-field interpolation class
-    class patchFieldInterpolator
-    :
-        public fvPatchFieldMapper
-    {
-        const labelList& directAddressing_;
-
-    public:
-
-        // Constructors
-
-            //- Construct given addressing
-            patchFieldInterpolator(const labelList& addr)
-            :
-                directAddressing_(addr)
-            {}
-
-
-        //- Destructor
-        virtual ~patchFieldInterpolator()
-        {}
-
-
-        // Member Functions
-
-            label size() const
-            {
-                return directAddressing_.size();
-            }
-
-            bool direct() const
-            {
-                return true;
-            }
-
-            const labelList& directAddressing() const
-            {
-                return directAddressing_;
-            }
-    };
-
-
     // Member Functions
 
         // Access

src/sampling/meshToMeshInterpolation/meshToMesh/meshToMeshInterpolate.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -28,6 +28,7 @@ License
 #include "interpolationCellPoint.H"
 #include "SubField.H"
 #include "mixedFvPatchField.H"
+#include "directFvPatchFieldMapper.H"
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
@@ -408,7 +409,7 @@ Foam::meshToMesh::interpolate
             << exit(FatalError);
     }
 
-    // Create and map the patch field values
+    // 1. Create the complete field with dummy patch fields
     PtrList<fvPatchField<Type> > patchFields
     (
         boundaryAddressing_.size()
@@ -421,13 +422,9 @@ Foam::meshToMesh::interpolate
             patchI,
             fvPatchField<Type>::New
             (
-                fromVf.boundaryField()[patchI],
+                calculatedFvPatchField<Type>::typeName,
                 toMesh_.boundary()[patchI],
-                DimensionedField<Type, volMesh>::null(),
+                DimensionedField<Type, volMesh>::null()
-                patchFieldInterpolator
-                (
-                    boundaryAddressing_[patchI]
-                )
             )
         );
     }
@@ -452,6 +449,31 @@ Foam::meshToMesh::interpolate
             patchFields
         )
     );
+    GeometricField<Type, fvPatchField, volMesh>& toF = ttoF();
+
+    // 2. Change the fvPatchFields to the correct type using a mapper
+    //  constructor (with reference to the now correct internal field)
+
+    typename GeometricField<Type, fvPatchField, volMesh>::
+        GeometricBoundaryField& bf = toF.boundaryField();
+
+    forAll(boundaryAddressing_, patchI)
+    {
+        bf.set
+        (
+            patchI,
+            fvPatchField<Type>::New
+            (
+                fromVf.boundaryField()[patchI],
+                toMesh_.boundary()[patchI],
+                toF.dimensionedInternalField(),
+                directFvPatchFieldMapper
+                (
+                    boundaryAddressing_[patchI]
+                )
+            )
+        );
+    }
 
     return ttoF;
 }