Merge branch 'master' of github.com:OpenFOAM/OpenFOAM-2.3.x

applications/solvers/multiphase/compressibleInterFoam/TEqn.H

@@ -18,4 +18,6 @@
     TEqn.solve();
 
     mixture.correct();
+
+    Info<< "min(T) " << min(T).value() << endl;
 }

applications/utilities/mesh/generation/extrude/extrudeToRegionMesh/extrudeToRegionMesh.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2014 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -2430,10 +2430,9 @@ int main(int argc, char *argv[])
     // Add the new patches
     forAll(regionPatches, patchI)
     {
-        regionPatches[patchI] = regionPatches[patchI]->clone
-        (
-            regionMesh.boundaryMesh()
-        ).ptr();
+        polyPatch* ppPtr = regionPatches[patchI];
+        regionPatches[patchI] = ppPtr->clone(regionMesh.boundaryMesh()).ptr();
+        delete ppPtr;
     }
     regionMesh.clearOut();
     regionMesh.removeFvBoundary();

applications/utilities/mesh/manipulation/createPatch/createPatch.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2014 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -186,6 +186,10 @@ void filterPatches(polyMesh& mesh, const HashSet<word>& addedPatchNames)
     else
     {
         Info<< "No patches removed." << endl;
+        forAll(allPatches, i)
+        {
+            delete allPatches[i];
+        }
     }
 }
 

etc/codeTemplates/dynamicCode/codedFvOptionTemplate.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2013 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2013-2014 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -43,6 +43,7 @@ namespace Foam
 
 namespace fv
 {
+
 // * * * * * * * * * * * * * * * Local Functions * * * * * * * * * * * * * * //
 
 //{{{ begin localCode
@@ -160,6 +161,24 @@ void ${typeName}FvOption${SourceType}::addSup
 }
 
 
+void ${typeName}FvOption${SourceType}::addSup
+(
+    const volScalarField& rho,
+    fvMatrix<${TemplateType}>& eqn,
+    const label fieldI
+)
+{
+    if (${verbose:-false})
+    {
+        Info<<"${typeName}FvOption${SourceType}::addSup()\n";
+    }
+
+//{{{ begin code
+    ${codeAddSup}
+//}}} end code
+}
+
+
 void ${typeName}FvOption${SourceType}::setValue
 (
     fvMatrix<${TemplateType}>& eqn,

etc/codeTemplates/dynamicCode/codedFvOptionTemplate.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2013 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2013-2014 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -162,6 +162,15 @@ public:
                 const label fieldI
             );
 
+            //- Explicit and implicit matrix contributions for compressible
+            //  equations
+            virtual void addSup
+            (
+                const volScalarField& rho,
+                fvMatrix<${TemplateType}>& eqn,
+                const label fieldI
+            );
+
             //- Set value
             virtual void setValue
             (

src/mesh/autoMesh/autoHexMesh/autoHexMeshDriver/autoRefineDriver.C

@@ -1248,6 +1248,12 @@ void Foam::autoRefineDriver::doRefine
             decomposer_,
             distributor_
         );
+
+
+        if (debug)
+        {
+            meshRefiner_.checkZoneFaces();
+        }
     }
 }
 

src/mesh/autoMesh/autoHexMesh/meshRefinement/meshRefinement.H

@@ -870,6 +870,9 @@ public:
                 const labelList& neiPatch
             );
 
+            //- Debug helper: check faceZones are not on processor patches
+            void checkZoneFaces() const;
+
             //- Create baffles for faces straddling zoned surfaces. Return
             //  baffles.
             autoPtr<mapPolyMesh> createZoneBaffles

src/mesh/autoMesh/autoHexMesh/meshRefinement/meshRefinementBaffles.C

@@ -531,6 +531,36 @@ Foam::autoPtr<Foam::mapPolyMesh> Foam::meshRefinement::createBaffles
 }
 
 
+void Foam::meshRefinement::checkZoneFaces() const
+{
+    const faceZoneMesh& fZones = mesh_.faceZones();
+
+    const polyBoundaryMesh& pbm = mesh_.boundaryMesh();
+
+    forAll(pbm, patchI)
+    {
+        const polyPatch& pp = pbm[patchI];
+
+        if (isA<processorPolyPatch>(pp))
+        {
+            forAll(pp, i)
+            {
+                label faceI = pp.start()+i;
+                label zoneI = fZones.whichZone(faceI);
+
+                if (zoneI != -1)
+                {
+                    FatalErrorIn("meshRefinement::checkZoneFaces")
+                        << "face:" << faceI << " on patch " << pp.name()
+                        << " is in zone " << fZones[zoneI].name()
+                        << exit(FatalError);
+                }
+            }
+        }
+    }
+}
+
+
 Foam::autoPtr<Foam::mapPolyMesh> Foam::meshRefinement::createZoneBaffles
 (
     const labelList& globalToMasterPatch,

src/meshTools/Make/files

@@ -64,6 +64,7 @@ indexedOctree/treeDataTriSurface.C
 searchableSurface = searchableSurface
 $(searchableSurface)/searchableBox.C
 $(searchableSurface)/searchableCylinder.C
+$(searchableSurface)/searchableDisk.C
 $(searchableSurface)/searchablePlane.C
 $(searchableSurface)/searchablePlate.C
 $(searchableSurface)/searchableSphere.C

src/meshTools/searchableSurface/searchableCylinder.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2014 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -662,21 +662,61 @@ void Foam::searchableCylinder::getNormal
             vector v(info[i].hitPoint() - point1_);
 
             // Decompose sample-point1 into normal and parallel component
-            scalar parallel = v & unitDir_;
+            scalar parallel = (v & unitDir_);
 
-            if (parallel < 0)
+            // Remove the parallel component and normalise
+            v -= parallel*unitDir_;
+            scalar magV = mag(v);
+
+            if (parallel <= 0)
             {
-                normal[i] = -unitDir_;
+                if ((magV-radius_) < mag(parallel))
+                {
+                    // either above endcap (magV<radius) or outside but closer
+                    normal[i] = -unitDir_;
+                }
+                else
+                {
+                    normal[i] = v/magV;
+                }
             }
-            else if (parallel > magDir_)
+            else if (parallel <= 0.5*magDir_)
             {
-                normal[i] = -unitDir_;
+                // See if endcap closer or sidewall
+                if (magV >= radius_ || (radius_-magV) < parallel)
+                {
+                    normal[i] = v/magV;
+                }
+                else
+                {
+                    // closer to endcap
+                    normal[i] = -unitDir_;
+                }
             }
-            else
+            else if (parallel <= magDir_)
             {
-                // Remove the parallel component
-                v -= parallel*unitDir_;
-                normal[i] = v/mag(v);
+                // See if endcap closer or sidewall
+                if (magV >= radius_ || (radius_-magV) < (magDir_-parallel))
+                {
+                    normal[i] = v/magV;
+                }
+                else
+                {
+                    // closer to endcap
+                    normal[i] = unitDir_;
+                }
+            }
+            else    // beyond cylinder
+            {
+                if ((magV-radius_) < (parallel-magDir_))
+                {
+                    // above endcap
+                    normal[i] = unitDir_;
+                }
+                else
+                {
+                    normal[i] = v/magV;
+                }
             }
         }
     }

src/meshTools/searchableSurface/searchableDisk.C

@@ -0,0 +1,329 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2014 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "searchableDisk.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+defineTypeNameAndDebug(searchableDisk, 0);
+addToRunTimeSelectionTable(searchableSurface, searchableDisk, dict);
+
+}
+
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+Foam::pointIndexHit Foam::searchableDisk::findNearest
+(
+    const point& sample,
+    const scalar nearestDistSqr
+) const
+{
+    pointIndexHit info(false, sample, -1);
+
+    vector v(sample - origin_);
+
+    // Decompose sample-origin into normal and parallel component
+    scalar parallel = (v & normal_);
+
+    // Remove the parallel component and normalise
+    v -= parallel*normal_;
+    scalar magV = mag(v);
+
+    if (magV < ROOTVSMALL)
+    {
+        v = vector::zero;
+    }
+    else
+    {
+        v /= magV;
+    }
+
+    // Clip to radius.
+    info.setPoint(origin_ + min(magV, radius_)*v);
+
+    if (magSqr(sample - info.rawPoint()) < nearestDistSqr)
+    {
+        info.setHit();
+        info.setIndex(0);
+    }
+
+    return info;
+}
+
+
+void Foam::searchableDisk::findLine
+(
+    const point& start,
+    const point& end,
+    pointIndexHit& info
+) const
+{
+    info = pointIndexHit(false, vector::zero, -1);
+
+    vector v(start - origin_);
+
+    // Decompose sample-origin into normal and parallel component
+    scalar parallel = (v & normal_);
+
+    if (sign(parallel) == sign((end - origin_) & normal_))
+    {
+        return;
+    }
+
+    // Remove the parallel component and normalise
+    v -= parallel*normal_;
+    scalar magV = mag(v);
+
+    if (magV < ROOTVSMALL)
+    {
+        v = vector::zero;
+    }
+    else
+    {
+        v /= magV;
+    }
+
+    // Set (hit or miss) to intersection of ray and plane of disk
+    info.setPoint(origin_ + magV*v);
+
+    if (magV <= radius_)
+    {
+        info.setHit();
+        info.setIndex(0);
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::searchableDisk::searchableDisk
+(
+    const IOobject& io,
+    const point& origin,
+    const point& normal,
+    const scalar radius
+)
+:
+    searchableSurface(io),
+    origin_(origin),
+    normal_(normal/mag(normal)),
+    radius_(radius)
+{
+    // Rough approximation of bounding box
+    //vector span(radius_, radius_, radius_);
+
+    // See searchableCylinder
+    vector span
+    (
+        sqrt(sqr(normal_.y()) + sqr(normal_.z())),
+        sqrt(sqr(normal_.x()) + sqr(normal_.z())),
+        sqrt(sqr(normal_.x()) + sqr(normal_.y()))
+    );
+    span *= radius_;
+
+    bounds().min() = origin_ - span;
+    bounds().max() = origin_ + span;
+}
+
+
+Foam::searchableDisk::searchableDisk
+(
+    const IOobject& io,
+    const dictionary& dict
+)
+:
+    searchableSurface(io),
+    origin_(dict.lookup("origin")),
+    normal_(dict.lookup("normal")),
+    radius_(readScalar(dict.lookup("radius")))
+{
+    normal_ /= mag(normal_);
+
+    // Rough approximation of bounding box
+    //vector span(radius_, radius_, radius_);
+
+    // See searchableCylinder
+    vector span
+    (
+        sqrt(sqr(normal_.y()) + sqr(normal_.z())),
+        sqrt(sqr(normal_.x()) + sqr(normal_.z())),
+        sqrt(sqr(normal_.x()) + sqr(normal_.y()))
+    );
+    span *= radius_;
+
+    bounds().min() = origin_ - span;
+    bounds().max() = origin_ + span;
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::searchableDisk::~searchableDisk()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+const Foam::wordList& Foam::searchableDisk::regions() const
+{
+    if (regions_.empty())
+    {
+        regions_.setSize(1);
+        regions_[0] = "region0";
+    }
+    return regions_;
+}
+
+
+void Foam::searchableDisk::boundingSpheres
+(
+    pointField& centres,
+    scalarField& radiusSqr
+) const
+{
+    centres.setSize(1);
+    centres[0] = origin_;
+
+    radiusSqr.setSize(1);
+    radiusSqr[0] = sqr(radius_);
+
+    // Add a bit to make sure all points are tested inside
+    radiusSqr += Foam::sqr(SMALL);
+}
+
+
+void Foam::searchableDisk::findNearest
+(
+    const pointField& samples,
+    const scalarField& nearestDistSqr,
+    List<pointIndexHit>& info
+) const
+{
+    info.setSize(samples.size());
+
+    forAll(samples, i)
+    {
+        info[i] = findNearest(samples[i], nearestDistSqr[i]);
+    }
+}
+
+
+void Foam::searchableDisk::findLine
+(
+    const pointField& start,
+    const pointField& end,
+    List<pointIndexHit>& info
+) const
+{
+    info.setSize(start.size());
+
+    forAll(start, i)
+    {
+        findLine(start[i], end[i], info[i]);
+    }
+}
+
+
+void Foam::searchableDisk::findLineAny
+(
+    const pointField& start,
+    const pointField& end,
+    List<pointIndexHit>& info
+) const
+{
+    findLine(start, end, info);
+}
+
+
+void Foam::searchableDisk::findLineAll
+(
+    const pointField& start,
+    const pointField& end,
+    List<List<pointIndexHit> >& info
+) const
+{
+    info.setSize(start.size());
+
+    forAll(start, i)
+    {
+        pointIndexHit inter;
+        findLine(start[i], end[i], inter);
+
+        if (inter.hit())
+        {
+            info[i].setSize(1);
+            info[i][0] = inter;
+        }
+        else
+        {
+            info[i].clear();
+        }
+    }
+}
+
+
+void Foam::searchableDisk::getRegion
+(
+    const List<pointIndexHit>& info,
+    labelList& region
+) const
+{
+    region.setSize(info.size());
+    region = 0;
+}
+
+
+void Foam::searchableDisk::getNormal
+(
+    const List<pointIndexHit>& info,
+    vectorField& normal
+) const
+{
+    normal.setSize(info.size());
+    normal = normal_;
+}
+
+
+void Foam::searchableDisk::getVolumeType
+(
+    const pointField& points,
+    List<volumeType>& volType
+) const
+{
+    FatalErrorIn
+    (
+        "searchableDisk::getVolumeType(const pointField&"
+        ", List<volumeType>&) const"
+    )   << "Volume type not supported for disk."
+        << exit(FatalError);
+}
+
+
+// ************************************************************************* //

src/meshTools/searchableSurface/searchableDisk.H

@@ -0,0 +1,246 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2014 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::searchableDisk
+
+Description
+    Searching on circular disk given as origin, normal (gets normalised)
+    and radius
+
+SourceFiles
+    searchableDisk.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef searchableDisk_H
+#define searchableDisk_H
+
+#include "treeBoundBox.H"
+#include "searchableSurface.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                           Class searchableDisk Declaration
+\*---------------------------------------------------------------------------*/
+
+class searchableDisk
+:
+    public searchableSurface
+{
+private:
+
+    // Private Member Data
+
+        //- origin
+        const point origin_;
+
+        //- normal
+        vector normal_;
+
+        //- radius
+        const scalar radius_;
+
+        //- Names of regions
+        mutable wordList regions_;
+
+
+    // Private Member Functions
+
+        //- Find nearest point on disk
+        pointIndexHit findNearest
+        (
+            const point& sample,
+            const scalar nearestDistSqr
+        ) const;
+
+        //- Find intersection with disk
+        void findLine
+        (
+            const point& start,
+            const point& end,
+            pointIndexHit&
+        ) const;
+
+        //- Disallow default bitwise copy construct
+        searchableDisk(const searchableDisk&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const searchableDisk&);
+
+public:
+
+    //- Runtime type information
+    TypeName("searchableDisk");
+
+
+    // Constructors
+
+        //- Construct from components
+        searchableDisk
+        (
+            const IOobject& io,
+            const point& origin,
+            const point& normal,
+            const scalar radius
+        );
+
+        //- Construct from dictionary (used by searchableSurface)
+        searchableDisk
+        (
+            const IOobject& io,
+            const dictionary& dict
+        );
+
+    //- Destructor
+    virtual ~searchableDisk();
+
+
+    // Member Functions
+
+        virtual const wordList& regions() const;
+
+        //- Whether supports volume type below
+        virtual bool hasVolumeType() const
+        {
+            return false;
+        }
+
+        //- Range of local indices that can be returned.
+        virtual label size() const
+        {
+            return 1;
+        }
+
+        //- Get representative set of element coordinates
+        //  Usually the element centres (should be of length size()).
+        virtual tmp<pointField> coordinates() const
+        {
+            tmp<pointField> tCtrs(new pointField(1, origin_));
+            return tCtrs;
+        }
+
+        //- Get bounding spheres (centre and radius squared), one per element.
+        //  Any point on element is guaranteed to be inside.
+        virtual void boundingSpheres
+        (
+            pointField& centres,
+            scalarField& radiusSqr
+        ) const;
+
+        //- Get the points that define the surface.
+        virtual tmp<pointField> points() const
+        {
+            return coordinates();
+        }
+
+        //- Does any part of the surface overlap the supplied bound box?
+        virtual bool overlaps(const boundBox& bb) const
+        {
+            notImplemented
+            (
+                "searchableDisk::overlaps(const boundBox&) const"
+            );
+
+            return false;
+        }
+
+
+        // Multiple point queries.
+
+            virtual void findNearest
+            (
+                const pointField& sample,
+                const scalarField& nearestDistSqr,
+                List<pointIndexHit>&
+            ) const;
+
+            virtual void findLine
+            (
+                const pointField& start,
+                const pointField& end,
+                List<pointIndexHit>&
+            ) const;
+
+            virtual void findLineAny
+            (
+                const pointField& start,
+                const pointField& end,
+                List<pointIndexHit>&
+            ) const;
+
+            //- Get all intersections in order from start to end.
+            virtual void findLineAll
+            (
+                const pointField& start,
+                const pointField& end,
+                List<List<pointIndexHit> >&
+            ) const;
+
+            //- From a set of points and indices get the region
+            virtual void getRegion
+            (
+                const List<pointIndexHit>&,
+                labelList& region
+            ) const;
+
+            //- From a set of points and indices get the normal
+            virtual void getNormal
+            (
+                const List<pointIndexHit>&,
+                vectorField& normal
+            ) const;
+
+            //- Determine type (inside/outside/mixed) for point. unknown if
+            //  cannot be determined (e.g. non-manifold surface)
+            virtual void getVolumeType
+            (
+                const pointField&,
+                List<volumeType>&
+            ) const;
+
+
+        // regIOobject implementation
+
+            bool writeData(Ostream&) const
+            {
+                notImplemented("searchableDisk::writeData(Ostream&) const");
+                return false;
+            }
+
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/parallel/decompose/decompositionMethods/decompositionMethod/decompositionMethod.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2014 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -33,6 +33,8 @@ InClass
 #include "faceSet.H"
 #include "regionSplit.H"
 #include "localPointRegion.H"
+#include "minData.H"
+#include "FaceCellWave.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
@@ -956,6 +958,72 @@ Foam::labelList Foam::decompositionMethod::decompose
         }
 
 
+        // blockedFaces corresponding to processor faces need to be handled
+        // separately since not handled by local regionSplit. We need to
+        // walk now across coupled faces and make sure to move a whole
+        // global region across
+        if (Pstream::parRun())
+        {
+            // Re-do regionSplit
+
+            // Field on cells and faces.
+            List<minData> cellData(mesh.nCells());
+            List<minData> faceData(mesh.nFaces());
+
+            // Take over blockedFaces by seeding a negative number
+            // (so is always less than the decomposition)
+            label nUnblocked = 0;
+            forAll(blockedFace, faceI)
+            {
+                if (blockedFace[faceI])
+                {
+                    faceData[faceI] = minData(-123);
+                }
+                else
+                {
+                    nUnblocked++;
+                }
+            }
+
+            // Seed unblocked faces with destination processor
+            labelList seedFaces(nUnblocked);
+            List<minData> seedData(nUnblocked);
+            nUnblocked = 0;
+
+            forAll(blockedFace, faceI)
+            {
+                if (!blockedFace[faceI])
+                {
+                    label own = mesh.faceOwner()[faceI];
+                    seedFaces[nUnblocked] = faceI;
+                    seedData[nUnblocked] = minData(finalDecomp[own]);
+                    nUnblocked++;
+                }
+            }
+
+
+            // Propagate information inwards
+            FaceCellWave<minData> deltaCalc
+            (
+                mesh,
+                seedFaces,
+                seedData,
+                faceData,
+                cellData,
+                mesh.globalData().nTotalCells()+1
+            );
+
+            // And extract
+            forAll(finalDecomp, cellI)
+            {
+                if (cellData[cellI].valid(deltaCalc.data()))
+                {
+                    finalDecomp[cellI] = cellData[cellI].data();
+                }
+            }
+        }
+
+
         // For specifiedProcessorFaces rework the cellToProc to enforce
         // all on one processor since we can't guarantee that the input
         // to regionSplit was a single region.
@@ -1000,6 +1068,44 @@ Foam::labelList Foam::decompositionMethod::decompose
                 }
             }
         }
+
+
+        if (debug && Pstream::parRun())
+        {
+            labelList nbrDecomp;
+            syncTools::swapBoundaryCellList(mesh, finalDecomp, nbrDecomp);
+
+            const polyBoundaryMesh& patches = mesh.boundaryMesh();
+            forAll(patches, patchI)
+            {
+                const polyPatch& pp = patches[patchI];
+                if (pp.coupled())
+                {
+                    forAll(pp, i)
+                    {
+                        label faceI = pp.start()+i;
+                        label own = mesh.faceOwner()[faceI];
+                        label bFaceI = faceI-mesh.nInternalFaces();
+
+                        if (!blockedFace[faceI])
+                        {
+                            label ownProc = finalDecomp[own];
+                            label nbrProc = nbrDecomp[bFaceI];
+                            if (ownProc != nbrProc)
+                            {
+                                FatalErrorIn("decompositionMethod::decompose()")
+                                    << "patch:" << pp.name()
+                                    << " face:" << faceI
+                                    << " at:" << mesh.faceCentres()[faceI]
+                                    << " ownProc:" << ownProc
+                                    << " nbrProc:" << nbrProc
+                                    << exit(FatalError);
+                            }
+                        }
+                    }
+                }
+            }
+        }
     }
 
     return finalDecomp;

src/parallel/decompose/decompositionMethods/decompositionMethod/minData.H

@@ -0,0 +1,205 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2014 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::minData
+
+Description
+    For use with FaceCellWave. Transports minimum passive data
+
+SourceFiles
+    minDataI.H
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef minData_H
+#define minData_H
+
+#include "point.H"
+#include "tensor.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+class polyPatch;
+class polyMesh;
+
+/*---------------------------------------------------------------------------*\
+                           Class minData Declaration
+\*---------------------------------------------------------------------------*/
+
+class minData
+{
+    // Private data
+
+        //- Starting data
+        label data_;
+
+
+public:
+
+    // Constructors
+
+        //- Construct null
+        inline minData();
+
+        //- Construct from count
+        inline minData(const label data);
+
+
+    // Member Functions
+
+        // Access
+
+            inline label data() const
+            {
+                return data_;
+            }
+
+
+        // Needed by FaceCellWave
+
+            //- Check whether origin has been changed at all or
+            //  still contains original (invalid) value.
+            template<class TrackingData>
+            inline bool valid(TrackingData& td) const;
+
+            //- Check for identical geometrical data. Used for cyclics checking.
+            template<class TrackingData>
+            inline bool sameGeometry
+            (
+                const polyMesh&,
+                const minData&,
+                const scalar,
+                TrackingData& td
+            ) const;
+
+            //- Convert any absolute coordinates into relative to (patch)face
+            //  centre
+            template<class TrackingData>
+            inline void leaveDomain
+            (
+                const polyMesh&,
+                const polyPatch&,
+                const label patchFaceI,
+                const point& faceCentre,
+                TrackingData& td
+            );
+
+            //- Reverse of leaveDomain
+            template<class TrackingData>
+            inline void enterDomain
+            (
+                const polyMesh&,
+                const polyPatch&,
+                const label patchFaceI,
+                const point& faceCentre,
+                TrackingData& td
+            );
+
+            //- Apply rotation matrix to any coordinates
+            template<class TrackingData>
+            inline void transform
+            (
+                const polyMesh&,
+                const tensor&,
+                TrackingData& td
+            );
+
+            //- Influence of neighbouring face.
+            template<class TrackingData>
+            inline bool updateCell
+            (
+                const polyMesh&,
+                const label thisCellI,
+                const label neighbourFaceI,
+                const minData& neighbourInfo,
+                const scalar tol,
+                TrackingData& td
+            );
+
+            //- Influence of neighbouring cell.
+            template<class TrackingData>
+            inline bool updateFace
+            (
+                const polyMesh&,
+                const label thisFaceI,
+                const label neighbourCellI,
+                const minData& neighbourInfo,
+                const scalar tol,
+                TrackingData& td
+            );
+
+            //- Influence of different value on same face.
+            template<class TrackingData>
+            inline bool updateFace
+            (
+                const polyMesh&,
+                const label thisFaceI,
+                const minData& neighbourInfo,
+                const scalar tol,
+                TrackingData& td
+            );
+
+            //- Same (like operator==)
+            template<class TrackingData>
+            inline bool equal(const minData&, TrackingData& td) const;
+
+    // Member Operators
+
+        // Needed for List IO
+        inline bool operator==(const minData&) const;
+
+        inline bool operator!=(const minData&) const;
+
+
+    // IOstream Operators
+
+        friend Ostream& operator<<(Ostream&, const minData&);
+        friend Istream& operator>>(Istream&, minData&);
+};
+
+
+//- Data associated with minData type are contiguous
+template<>
+inline bool contiguous<minData>()
+{
+    return true;
+}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#include "minDataI.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/parallel/decompose/decompositionMethods/decompositionMethod/minDataI.H

@@ -0,0 +1,222 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2014 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "polyMesh.H"
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+inline Foam::minData::minData()
+:
+    data_(labelMax)
+{}
+
+
+inline Foam::minData::minData(const label data)
+:
+    data_(data)
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+template<class TrackingData>
+inline bool Foam::minData::valid(TrackingData& td) const
+{
+    return data_ != labelMax;
+}
+
+
+template<class TrackingData>
+inline bool Foam::minData::sameGeometry
+(
+    const polyMesh&,
+    const minData&,
+    const scalar,
+    TrackingData&
+) const
+{
+    return true;
+}
+
+
+template<class TrackingData>
+inline void Foam::minData::leaveDomain
+(
+    const polyMesh&,
+    const polyPatch& patch,
+    const label patchFaceI,
+    const point& faceCentre,
+    TrackingData&
+)
+{}
+
+
+template<class TrackingData>
+inline void Foam::minData::transform
+(
+    const polyMesh&,
+    const tensor& rotTensor,
+    TrackingData&
+)
+{}
+
+
+template<class TrackingData>
+inline void Foam::minData::enterDomain
+(
+    const polyMesh&,
+    const polyPatch& patch,
+    const label patchFaceI,
+    const point& faceCentre,
+    TrackingData&
+)
+{}
+
+
+template<class TrackingData>
+inline bool Foam::minData::updateCell
+(
+    const polyMesh&,
+    const label thisCellI,
+    const label neighbourFaceI,
+    const minData& neighbourInfo,
+    const scalar tol,
+    TrackingData&
+)
+{
+    if (neighbourInfo.data_ < data_)
+    {
+        operator=(neighbourInfo);
+        return true;
+    }
+    else
+    {
+        return false;
+    }
+}
+
+
+template<class TrackingData>
+inline bool Foam::minData::updateFace
+(
+    const polyMesh& mesh,
+    const label thisFaceI,
+    const label neighbourCellI,
+    const minData& neighbourInfo,
+    const scalar tol,
+    TrackingData&
+)
+{
+    // From cell to its faces.
+
+    if (neighbourInfo.data_ < data_)
+    {
+        operator=(neighbourInfo);
+        return true;
+    }
+    else
+    {
+        return false;
+    }
+}
+
+
+template<class TrackingData>
+inline bool Foam::minData::updateFace
+(
+    const polyMesh&,
+    const label thisFaceI,
+    const minData& neighbourInfo,
+    const scalar tol,
+    TrackingData&
+)
+{
+    // From face to face (e.g. coupled faces)
+    if (neighbourInfo.data_ < data_)
+    {
+        operator=(neighbourInfo);
+        return true;
+    }
+    else
+    {
+        return false;
+    }
+}
+
+
+template<class TrackingData>
+inline bool Foam::minData::equal
+(
+    const minData& rhs,
+    TrackingData& td
+) const
+{
+    return operator==(rhs);
+}
+
+
+// * * * * * * * * * * * * * * * Member Operators  * * * * * * * * * * * * * //
+
+inline bool Foam::minData::operator==
+(
+    const Foam::minData& rhs
+) const
+{
+    return data() == rhs.data();
+}
+
+
+inline bool Foam::minData::operator!=
+(
+    const Foam::minData& rhs
+) const
+{
+    return !(*this == rhs);
+}
+
+
+// * * * * * * * * * * * * * * * Friend Operators  * * * * * * * * * * * * * //
+
+Foam::Ostream& Foam::operator<<
+(
+    Foam::Ostream& os,
+    const Foam::minData& wDist
+)
+{
+    return os << wDist.data_;
+}
+
+
+Foam::Istream& Foam::operator>>
+(
+    Foam::Istream& is,
+    Foam::minData& wDist
+)
+{
+    return is >> wDist.data_;
+}
+
+
+// ************************************************************************* //

tutorials/multiphase/interDyMFoam/ras/mixerVesselAMI/system/fvSolution

@@ -1,7 +1,7 @@
 /*--------------------------------*- C++ -*----------------------------------*\
 | =========                 |                                                 |
 | \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
-|  \\    /   O peration     | Version:  2.3.0                                 |
+|  \\    /   O peration     | Version:  2.3.x                                 |
 |   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
 |    \\/     M anipulation  |                                                 |
 \*---------------------------------------------------------------------------*/
@@ -74,9 +74,6 @@ PIMPLE
     nOuterCorrectors    2;
     nCorrectors         1;
     nNonOrthogonalCorrectors 0;
-    nAlphaCorr          1;
-    nAlphaSubCycles     2;
-    cAlpha              1;
 }
 
 relaxationFactors