Merge commit 'OpenCFD/master' into olesenm

README

@@ -99,7 +99,7 @@
     and a csh/tcsh example:
 
     + setenv FOAM_INST_DIR /data/app/OpenFOAM
-    + foamDotFile=$FOAM_INST_DIR/OpenFOAM-1.6/etc/bashrc
+    + foamDotFile=$FOAM_INST_DIR/OpenFOAM-1.6/etc/cshrc
     + if ( -f $foamDotFile ) source $foamDotFile
 
     The value set in '$FOAM_INST_DIR' will be used to locate the remaining parts

applications/utilities/mesh/manipulation/splitMeshRegions/splitMeshRegions.C

@@ -45,7 +45,7 @@ Description
     so cannot have any cells in any other zone.
     - useCellZonesOnly does not do a walk and uses the cellZones only. Use
     this if you don't mind having disconnected domains in a single region.
-    This option requires all cells to be in one (and one only) region.
+    This option requires all cells to be in one (and one only) cellZone.
 
 \*---------------------------------------------------------------------------*/
 

applications/utilities/preProcessing/applyBoundaryLayer/Make/options

@@ -1,8 +1,14 @@
 EXE_INC = \
     -I$(LIB_SRC)/finiteVolume/lnInclude \
+    -I$(LIB_SRC)/turbulenceModels \
+    -I$(LIB_SRC)/turbulenceModels/incompressible/RAS/RASModel \
+    -I$(LIB_SRC)/transportModels \
+    -I$(LIB_SRC)/transportModels/incompressible/singlePhaseTransportModel \
     -I$(LIB_SRC)/meshTools/lnInclude
 
 EXE_LIBS = \
     -lfiniteVolume \
+    -lincompressibleRASModels \
+    -lincompressibleTransportModels \
     -lgenericPatchFields \
     -lmeshTools

applications/utilities/preProcessing/applyBoundaryLayer/applyBoundaryLayer.C

@@ -37,6 +37,8 @@ Description
 \*---------------------------------------------------------------------------*/
 
 #include "fvCFD.H"
+#include "singlePhaseTransportModel.H"
+#include "RASModel.H"
 #include "wallDist.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@@ -52,54 +54,14 @@ int main(int argc, char *argv[])
     argList::validOptions.insert("Cbl", "scalar");
     argList::validOptions.insert("writenut", "");
 
-#   include "setRootCase.H"
+    #include "setRootCase.H"
-#   include "createTime.H"
+    #include "createTime.H"
-#   include "createMesh.H"
+    #include "createMesh.H"
+    #include "createFields.H"
 
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+    // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-    Info<< "Reading field U\n" << endl;
+    Info<< "Time = " << runTime.timeName() << nl << endl;
-    volVectorField U
-    (
-        IOobject
-        (
-            "U",
-            runTime.timeName(),
-            mesh,
-            IOobject::MUST_READ,
-            IOobject::NO_WRITE
-        ),
-        mesh
-    );
-
-#   include "createPhi.H"
-
-    Info<< "Calculating wall distance field" << endl;
-    volScalarField y = wallDist(mesh).y();
-
-    // Set the mean boundary-layer thickness
-    dimensionedScalar ybl("ybl", dimLength, 0);
-
-    if (args.optionFound("ybl"))
-    {
-        // If the boundary-layer thickness is provided use it
-        ybl.value() = args.optionRead<scalar>("ybl");
-    }
-    else if (args.optionFound("Cbl"))
-    {
-        // Calculate boundary layer thickness as Cbl * mean distance to wall
-        ybl.value() = gAverage(y) * args.optionRead<scalar>("Cbl");
-    }
-    else
-    {
-        FatalErrorIn(args.executable())
-            << "Neither option 'ybl' or 'Cbl' have been provided to calculate"
-               " the boundary-layer thickness"
-            << exit(FatalError);
-    }
-
-    Info<< "\nCreating boundary-layer for U of thickness "
-        << ybl.value() << " m" << nl << endl;
 
     // Modify velocity by applying a 1/7th power law boundary-layer
     // u/U0 = (y/ybl)^(1/7)
@@ -114,45 +76,18 @@ int main(int argc, char *argv[])
         }
     }
 
-    Info<< "Writing U" << endl;
+    Info<< "Writing U\n" << endl;
     U.write();
 
     // Update/re-write phi
     phi = fvc::interpolate(U) & mesh.Sf();
     phi.write();
 
-    // Read and modify turbulence fields if present
+    // Calculate nut
-
+    tmp<volScalarField> tnut = turbulence->nut();
-    IOobject epsilonHeader
+    volScalarField& nut = tnut();
-    (
+    volScalarField S = mag(dev(symm(fvc::grad(U))));
-        "epsilon",
+    nut = sqr(kappa*min(y, ybl))*::sqrt(2)*S;
-        runTime.timeName(),
-        mesh,
-        IOobject::MUST_READ
-    );
-
-    IOobject kHeader
-    (
-        "k",
-        runTime.timeName(),
-        mesh,
-        IOobject::MUST_READ
-    );
-
-    IOobject nuTildaHeader
-    (
-        "nuTilda",
-        runTime.timeName(),
-        mesh,
-        IOobject::MUST_READ
-    );
-
-    // First calculate nut
-    volScalarField nut
-    (
-        "nut",
-        sqr(kappa*min(y, ybl))*::sqrt(2)*mag(dev(symm(fvc::grad(U))))
-    );
 
     if (args.optionFound("writenut"))
     {
@@ -160,12 +95,69 @@ int main(int argc, char *argv[])
         nut.write();
     }
 
+    // Create G field - used by RAS wall functions
+    volScalarField G("RASModel::G", nut*2*sqr(S));
 
-    // Read and modify turbulence fields if present
+
+    //--- Read and modify turbulence fields
+
+    // Turbulence k
+    tmp<volScalarField> tk = turbulence->k();
+    volScalarField& k = tk();
+    scalar ck0 = pow025(Cmu)*kappa;
+    k = sqr(nut/(ck0*min(y, ybl)));
+    k.correctBoundaryConditions();
+
+    Info<< "Writing k\n" << endl;
+    k.write();
+
+
+    // Turbulence epsilon
+    tmp<volScalarField> tepsilon = turbulence->epsilon();
+    volScalarField& epsilon = tepsilon();
+    scalar ce0 = ::pow(Cmu, 0.75)/kappa;
+    epsilon = ce0*k*sqrt(k)/min(y, ybl);
+    epsilon.correctBoundaryConditions();
+
+    Info<< "Writing epsilon\n" << endl;
+    epsilon.write();
+
+
+    // Turbulence omega
+    IOobject omegaHeader
+    (
+        "omega",
+        runTime.timeName(),
+        mesh,
+        IOobject::MUST_READ,
+        IOobject::NO_WRITE,
+        false
+    );
+
+    if (omegaHeader.headerOk())
+    {
+        volScalarField omega(omegaHeader, mesh);
+        omega = epsilon/(Cmu*k);
+        omega.correctBoundaryConditions();
+
+        Info<< "Writing omega\n" << endl;
+        omega.write();
+    }
+
+
+    // Turbulence nuTilda
+    IOobject nuTildaHeader
+    (
+        "nuTilda",
+        runTime.timeName(),
+        mesh,
+        IOobject::MUST_READ,
+        IOobject::NO_WRITE,
+        false
+    );
 
     if (nuTildaHeader.headerOk())
     {
-        Info<< "Reading field nuTilda\n" << endl;
         volScalarField nuTilda(nuTildaHeader, mesh);
         nuTilda = nut;
         nuTilda.correctBoundaryConditions();
@@ -174,28 +166,6 @@ int main(int argc, char *argv[])
         nuTilda.write();
     }
 
-    if (kHeader.headerOk() && epsilonHeader.headerOk())
-    {
-        Info<< "Reading field k\n" << endl;
-        volScalarField k(kHeader, mesh);
-
-        Info<< "Reading field epsilon\n" << endl;
-        volScalarField epsilon(epsilonHeader, mesh);
-
-        scalar ck0 = ::pow(Cmu, 0.25)*kappa;
-        k = sqr(nut/(ck0*min(y, ybl)));
-        k.correctBoundaryConditions();
-
-        scalar ce0 = ::pow(Cmu, 0.75)/kappa;
-        epsilon = ce0*k*sqrt(k)/min(y, ybl);
-        epsilon.correctBoundaryConditions();
-
-        Info<< "Writing k\n" << endl;
-        k.write();
-
-        Info<< "Writing epsilon\n" << endl;
-        epsilon.write();
-    }
 
     Info<< nl << "ExecutionTime = " << runTime.elapsedCpuTime() << " s"
         << "  ClockTime = " << runTime.elapsedClockTime() << " s"

applications/utilities/preProcessing/applyBoundaryLayer/createFields.H

@@ -0,0 +1,78 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2009-2009 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+\*---------------------------------------------------------------------------*/
+
+    Info<< "Reading field U\n" << endl;
+    volVectorField U
+    (
+        IOobject
+        (
+            "U",
+            runTime.timeName(),
+            mesh,
+            IOobject::MUST_READ,
+            IOobject::NO_WRITE
+        ),
+        mesh
+    );
+
+    #include "createPhi.H"
+
+    singlePhaseTransportModel laminarTransport(U, phi);
+
+    autoPtr<incompressible::RASModel> turbulence
+    (
+        incompressible::RASModel::New(U, phi, laminarTransport)
+    );
+
+    Info<< "Calculating wall distance field" << endl;
+    volScalarField y = wallDist(mesh).y();
+
+    // Set the mean boundary-layer thickness
+    dimensionedScalar ybl("ybl", dimLength, 0);
+
+    if (args.optionFound("ybl"))
+    {
+        // If the boundary-layer thickness is provided use it
+        ybl.value() = args.optionRead<scalar>("ybl");
+    }
+    else if (args.optionFound("Cbl"))
+    {
+        // Calculate boundary layer thickness as Cbl * mean distance to wall
+        ybl.value() = gAverage(y)*args.optionRead<scalar>("Cbl");
+    }
+    else
+    {
+        FatalErrorIn(args.executable())
+            << "Neither option 'ybl' or 'Cbl' have been provided to calculate "
+            << "the boundary-layer thickness"
+            << exit(FatalError);
+    }
+
+    Info<< "\nCreating boundary-layer for U of thickness "
+        << ybl.value() << " m" << nl << endl;
+
+
+// ************************************************************************* //

bin/mpirunDebug

@@ -206,6 +206,21 @@ done
 cmd=""
 if [ .$WM_MPLIB = .OPENMPI ]; then
     cmd="mpirun -app $PWD/mpirun.schema </dev/null"
+elif [ .$WM_MPLIB = .MPICH ]; then
+    cmd="mpiexec"
+    for ((proc=0; proc<$nProcs; proc++))
+    do
+        read procCmd
+
+        procXtermCmdFile="$PWD/processor${proc}Xterm.sh"
+        echo "#!/bin/sh" > $procXtermCmdFile
+        echo "$procCmd" >> $procXtermCmdFile
+        chmod +x $procXtermCmdFile
+        if [ $proc -ne 0 ]; then
+            cmd="${cmd} :"
+        fi
+        cmd="${cmd} -n 1 ${procXtermCmdFile}"
+    done < $PWD/mpirun.schema
 fi
 
 echo "Constructed $PWD/mpirun.schema file."

etc/apps/paraview/bashrc

@@ -1,67 +0,0 @@
-#----------------------------------*-sh-*--------------------------------------
-# =========                 |
-# \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-#  \\    /   O peration     |
-#   \\  /    A nd           | Copyright (C) 1991-2009 OpenCFD Ltd.
-#    \\/     M anipulation  |
-#------------------------------------------------------------------------------
-# License
-#     This file is part of OpenFOAM.
-#
-#     OpenFOAM is free software; you can redistribute it and/or modify it
-#     under the terms of the GNU General Public License as published by the
-#     Free Software Foundation; either version 2 of the License, or (at your
-#     option) any later version.
-#
-#     OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-#     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-#     FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-#     for more details.
-#
-#     You should have received a copy of the GNU General Public License
-#     along with OpenFOAM; if not, write to the Free Software Foundation,
-#     Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
-#
-# Script
-#     paraview/bashrc
-#
-# Description
-#     Setup file for paraview-2.x
-#     Sourced from OpenFOAM-*/etc/bashrc
-#
-#------------------------------------------------------------------------------
-
-# determine the cmake to be used
-unset CMAKE_HOME
-for cmake in cmake-2.6.4 cmake-2.6.2 cmake-2.4.6
-do
-    cmake=$WM_THIRD_PARTY_DIR/$cmake/platforms/$WM_ARCH
-    if [ -r $cmake ]
-    then
-        export CMAKE_HOME=$cmake
-        export PATH=$CMAKE_HOME/bin:$PATH
-        break
-    fi
-done
-
-paraviewMajor=paraview-2.4
-export ParaView_VERSION=2.4.4
-
-export ParaView_INST_DIR=$WM_THIRD_PARTY_DIR/ParaView$ParaView_VERSION
-export ParaView_DIR=$ParaView_INST_DIR/lib/$paraviewMajor
-
-if [ -r $ParaView_INST_DIR ]
-then
-    export PV_INTERFACE_PATH=$FOAM_UTILITIES/postProcessing/graphics/PVFoamReader/PVFoamReader/Make
-
-    export PATH=$ParaView_INST_DIR/bin:$PATH
-    export LD_LIBRARY_PATH=${ParaView_INST_DIR}/lib:${ParaView_INST_DIR}/lib/vtk:${LD_LIBRARY_PATH}
-fi
-
-if [ -r $ParaView_DIR ]
-then
-    export VTK_DIR=$ParaView_DIR/VTK
-fi
-
-unset cmake paraviewMajor
-# -----------------------------------------------------------------------------

etc/apps/paraview/cshrc

@@ -1,63 +0,0 @@
-#----------------------------------*-sh-*--------------------------------------
-# =========                 |
-# \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-#  \\    /   O peration     |
-#   \\  /    A nd           | Copyright (C) 1991-2009 OpenCFD Ltd.
-#    \\/     M anipulation  |
-#------------------------------------------------------------------------------
-# License
-#     This file is part of OpenFOAM.
-#
-#     OpenFOAM is free software; you can redistribute it and/or modify it
-#     under the terms of the GNU General Public License as published by the
-#     Free Software Foundation; either version 2 of the License, or (at your
-#     option) any later version.
-#
-#     OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-#     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-#     FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-#     for more details.
-#
-#     You should have received a copy of the GNU General Public License
-#     along with OpenFOAM; if not, write to the Free Software Foundation,
-#     Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
-#
-# Script
-#     paraview/cshrc
-#
-# Description
-#     Setup file for paraview-2.x
-#     Sourced from OpenFOAM-*/etc/cshrc
-#
-#------------------------------------------------------------------------------
-
-# determine the cmake to be used
-unsetenv CMAKE_HOME
-foreach cmake ( cmake-2.6.4 cmake-2.6.2 cmake-2.4.6 )
-    set cmake=$WM_THIRD_PARTY_DIR/$cmake/platforms/$WM_ARCH
-    if ( -r $cmake ) then
-        setenv CMAKE_HOME $cmake
-        set path=($CMAKE_HOME/bin $path)
-        break
-    endif
-end
-
-set paraviewMajor=paraview-2.4
-setenv ParaView_VERSION 2.4.4
-
-setenv ParaView_INST_DIR $WM_THIRD_PARTY_DIR/ParaView$ParaView_VERSION
-setenv ParaView_DIR $ParaView_INST_DIR/lib/$paraviewMajor
-
-if ( -r $ParaView_INST_DIR ) then
-    setenv PV_INTERFACE_PATH $FOAM_UTILITIES/postProcessing/graphics/PVFoamReader/PVFoamReader/Make
-
-    set path=($ParaView_INST_DIR/bin $path)
-    setenv LD_LIBRARY_PATH ${ParaView_INST_DIR}/lib:${ParaView_INST_DIR}/lib/vtk:${LD_LIBRARY_PATH}
-endif
-
-if ( -r $ParaView_DIR ) then
-    setenv VTK_DIR $ParaView_DIR/VTK
-endif
-
-unset cmake paraviewMajor
-# -----------------------------------------------------------------------------

etc/apps/paraview3/bashrc

@@ -46,21 +46,22 @@ do
     fi
 done
 
-paraviewMajor=paraview-3.6
+# set MAJOR and VERSION variables if not already set
-export ParaView_VERSION=3.6.1
+[ -z "$ParaView_MAJOR" ] && export ParaView_MAJOR=paraview-3.6
+[ -z "$ParaView_VERSION" ] && export ParaView_VERSION=3.6.1
 
 export ParaView_INST_DIR=$WM_THIRD_PARTY_DIR/paraview-$ParaView_VERSION
 export ParaView_DIR=$ParaView_INST_DIR/platforms/$WM_ARCH$WM_COMPILER
 
 # add in python libraries if required
-paraviewPython=$ParaView_DIR/Utilities/VTKPythonWrapping
+ParaView_PYTHON_DIR=$ParaView_DIR/Utilities/VTKPythonWrapping
-if [ -r $paraviewPython ]
+if [ -r $ParaView_PYTHON_DIR ]
 then
     if [ "$PYTHONPATH" ]
     then
-        export PYTHONPATH=$PYTHONPATH:$paraviewPython:$ParaView_DIR/lib/$paraviewMajor
+        export PYTHONPATH=$PYTHONPATH:$ParaView_PYTHON_DIR:$ParaView_DIR/lib/$ParaView_MAJOR
     else
-        export PYTHONPATH=$paraviewPython:$ParaView_DIR/lib/$paraviewMajor
+        export PYTHONPATH=$ParaView_PYTHON_DIR:$ParaView_DIR/lib/$ParaView_MAJOR
     fi
 fi
 
@@ -70,5 +71,5 @@ then
     export PV_PLUGIN_PATH=$FOAM_LIBBIN
 fi
 
-unset cmake paraviewMajor paraviewPython
+unset cmake ParaView_PYTHON_DIR
 # -----------------------------------------------------------------------------

src/OpenFOAM/containers/Lists/UList/UList.H

@@ -184,6 +184,12 @@ public:
         //  an out-of-range element returns false without any ill-effects
         inline const T& operator[](const label) const;
 
+        //- Return last element of UList.
+        inline T& last();
+
+        //- Return last element of UList.
+        inline const T& last() const;
+
         //- Allow cast to a const List<T>&
         inline operator const Foam::List<T>&() const;
 

src/OpenFOAM/containers/Lists/UList/UListI.H

@@ -114,6 +114,20 @@ inline void Foam::UList<T>::checkIndex(const label i) const
 }
 
 
+template<class T>
+inline T& Foam::UList<T>::last()
+{
+    return this->operator[](this->size()-1);
+}
+
+
+template<class T>
+inline const T& Foam::UList<T>::last() const
+{
+    return this->operator[](this->size()-1);
+}
+
+
 template<class T>
 inline const T* Foam::UList<T>::cdata() const
 {

src/OpenFOAM/db/IOstreams/Pstreams/PstreamBuffers.C

@@ -82,9 +82,6 @@ void Foam::PstreamBuffers::finishedSends(labelListList& sizes, const bool block)
 
     if (commsType_ == UPstream::nonBlocking)
     {
-        labelListList sizes;
-        labelListList send,recv;
-
         Pstream::exchange<DynamicList<char>, char>
         (
             sendBuf_,
@@ -96,20 +93,30 @@ void Foam::PstreamBuffers::finishedSends(labelListList& sizes, const bool block)
     }
     else
     {
-        sizes.setSize(UPstream::nProcs());
+        FatalErrorIn
-        labelList& nsTransPs = sizes[UPstream::myProcNo()];
+        (
-        nsTransPs.setSize(UPstream::nProcs());
+            "PstreamBuffers::finishedSends(labelListList&, const bool)"
+        )   << "Obtaining sizes not supported in "
+            << UPstream::commsTypeNames[commsType_] << endl
+            << " since transfers already in progress. Use non-blocking instead."
+            << exit(FatalError);
 
-        forAll(sendBuf_, procI)
+        // Note: possible only if using different tag from write started
-        {
+        // by ~UOPstream. Needs some work.
-            nsTransPs[procI] = sendBuf_[procI].size();
+        //sizes.setSize(UPstream::nProcs());
-        }
+        //labelList& nsTransPs = sizes[UPstream::myProcNo()];
-
+        //nsTransPs.setSize(UPstream::nProcs());
-        // Send sizes across.
+        //
-        int oldTag = UPstream::msgType();
+        //forAll(sendBuf_, procI)
-        UPstream::msgType() = tag_;
+        //{
-        combineReduce(sizes, UPstream::listEq());
+        //    nsTransPs[procI] = sendBuf_[procI].size();
-        UPstream::msgType() = oldTag;
+        //}
+        //
+        //// Send sizes across.
+        //int oldTag = UPstream::msgType();
+        //UPstream::msgType() = tag_;
+        //combineReduce(sizes, UPstream::listEq());
+        //UPstream::msgType() = oldTag;
     }
 }
 

src/OpenFOAM/db/IOstreams/Pstreams/PstreamBuffers.H

@@ -138,7 +138,8 @@ public:
         void finishedSends(const bool block = true);
 
         //- Mark all sends as having been done. Same as above but also returns
-        //  sizes (bytes) transferred.
+        //  sizes (bytes) transferred. Note:currently only valid for
+        //  non-blocking.
         void finishedSends(labelListList& sizes, const bool block = true);
 
 };

src/OpenFOAM/db/IOstreams/Pstreams/exchange.C

@@ -50,43 +50,42 @@ void Pstream::exchange
     const bool block
 )
 {
-    if (UPstream::parRun())
+    if (!contiguous<T>())
     {
-        if (!contiguous<T>())
+        FatalErrorIn
-        {
+        (
-            FatalErrorIn
+            "Pstream::exchange(..)"
-            (
+        )   << "Continuous data only." << Foam::abort(FatalError);
-                "Pstream::exchange(..)"
+    }
-            )   << "Continuous data only." << Foam::abort(FatalError);
-        }
 
-        if (sendBufs.size() != UPstream::nProcs())
+    if (sendBufs.size() != UPstream::nProcs())
-        {
+    {
-            FatalErrorIn
+        FatalErrorIn
-            (
+        (
-                "Pstream::exchange(..)"
+            "Pstream::exchange(..)"
-            )   << "Size of list:" << sendBufs.size()
+        )   << "Size of list:" << sendBufs.size()
-                << " does not equal the number of processors:"
+            << " does not equal the number of processors:"
-                << UPstream::nProcs()
+            << UPstream::nProcs()
-                << Foam::abort(FatalError);
+            << Foam::abort(FatalError);
-        }
+    }
 
-        sizes.setSize(UPstream::nProcs());
+    sizes.setSize(UPstream::nProcs());
-        labelList& nsTransPs = sizes[UPstream::myProcNo()];
+    labelList& nsTransPs = sizes[UPstream::myProcNo()];
-        nsTransPs.setSize(UPstream::nProcs());
+    nsTransPs.setSize(UPstream::nProcs());
 
-        forAll(sendBufs, procI)
+    forAll(sendBufs, procI)
-        {
+    {
-            nsTransPs[procI] = sendBufs[procI].size();
+        nsTransPs[procI] = sendBufs[procI].size();
-        }
+    }
-
-        // Send sizes across.
-        int oldTag = UPstream::msgType();
-        UPstream::msgType() = tag;
-        combineReduce(sizes, UPstream::listEq());
-        UPstream::msgType() = oldTag;
 
+    // Send sizes across.
+    int oldTag = UPstream::msgType();
+    UPstream::msgType() = tag;
+    combineReduce(sizes, UPstream::listEq());
+    UPstream::msgType() = oldTag;
 
+    if (Pstream::parRun())
+    {
         // Set up receives
         // ~~~~~~~~~~~~~~~
 

src/OpenFOAM/db/functionObjects/OutputFilterFunctionObject/OutputFilterFunctionObject.C

@@ -37,8 +37,43 @@ void Foam::OutputFilterFunctionObject<OutputFilter>::readDict()
     dict_.readIfPresent("region", regionName_);
     dict_.readIfPresent("dictionary", dictName_);
     dict_.readIfPresent("enabled", enabled_);
+    dict_.readIfPresent("storeFilter", storeFilter_);
 }
 
+template<class OutputFilter>
+void Foam::OutputFilterFunctionObject<OutputFilter>::allocateFilter()
+{
+    if (dictName_.size())
+    {
+        ptr_.reset
+        (
+            new IOOutputFilter<OutputFilter>
+            (
+                name(),
+                time_.lookupObject<objectRegistry>(regionName_),
+                dictName_
+            )
+        );
+    }
+    else
+    {
+        ptr_.reset
+        (
+            new OutputFilter
+            (
+                name(),
+                time_.lookupObject<objectRegistry>(regionName_),
+                dict_
+            )
+        );
+    }
+}
+
+template<class OutputFilter>
+void Foam::OutputFilterFunctionObject<OutputFilter>::destroyFilter()
+{
+    ptr_.reset();
+}
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
@@ -56,6 +91,7 @@ Foam::OutputFilterFunctionObject<OutputFilter>::OutputFilterFunctionObject
     regionName_(polyMesh::defaultRegion),
     dictName_(),
     enabled_(true),
+    storeFilter_(true),
     outputControl_(t, dict)
 {
     readDict();
@@ -83,32 +119,9 @@ bool Foam::OutputFilterFunctionObject<OutputFilter>::start()
 {
     readDict();
 
-    if (enabled_)
+    if (enabled_&&storeFilter_)
     {
-        if (dictName_.size())
+        allocateFilter();
-        {
-            ptr_.reset
-            (
-                new IOOutputFilter<OutputFilter>
-                (
-                    name(),
-                    time_.lookupObject<objectRegistry>(regionName_),
-                    dictName_
-                )
-            );
-        }
-        else
-        {
-            ptr_.reset
-            (
-                new OutputFilter
-                (
-                    name(),
-                    time_.lookupObject<objectRegistry>(regionName_),
-                    dict_
-                )
-            );
-        }
     }
 
     return true;
@@ -120,12 +133,22 @@ bool Foam::OutputFilterFunctionObject<OutputFilter>::execute()
 {
     if (enabled_)
     {
+        if (!storeFilter_)
+        {
+            allocateFilter();
+        }
+
         ptr_->execute();
 
-        if (enabled_ && outputControl_.output())
+        if (outputControl_.output())
         {
             ptr_->write();
         }
+
+        if (!storeFilter_)
+        {
+            destroyFilter();
+        }
     }
 
     return true;
@@ -137,12 +160,22 @@ bool Foam::OutputFilterFunctionObject<OutputFilter>::end()
 {
     if (enabled_)
     {
+        if (!storeFilter_)
+        {
+            allocateFilter();
+        }
+
         ptr_->end();
 
-        if (enabled_ && outputControl_.output())
+        if (outputControl_.output())
         {
             ptr_->write();
         }
+
+        if (!storeFilter_)
+        {
+            destroyFilter();
+        }
     }
 
     return true;

src/OpenFOAM/db/functionObjects/OutputFilterFunctionObject/OutputFilterFunctionObject.H

@@ -78,6 +78,10 @@ class OutputFilterFunctionObject
         //- Switch for the execution of the functionObject
         bool enabled_;
 
+        //- Switch to store filter in between writes or use on-the-fly
+        //  construction
+        bool storeFilter_;
+
         //- Output controls
         outputFilterOutputControl outputControl_;
 
@@ -90,6 +94,12 @@ class OutputFilterFunctionObject
         //- Read relevant dictionary entries
         void readDict();
  
+        //- Creates most of the data associated with this object.
+        void allocateFilter();
+
+        //- Destroys most of the data associated with this object.
+        void destroyFilter();
+
         //- Disallow default bitwise copy construct
         OutputFilterFunctionObject(const OutputFilterFunctionObject&);
 

src/OpenFOAM/meshes/pointMesh/pointBoundaryMesh/pointBoundaryMesh.C

@@ -28,6 +28,9 @@ License
 #include "polyBoundaryMesh.H"
 #include "facePointPatch.H"
 #include "globalPointPatch.H"
+#include "PstreamBuffers.H"
+#include "lduSchedule.H"
+#include "globalMeshData.H"
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
@@ -58,14 +61,46 @@ Foam::pointBoundaryMesh::pointBoundaryMesh
 
 void Foam::pointBoundaryMesh::calcGeometry()
 {
-    forAll(*this, patchi)
+    PstreamBuffers pBufs(Pstream::defaultCommsType);
-    {
-        operator[](patchi).initGeometry();
-    }
 
-    forAll(*this, patchi)
+    if
+    (
+        Pstream::defaultCommsType == Pstream::blocking
+     || Pstream::defaultCommsType == Pstream::nonBlocking
+    )
     {
-        operator[](patchi).calcGeometry();
+        forAll(*this, patchi)
+        {
+            operator[](patchi).initGeometry(pBufs);
+        }
+
+        pBufs.finishedSends();
+
+        forAll(*this, patchi)
+        {
+            operator[](patchi).calcGeometry(pBufs);
+        }
+    }
+    else if (Pstream::defaultCommsType == Pstream::scheduled)
+    {
+        const lduSchedule& patchSchedule = mesh().globalData().patchSchedule();
+
+        // Dummy.
+        pBufs.finishedSends();
+
+        forAll(patchSchedule, patchEvali)
+        {
+            label patchi = patchSchedule[patchEvali].patch;
+
+            if (patchSchedule[patchEvali].init)
+            {
+                operator[](patchi).initGeometry(pBufs);
+            }
+            else
+            {
+                operator[](patchi).calcGeometry(pBufs);
+            }
+        }
     }
 }
 
@@ -97,32 +132,92 @@ Foam::pointBoundaryMesh::globalPatch() const
 
 void Foam::pointBoundaryMesh::movePoints(const pointField& p)
 {
-    pointPatchList& patches = *this;
+    PstreamBuffers pBufs(Pstream::defaultCommsType);
 
-    forAll(patches, patchi)
+    if
+    (
+        Pstream::defaultCommsType == Pstream::blocking
+     || Pstream::defaultCommsType == Pstream::nonBlocking
+    )
     {
-        patches[patchi].initMovePoints(p);
+        forAll(*this, patchi)
+        {
+            operator[](patchi).initMovePoints(pBufs, p);
+        }
+
+        pBufs.finishedSends();
+
+        forAll(*this, patchi)
+        {
+            operator[](patchi).movePoints(pBufs, p);
+        }
     }
-
+    else if (Pstream::defaultCommsType == Pstream::scheduled)
-    forAll(patches, patchi)
     {
-        patches[patchi].movePoints(p);
+        const lduSchedule& patchSchedule = mesh().globalData().patchSchedule();
+
+        // Dummy.
+        pBufs.finishedSends();
+
+        forAll(patchSchedule, patchEvali)
+        {
+            label patchi = patchSchedule[patchEvali].patch;
+
+            if (patchSchedule[patchEvali].init)
+            {
+                operator[](patchi).initMovePoints(pBufs, p);
+            }
+            else
+            {
+                operator[](patchi).movePoints(pBufs, p);
+            }
+        }
     }
 }
 
 
 void Foam::pointBoundaryMesh::updateMesh()
 {
-    pointPatchList& patches = *this;
+    PstreamBuffers pBufs(Pstream::defaultCommsType);
 
-    forAll(patches, patchi)
+    if
+    (
+        Pstream::defaultCommsType == Pstream::blocking
+     || Pstream::defaultCommsType == Pstream::nonBlocking
+    )
     {
-        patches[patchi].initUpdateMesh();
+        forAll(*this, patchi)
+        {
+            operator[](patchi).initUpdateMesh(pBufs);
+        }
+
+        pBufs.finishedSends();
+
+        forAll(*this, patchi)
+        {
+            operator[](patchi).updateMesh(pBufs);
+        }
     }
-
+    else if (Pstream::defaultCommsType == Pstream::scheduled)
-    forAll(patches, patchi)
     {
-        patches[patchi].updateMesh();
+        const lduSchedule& patchSchedule = mesh().globalData().patchSchedule();
+
+        // Dummy.
+        pBufs.finishedSends();
+
+        forAll(patchSchedule, patchEvali)
+        {
+            label patchi = patchSchedule[patchEvali].patch;
+
+            if (patchSchedule[patchEvali].init)
+            {
+                operator[](patchi).initUpdateMesh(pBufs);
+            }
+            else
+            {
+                operator[](patchi).updateMesh(pBufs);
+            }
+        }
     }
 }
 

src/OpenFOAM/meshes/pointMesh/pointPatches/basic/coupled/coupledPointPatch.H

@@ -66,22 +66,22 @@ protected:
     // Protected Member Functions
 
         //- Initialise the calculation of the patch geometry
-        virtual void initGeometry() = 0;
+        virtual void initGeometry(PstreamBuffers&) = 0;
 
         //- Calculate the patch geometry
-        virtual void calcGeometry() = 0;
+        virtual void calcGeometry(PstreamBuffers&) = 0;
 
         //- Initialise the patches for moving points
-        virtual void initMovePoints(const pointField&) = 0;
+        virtual void initMovePoints(PstreamBuffers&, const pointField&) = 0;
 
         //- Correct patches after moving points
-        virtual void movePoints(const pointField&) = 0;
+        virtual void movePoints(PstreamBuffers&, const pointField&) = 0;
 
         //- Initialise the update of the patch topology
-        virtual void initUpdateMesh() = 0;
+        virtual void initUpdateMesh(PstreamBuffers&) = 0;
 
         //- Update of the patch topology
-        virtual void updateMesh() = 0;
+        virtual void updateMesh(PstreamBuffers&) = 0;
 
 
 public:

src/OpenFOAM/meshes/pointMesh/pointPatches/constraint/cyclic/cyclicPointPatch.C

@@ -50,13 +50,13 @@ addToRunTimeSelectionTable
 
 // * * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * //
 
-void Foam::cyclicPointPatch::initGeometry()
+void Foam::cyclicPointPatch::initGeometry(PstreamBuffers&)
 {
     transformPairs_.setSize(0);
 }
 
 
-void Foam::cyclicPointPatch::calcGeometry()
+void Foam::cyclicPointPatch::calcGeometry(PstreamBuffers&)
 {
     const edgeList& cp = cyclicPolyPatch_.coupledPoints();
     const labelList& mp = cyclicPolyPatch_.meshPoints();
@@ -128,16 +128,20 @@ void Foam::cyclicPointPatch::calcGeometry()
             }
             else if (pointMap[cp[i][0]] == -1 && pointMap[cp[i][1]] != -1)
             {
-                FatalErrorIn("cyclicPointPatch::calcGeometry() const")
+                FatalErrorIn
-                    << "Point " << cp[i][0] << "of point-pair " << i
+                (
+                    "cyclicPointPatch::calcGeometry(PstreamBuffers&) const"
+                )   << "Point " << cp[i][0] << "of point-pair " << i
                     << " is a global point but the other point "
                     << cp[i][1] << " is not"
                     << exit(FatalError);
             }
             else if (pointMap[cp[i][0]] != -1 && pointMap[cp[i][1]] == -1)
             {
-                FatalErrorIn("cyclicPointPatch::calcGeometry() const")
+                FatalErrorIn
-                    << "Point " << cp[i][1] << "of point-pair " << i
+                (
+                    "cyclicPointPatch::calcGeometry(PstreamBuffers&) const"
+                )   << "Point " << cp[i][1] << "of point-pair " << i
                     << " is a global point but the other point "
                     << cp[i][0] << " is not"
                     << exit(FatalError);
@@ -149,25 +153,25 @@ void Foam::cyclicPointPatch::calcGeometry()
 }
 
 
-void cyclicPointPatch::initMovePoints(const pointField&)
+void cyclicPointPatch::initMovePoints(PstreamBuffers&, const pointField&)
 {}
 
 
-void cyclicPointPatch::movePoints(const pointField&)
+void cyclicPointPatch::movePoints(PstreamBuffers&, const pointField&)
 {}
 
 
-void cyclicPointPatch::initUpdateMesh()
+void cyclicPointPatch::initUpdateMesh(PstreamBuffers& pBufs)
 {
-    facePointPatch::initUpdateMesh();
+    facePointPatch::initUpdateMesh(pBufs);
-    cyclicPointPatch::initGeometry();
+    cyclicPointPatch::initGeometry(pBufs);
 }
 
 
-void cyclicPointPatch::updateMesh()
+void cyclicPointPatch::updateMesh(PstreamBuffers& pBufs)
 {
-    facePointPatch::updateMesh();
+    facePointPatch::updateMesh(pBufs);
-    cyclicPointPatch::calcGeometry();
+    cyclicPointPatch::calcGeometry(pBufs);
 }
 
 

src/OpenFOAM/meshes/pointMesh/pointPatches/constraint/cyclic/cyclicPointPatch.H

@@ -74,22 +74,22 @@ class cyclicPointPatch
         edgeList transformPairs_;
 
         //- Initialise the calculation of the patch geometry
-        virtual void initGeometry();
+        virtual void initGeometry(PstreamBuffers&);
 
         //- Calculate the patch geometry
-        virtual void calcGeometry();
+        virtual void calcGeometry(PstreamBuffers&);
 
         //- Initialise the patches for moving points
-        virtual void initMovePoints(const pointField&);
+        virtual void initMovePoints(PstreamBuffers&, const pointField&);
 
         //- Correct patches after moving points
-        virtual void movePoints(const pointField&);
+        virtual void movePoints(PstreamBuffers&, const pointField&);
 
         //- Initialise the update of the patch topology
-        virtual void initUpdateMesh();
+        virtual void initUpdateMesh(PstreamBuffers&);
 
         //- Update of the patch topology
-        virtual void updateMesh();
+        virtual void updateMesh(PstreamBuffers&);
 
 
 public:

src/OpenFOAM/meshes/pointMesh/pointPatches/constraint/processor/processorPointPatch.C

@@ -52,7 +52,7 @@ addToRunTimeSelectionTable
 
 // * * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * //
 
-void Foam::processorPointPatch::initGeometry()
+void Foam::processorPointPatch::initGeometry(PstreamBuffers& pBufs)
 {
     // Algorithm:
     // Depending on whether the patch is a master or a slave, get the primitive
@@ -84,16 +84,16 @@ void Foam::processorPointPatch::initGeometry()
 
     if (Pstream::parRun())
     {
-        initPatchPatchPoints();
+        initPatchPatchPoints(pBufs);
     }
 }
 
 
-void Foam::processorPointPatch::calcGeometry()
+void Foam::processorPointPatch::calcGeometry(PstreamBuffers& pBufs)
 {
     if (Pstream::parRun())
     {
-        calcPatchPatchPoints();
+        calcPatchPatchPoints(pBufs);
     }
 
     // If it is not runing parallel or there are no global points
@@ -149,11 +149,11 @@ void Foam::processorPointPatch::calcGeometry()
 }
 
 
-void processorPointPatch::initPatchPatchPoints()
+void processorPointPatch::initPatchPatchPoints(PstreamBuffers& pBufs)
 {
     if (debug)
     {
-        Info<< "processorPointPatch::calcPatchPatchPoints() : "
+        Info<< "processorPointPatch::initPatchPatchPoints(PstreamBuffers&) : "
             << "constructing patch-patch points"
             << endl;
     }
@@ -229,7 +229,7 @@ void processorPointPatch::initPatchPatchPoints()
 
     // Send the patchPatchPoints to the neighbouring processor
 
-    OPstream toNeighbProc(Pstream::blocking, neighbProcNo());
+    UOPstream toNeighbProc(neighbProcNo(), pBufs);
 
     toNeighbProc
         << ppmp.size()              // number of points for checking
@@ -238,17 +238,17 @@ void processorPointPatch::initPatchPatchPoints()
 
     if (debug)
     {
-        Info<< "processorPointPatch::calcPatchPatchPoints() : "
+        Info<< "processorPointPatch::initPatchPatchPoints() : "
             << "constructed patch-patch points"
             << endl;
     }
 }
 
 
-void Foam::processorPointPatch::calcPatchPatchPoints()
+void Foam::processorPointPatch::calcPatchPatchPoints(PstreamBuffers& pBufs)
 {
     // Get the patchPatchPoints from the neighbouring processor
-    IPstream fromNeighbProc(Pstream::blocking, neighbProcNo());
+    UIPstream fromNeighbProc(neighbProcNo(), pBufs);
 
     label nbrNPoints(readLabel(fromNeighbProc));
     labelListList patchPatchPoints(fromNeighbProc);
@@ -265,7 +265,7 @@ void Foam::processorPointPatch::calcPatchPatchPoints()
     // separate.
     if (nbrNPoints != ppmp.size())
     {
-        WarningIn("processorPointPatch::calcPatchPatchPoints()")
+        WarningIn("processorPointPatch::calcPatchPatchPoints(PstreamBuffers&)")
             << "Processor patch " << name()
             << " has " << ppmp.size() << " points; coupled patch has "
             << nbrNPoints << " points." << endl
@@ -352,25 +352,25 @@ void Foam::processorPointPatch::calcPatchPatchPoints()
 }
 
 
-void processorPointPatch::initMovePoints(const pointField&)
+void processorPointPatch::initMovePoints(PstreamBuffers&, const pointField&)
 {}
 
 
-void processorPointPatch::movePoints(const pointField&)
+void processorPointPatch::movePoints(PstreamBuffers&, const pointField&)
 {}
 
 
-void processorPointPatch::initUpdateMesh()
+void processorPointPatch::initUpdateMesh(PstreamBuffers& pBufs)
 {
-    facePointPatch::initUpdateMesh();
+    facePointPatch::initUpdateMesh(pBufs);
-    processorPointPatch::initGeometry();
+    processorPointPatch::initGeometry(pBufs);
 }
 
 
-void processorPointPatch::updateMesh()
+void processorPointPatch::updateMesh(PstreamBuffers& pBufs)
 {
-    facePointPatch::updateMesh();
+    facePointPatch::updateMesh(pBufs);
-    processorPointPatch::calcGeometry();
+    processorPointPatch::calcGeometry(pBufs);
 }
 
 

src/OpenFOAM/meshes/pointMesh/pointPatches/constraint/processor/processorPointPatch.H

@@ -68,30 +68,30 @@ class processorPointPatch
     // Private Member Functions
 
         //- Initialise the calculation of the patch geometry
-        virtual void initGeometry();
+        virtual void initGeometry(PstreamBuffers&);
 
         //- Calculate the patch geometry
-        virtual void calcGeometry();
+        virtual void calcGeometry(PstreamBuffers&);
 
         //- Initialise the points on this patch which are should also be 
         //  on a neighbouring patch but are not part of faces of that patch
-        void initPatchPatchPoints();
+        void initPatchPatchPoints(PstreamBuffers&);
 
         //- Calculate the points on this patch which are should also be 
         //  on a neighbouring patch but are not part of faces of that patch
-        void calcPatchPatchPoints();
+        void calcPatchPatchPoints(PstreamBuffers&);
 
         //- Initialise the patches for moving points
-        virtual void initMovePoints(const pointField&);
+        virtual void initMovePoints(PstreamBuffers&, const pointField&);
 
         //- Correct patches after moving points
-        virtual void movePoints(const pointField&);
+        virtual void movePoints(PstreamBuffers&, const pointField&);
 
         //- Initialise the update of the patch topology
-        virtual void initUpdateMesh();
+        virtual void initUpdateMesh(PstreamBuffers&);
 
         //- Update of the patch topology
-        virtual void updateMesh();
+        virtual void updateMesh(PstreamBuffers&);
 
 
         //- Disallow default construct as copy

src/OpenFOAM/meshes/pointMesh/pointPatches/derived/coupled/coupledFacePointPatch.H

@@ -86,7 +86,7 @@ protected:
         // Construction of demand-driven data
 
             //- Calculate mesh points
-            virtual void calcGeometry() = 0;
+            virtual void calcGeometry(PstreamBuffers&) = 0;
 
 
 public:

src/OpenFOAM/meshes/pointMesh/pointPatches/derived/global/globalPointPatch.H

@@ -67,27 +67,27 @@ class globalPointPatch
     // Protected Member Functions
 
         //- Initialise the calculation of the patch geometry
-        virtual void initGeometry()
+        virtual void initGeometry(PstreamBuffers&)
         {}
 
         //- Calculate the patch geometry
-        virtual void calcGeometry()
+        virtual void calcGeometry(PstreamBuffers&)
         {}
 
         //- Initialise the patches for moving points
-        virtual void initMovePoints(const pointField&)
+        virtual void initMovePoints(PstreamBuffers&, const pointField&)
         {}
 
         //- Correct patches after moving points
-        virtual void movePoints(const pointField&)
+        virtual void movePoints(PstreamBuffers&, const pointField&)
         {}
 
         //- Initialise the update of the patch topology
-        virtual void initUpdateMesh()
+        virtual void initUpdateMesh(PstreamBuffers&)
         {}
 
         //- Update of the patch topology
-        virtual void updateMesh()
+        virtual void updateMesh(PstreamBuffers&)
         {}
 
 

src/OpenFOAM/meshes/pointMesh/pointPatches/facePointPatch/facePointPatch.C

@@ -51,7 +51,7 @@ addToRunTimeSelectionTable
 
 // * * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * //
 
-void facePointPatch::initGeometry()
+void facePointPatch::initGeometry(PstreamBuffers&)
 {
     meshPoints_.setSize(0);
     localPoints_.setSize(0);
@@ -59,25 +59,25 @@ void facePointPatch::initGeometry()
 }
 
 
-void facePointPatch::calcGeometry()
+void facePointPatch::calcGeometry(PstreamBuffers&)
 {}
 
 
-void facePointPatch::initMovePoints(const pointField&)
+void facePointPatch::initMovePoints(PstreamBuffers&, const pointField&)
 {}
 
 
-void facePointPatch::movePoints(const pointField&)
+void facePointPatch::movePoints(PstreamBuffers&, const pointField&)
 {}
 
 
-void facePointPatch::initUpdateMesh()
+void facePointPatch::initUpdateMesh(PstreamBuffers& pBufs)
 {
-    facePointPatch::initGeometry();
+    facePointPatch::initGeometry(pBufs);
 }
 
 
-void facePointPatch::updateMesh()
+void facePointPatch::updateMesh(PstreamBuffers&)
 {}
 
 

src/OpenFOAM/meshes/pointMesh/pointPatches/facePointPatch/facePointPatch.H

@@ -76,22 +76,22 @@ protected:
     // Protected Member Functions
 
         //- Initialise the calculation of the patch geometry
-        virtual void initGeometry();
+        virtual void initGeometry(PstreamBuffers&);
 
         //- Calculate the patch geometry
-        virtual void calcGeometry();
+        virtual void calcGeometry(PstreamBuffers&);
 
         //- Initialise the patches for moving points
-        virtual void initMovePoints(const pointField&);
+        virtual void initMovePoints(PstreamBuffers&, const pointField&);
 
         //- Correct patches after moving points
-        virtual void movePoints(const pointField&);
+        virtual void movePoints(PstreamBuffers&, const pointField&);
 
         //- Initialise the update of the patch topology
-        virtual void initUpdateMesh();
+        virtual void initUpdateMesh(PstreamBuffers&);
 
         //- Update of the patch topology
-        virtual void updateMesh();
+        virtual void updateMesh(PstreamBuffers&);
 
 
 private:

src/OpenFOAM/meshes/pointMesh/pointPatches/pointPatch/pointPatch.H

@@ -49,6 +49,7 @@ namespace Foam
 
 class pointBoundaryMesh;
 class pointConstraint;
+class PstreamBuffers;
 
 /*---------------------------------------------------------------------------*\
                       Class pointPatch Declaration
@@ -79,27 +80,27 @@ protected:
         friend class pointBoundaryMesh;
 
         //- Initialise the calculation of the patch geometry
-        virtual void initGeometry()
+        virtual void initGeometry(PstreamBuffers&)
         {}
 
         //- Calculate the patch geometry
-        virtual void calcGeometry()
+        virtual void calcGeometry(PstreamBuffers&)
         {}
 
         //- Initialise the patches for moving points
-        virtual void initMovePoints(const pointField&)
+        virtual void initMovePoints(PstreamBuffers&, const pointField&)
         {}
 
         //- Correct patches after moving points
-        virtual void movePoints(const pointField&)
+        virtual void movePoints(PstreamBuffers&, const pointField&)
         {}
 
         //- Initialise the update of the patch topology
-        virtual void initUpdateMesh()
+        virtual void initUpdateMesh(PstreamBuffers&)
         {}
 
         //- Update of the patch topology
-        virtual void updateMesh()
+        virtual void updateMesh(PstreamBuffers&)
         {}
 
 

src/OpenFOAM/meshes/polyMesh/polyBoundaryMesh/polyBoundaryMesh.C

@@ -29,6 +29,9 @@ License
 #include "primitiveMesh.H"
 #include "processorPolyPatch.H"
 #include "stringListOps.H"
+#include "PstreamBuffers.H"
+#include "lduSchedule.H"
+#include "globalMeshData.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
@@ -144,14 +147,46 @@ void Foam::polyBoundaryMesh::clearAddressing()
 
 void Foam::polyBoundaryMesh::calcGeometry()
 {
-    forAll(*this, patchi)
+    PstreamBuffers pBufs(Pstream::defaultCommsType);
-    {
-        operator[](patchi).initGeometry();
-    }
 
-    forAll(*this, patchi)
+    if
+    (
+        Pstream::defaultCommsType == Pstream::blocking
+     || Pstream::defaultCommsType == Pstream::nonBlocking
+    )
     {
-        operator[](patchi).calcGeometry();
+        forAll(*this, patchi)
+        {
+            operator[](patchi).initGeometry(pBufs);
+        }
+
+        pBufs.finishedSends();
+
+        forAll(*this, patchi)
+        {
+            operator[](patchi).calcGeometry(pBufs);
+        }
+    }
+    else if (Pstream::defaultCommsType == Pstream::scheduled)
+    {
+        const lduSchedule& patchSchedule = mesh().globalData().patchSchedule();
+
+        // Dummy.
+        pBufs.finishedSends();
+
+        forAll(patchSchedule, patchEvali)
+        {
+            label patchi = patchSchedule[patchEvali].patch;
+
+            if (patchSchedule[patchEvali].init)
+            {
+                operator[](patchi).initGeometry(pBufs);
+            }
+            else
+            {
+                operator[](patchi).calcGeometry(pBufs);
+            }
+        }
     }
 }
 
@@ -573,16 +608,46 @@ bool Foam::polyBoundaryMesh::checkDefinition(const bool report) const
 
 void Foam::polyBoundaryMesh::movePoints(const pointField& p)
 {
-    polyPatchList& patches = *this;
+    PstreamBuffers pBufs(Pstream::defaultCommsType);
 
-    forAll(patches, patchi)
+    if
+    (
+        Pstream::defaultCommsType == Pstream::blocking
+     || Pstream::defaultCommsType == Pstream::nonBlocking
+    )
     {
-        patches[patchi].initMovePoints(p);
+        forAll(*this, patchi)
+        {
+            operator[](patchi).initMovePoints(pBufs, p);
+        }
+
+        pBufs.finishedSends();
+
+        forAll(*this, patchi)
+        {
+            operator[](patchi).movePoints(pBufs, p);
+        }
     }
-
+    else if (Pstream::defaultCommsType == Pstream::scheduled)
-    forAll(patches, patchi)
     {
-        patches[patchi].movePoints(p);
+        const lduSchedule& patchSchedule = mesh().globalData().patchSchedule();
+
+        // Dummy.
+        pBufs.finishedSends();
+
+        forAll(patchSchedule, patchEvali)
+        {
+            label patchi = patchSchedule[patchEvali].patch;
+
+            if (patchSchedule[patchEvali].init)
+            {
+                operator[](patchi).initMovePoints(pBufs, p);
+            }
+            else
+            {
+                operator[](patchi).movePoints(pBufs, p);
+            }
+        }
     }
 }
 
@@ -591,16 +656,46 @@ void Foam::polyBoundaryMesh::updateMesh()
 {
     deleteDemandDrivenData(neighbourEdgesPtr_);
 
-    polyPatchList& patches = *this;
+    PstreamBuffers pBufs(Pstream::defaultCommsType);
 
-    forAll(patches, patchi)
+    if
+    (
+        Pstream::defaultCommsType == Pstream::blocking
+     || Pstream::defaultCommsType == Pstream::nonBlocking
+    )
     {
-        patches[patchi].initUpdateMesh();
+        forAll(*this, patchi)
+        {
+            operator[](patchi).initUpdateMesh(pBufs);
+        }
+
+        pBufs.finishedSends();
+
+        forAll(*this, patchi)
+        {
+            operator[](patchi).updateMesh(pBufs);
+        }
     }
-
+    else if (Pstream::defaultCommsType == Pstream::scheduled)
-    forAll(patches, patchi)
     {
-        patches[patchi].updateMesh();
+        const lduSchedule& patchSchedule = mesh().globalData().patchSchedule();
+
+        // Dummy.
+        pBufs.finishedSends();
+
+        forAll(patchSchedule, patchEvali)
+        {
+            label patchi = patchSchedule[patchEvali].patch;
+
+            if (patchSchedule[patchEvali].init)
+            {
+                operator[](patchi).initUpdateMesh(pBufs);
+            }
+            else
+            {
+                operator[](patchi).updateMesh(pBufs);
+            }
+        }
     }
 }
 

src/OpenFOAM/meshes/polyMesh/polyBoundaryMesh/polyBoundaryMesh.H

@@ -50,8 +50,6 @@ class polyMesh;
 
 // Forward declaration of friend functions and operators
 
-class polyBoundaryMesh;
-
 Ostream& operator<<(Ostream&, const polyBoundaryMesh&);
 
 

src/OpenFOAM/meshes/polyMesh/polyPatches/basic/coupled/coupledPolyPatch.H

@@ -90,22 +90,22 @@ protected:
         ) const;
 
         //- Initialise the calculation of the patch geometry
-        virtual void initGeometry() = 0;
+        virtual void initGeometry(PstreamBuffers&) = 0;
 
         //- Calculate the patch geometry
-        virtual void calcGeometry() = 0;
+        virtual void calcGeometry(PstreamBuffers&) = 0;
 
         //- Initialise the patches for moving points
-        virtual void initMovePoints(const pointField&) = 0;
+        virtual void initMovePoints(PstreamBuffers&, const pointField&) = 0;
 
         //- Correct patches after moving points
-        virtual void movePoints(const pointField&) = 0;
+        virtual void movePoints(PstreamBuffers&, const pointField&) = 0;
 
         //- Initialise the update of the patch topology
-        virtual void initUpdateMesh() = 0;
+        virtual void initUpdateMesh(PstreamBuffers&) = 0;
 
         //- Update of the patch topology
-        virtual void updateMesh() = 0;
+        virtual void updateMesh(PstreamBuffers&) = 0;
 
 
         //- Write point in OBJ format
@@ -283,7 +283,11 @@ public:
 
         //- Initialize ordering for primitivePatch. Does not
         //  refer to *this (except for name() and type() etc.)
-        virtual void initOrder(const primitivePatch&) const = 0;
+        virtual void initOrder
+        (
+            PstreamBuffers&,
+            const primitivePatch&
+        ) const = 0;
 
         //- Return new ordering for primitivePatch.
         //  Ordering is -faceMap: for every face
@@ -292,6 +296,7 @@ public:
         //  (faceMap is identity, rotation is 0), true otherwise.
         virtual bool order
         (
+            PstreamBuffers&,
             const primitivePatch&,
             labelList& faceMap,
             labelList& rotation

src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/cyclic/cyclicPolyPatch.C

@@ -516,7 +516,8 @@ void Foam::cyclicPolyPatch::getCentresAndAnchors
         //    if (debug)
         //    {
         //        Pout<< "cyclicPolyPatch::getCentresAndAnchors :"
-        //            << "Specified translation : " << separationVector_ << endl;
+        //            << "Specified translation : " << separationVector_
+        //            << endl;
         //    }
         //
         //    half0Ctrs += separationVector_;
@@ -858,36 +859,44 @@ Foam::cyclicPolyPatch::~cyclicPolyPatch()
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
-void Foam::cyclicPolyPatch::initGeometry()
+void Foam::cyclicPolyPatch::initGeometry(PstreamBuffers& pBufs)
 {
-    polyPatch::initGeometry();
+    polyPatch::initGeometry(pBufs);
 }
 
-void Foam::cyclicPolyPatch::calcGeometry()
+void Foam::cyclicPolyPatch::calcGeometry(PstreamBuffers& pBufs)
 {
-    polyPatch::calcGeometry();
+    polyPatch::calcGeometry(pBufs);
     calcTransforms();
 }
 
-void Foam::cyclicPolyPatch::initMovePoints(const pointField& p)
+void Foam::cyclicPolyPatch::initMovePoints
+(
+    PstreamBuffers& pBufs,
+    const pointField& p
+)
 {
-    polyPatch::initMovePoints(p);
+    polyPatch::initMovePoints(pBufs, p);
 }
 
-void Foam::cyclicPolyPatch::movePoints(const pointField& p)
+void Foam::cyclicPolyPatch::movePoints
+(
+    PstreamBuffers& pBufs,
+    const pointField& p
+)
 {
-    polyPatch::movePoints(p);
+    polyPatch::movePoints(pBufs, p);
     calcTransforms();
 }
 
-void Foam::cyclicPolyPatch::initUpdateMesh()
+void Foam::cyclicPolyPatch::initUpdateMesh(PstreamBuffers& pBufs)
 {
-    polyPatch::initUpdateMesh();
+    polyPatch::initUpdateMesh(pBufs);
 }
 
-void Foam::cyclicPolyPatch::updateMesh()
+void Foam::cyclicPolyPatch::updateMesh(PstreamBuffers& pBufs)
 {
-    polyPatch::updateMesh();
+    polyPatch::updateMesh(pBufs);
     deleteDemandDrivenData(coupledPointsPtr_);
     deleteDemandDrivenData(coupledEdgesPtr_);
 }
@@ -1105,7 +1114,11 @@ const Foam::edgeList& Foam::cyclicPolyPatch::coupledEdges() const
 }
 
 
-void Foam::cyclicPolyPatch::initOrder(const primitivePatch& pp) const
+void Foam::cyclicPolyPatch::initOrder
+(
+    PstreamBuffers&,
+    const primitivePatch& pp
+) const
 {}
 
 
@@ -1115,6 +1128,7 @@ void Foam::cyclicPolyPatch::initOrder(const primitivePatch& pp) const
 //  is identity, rotation is 0)
 bool Foam::cyclicPolyPatch::order
 (
+    PstreamBuffers& pBufs,
     const primitivePatch& pp,
     labelList& faceMap,
     labelList& rotation
@@ -1300,7 +1314,8 @@ bool Foam::cyclicPolyPatch::order
                 << endl;
 
             // Recalculate untransformed face centres
-            //pointField rawHalf0Ctrs = calcFaceCentres(half0Faces, pp.points());
+            //pointField rawHalf0Ctrs =
+            //    calcFaceCentres(half0Faces, pp.points());
             label vertI = 0;
 
             forAll(half1Ctrs, i)
@@ -1413,7 +1428,8 @@ bool Foam::cyclicPolyPatch::order
                     << endl;
 
                 // Recalculate untransformed face centres
-                //pointField rawHalf0Ctrs = calcFaceCentres(half0Faces, pp.points());
+                //pointField rawHalf0Ctrs =
+                //    calcFaceCentres(half0Faces, pp.points());
                 label vertI = 0;
 
                 forAll(half1Ctrs, i)
@@ -1499,7 +1515,8 @@ bool Foam::cyclicPolyPatch::order
                 << endl;
 
             // Recalculate untransformed face centres
-            //pointField rawHalf0Ctrs = calcFaceCentres(half0Faces, pp.points());
+            //pointField rawHalf0Ctrs =
+            //    calcFaceCentres(half0Faces, pp.points());
             label vertI = 0;
 
             forAll(half1Ctrs, i)

src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/cyclic/cyclicPolyPatch.H

@@ -176,22 +176,22 @@ protected:
     // Protected Member functions
 
         //- Initialise the calculation of the patch geometry
-        virtual void initGeometry();
+        virtual void initGeometry(PstreamBuffers&);
 
         //- Calculate the patch geometry
-        virtual void calcGeometry();
+        virtual void calcGeometry(PstreamBuffers&);
 
         //- Initialise the patches for moving points
-        virtual void initMovePoints(const pointField&);
+        virtual void initMovePoints(PstreamBuffers&, const pointField&);
 
         //- Correct patches after moving points
-        virtual void movePoints(const pointField&);
+        virtual void movePoints(PstreamBuffers&, const pointField&);
 
         //- Initialise the update of the patch topology
-        virtual void initUpdateMesh();
+        virtual void initUpdateMesh(PstreamBuffers&);
 
         //- Update of the patch topology
-        virtual void updateMesh();
+        virtual void updateMesh(PstreamBuffers&);
 
 public:
 
@@ -391,7 +391,7 @@ public:
 
         //- Initialize ordering for primitivePatch. Does not
         //  refer to *this (except for name() and type() etc.)
-        virtual void initOrder(const primitivePatch&) const;
+        virtual void initOrder(PstreamBuffers&, const primitivePatch&) const;
 
         //- Return new ordering for primitivePatch.
         //  Ordering is -faceMap: for every face
@@ -400,6 +400,7 @@ public:
         //  (faceMap is identity, rotation is 0), true otherwise.
         virtual bool order
         (
+            PstreamBuffers&,
             const primitivePatch&,
             labelList& faceMap,
             labelList& rotation

src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/processor/processorPolyPatch.C

@@ -34,6 +34,7 @@ License
 #include "polyMesh.H"
 #include "Time.H"
 #include "transformList.H"
+#include "PstreamBuffers.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -155,16 +156,11 @@ Foam::processorPolyPatch::~processorPolyPatch()
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
-void Foam::processorPolyPatch::initGeometry()
+void Foam::processorPolyPatch::initGeometry(PstreamBuffers& pBufs)
 {
     if (Pstream::parRun())
     {
-        OPstream toNeighbProc
+        UOPstream toNeighbProc(neighbProcNo(), pBufs);
-        (
-            Pstream::blocking,
-            neighbProcNo(),
-            3*(sizeof(label) + size()*sizeof(vector) + sizeof(scalar))
-        );
 
         toNeighbProc
             << faceCentres()
@@ -174,17 +170,13 @@ void Foam::processorPolyPatch::initGeometry()
 }
 
 
-void Foam::processorPolyPatch::calcGeometry()
+void Foam::processorPolyPatch::calcGeometry(PstreamBuffers& pBufs)
 {
     if (Pstream::parRun())
     {
         {
-            IPstream fromNeighbProc
+            UIPstream fromNeighbProc(neighbProcNo(), pBufs);
-            (
+
-                Pstream::blocking,
-                neighbProcNo(),
-                3*(sizeof(label) + size()*sizeof(vector) + sizeof(scalar))
-            );
             fromNeighbProc
                 >> neighbFaceCentres_
                 >> neighbFaceAreas_
@@ -251,22 +243,30 @@ void Foam::processorPolyPatch::calcGeometry()
 }
 
 
-void Foam::processorPolyPatch::initMovePoints(const pointField& p)
+void Foam::processorPolyPatch::initMovePoints
+(
+    PstreamBuffers& pBufs,
+    const pointField& p
+)
 {
-    polyPatch::movePoints(p);
+    polyPatch::movePoints(pBufs, p);
-    processorPolyPatch::initGeometry();
+    processorPolyPatch::initGeometry(pBufs);
 }
 
 
-void Foam::processorPolyPatch::movePoints(const pointField&)
+void Foam::processorPolyPatch::movePoints
+(
+    PstreamBuffers& pBufs,
+    const pointField&
+)
 {
-    processorPolyPatch::calcGeometry();
+    processorPolyPatch::calcGeometry(pBufs);
 }
 
 
-void Foam::processorPolyPatch::initUpdateMesh()
+void Foam::processorPolyPatch::initUpdateMesh(PstreamBuffers& pBufs)
 {
-    polyPatch::initUpdateMesh();
+    polyPatch::initUpdateMesh(pBufs);
 
     deleteDemandDrivenData(neighbPointsPtr_);
     deleteDemandDrivenData(neighbEdgesPtr_);
@@ -303,14 +303,7 @@ void Foam::processorPolyPatch::initUpdateMesh()
             edgeIndex[patchEdgeI] = findIndex(fEdges, patchEdgeI);
         }
 
-        OPstream toNeighbProc
+        UOPstream toNeighbProc(neighbProcNo(), pBufs);
-        (
-            Pstream::blocking,
-            neighbProcNo(),
-            8*sizeof(label)             // four headers of labelList
-          + 2*nPoints()*sizeof(label)   // two point-based labellists
-          + 2*nEdges()*sizeof(label)    // two edge-based labelLists
-        );
 
         toNeighbProc
             << pointFace
@@ -321,10 +314,10 @@ void Foam::processorPolyPatch::initUpdateMesh()
 }
 
 
-void Foam::processorPolyPatch::updateMesh()
+void Foam::processorPolyPatch::updateMesh(PstreamBuffers& pBufs)
 {
     // For completeness
-    polyPatch::updateMesh();
+    polyPatch::updateMesh(pBufs);
 
     if (Pstream::parRun())
     {
@@ -336,7 +329,7 @@ void Foam::processorPolyPatch::updateMesh()
         {
             // Note cannot predict exact size since opposite nPoints might
             // be different from one over here.
-            IPstream fromNeighbProc(Pstream::blocking, neighbProcNo());
+            UIPstream fromNeighbProc(neighbProcNo(), pBufs);
 
             fromNeighbProc
                 >> nbrPointFace
@@ -446,7 +439,11 @@ const Foam::labelList& Foam::processorPolyPatch::neighbEdges() const
 }
 
 
-void Foam::processorPolyPatch::initOrder(const primitivePatch& pp) const
+void Foam::processorPolyPatch::initOrder
+(
+    PstreamBuffers& pBufs,
+    const primitivePatch& pp
+) const
 {
     if (!Pstream::parRun())
     {
@@ -491,7 +488,7 @@ void Foam::processorPolyPatch::initOrder(const primitivePatch& pp) const
         pointField anchors(getAnchorPoints(pp, pp.points()));
 
         // Now send all info over to the neighbour
-        OPstream toNeighbour(Pstream::blocking, neighbProcNo());
+        UOPstream toNeighbour(neighbProcNo(), pBufs);
         toNeighbour << ctrs << anchors;
     }
 }
@@ -503,6 +500,7 @@ void Foam::processorPolyPatch::initOrder(const primitivePatch& pp) const
 // is identity, rotation is 0)
 bool Foam::processorPolyPatch::order
 (
+    PstreamBuffers& pBufs,
     const primitivePatch& pp,
     labelList& faceMap,
     labelList& rotation
@@ -539,7 +537,7 @@ bool Foam::processorPolyPatch::order
 
         // Receive data from neighbour
         {
-            IPstream fromNeighbour(Pstream::blocking, neighbProcNo());
+            UIPstream fromNeighbour(neighbProcNo(), pBufs);
             fromNeighbour >> masterCtrs >> masterAnchors;
         }
 

src/OpenFOAM/meshes/polyMesh/polyPatches/constraint/processor/processorPolyPatch.H

@@ -28,11 +28,9 @@ Class
 Description
     Neighbour processor patch.
 
-    Note: morph patch face ordering comes geometric or topological.
+    Note: morph patch face ordering tries to do a geometric ordering.
-    Geometric: no cyclics allowed (assumes faces coincident)
+    (assumes faces coincident) Hence will have problems when cyclics
-    Topological: needs unmodified faces on both sides to correspond. Also
+    are present. 
-    needs at least one per connected patch area (so all patch faces can be
-    visited from an unmodified face)
 
 SourceFiles
     processorPolyPatch.C
@@ -97,22 +95,22 @@ protected:
     // Protected Member functions
 
         //- Initialise the calculation of the patch geometry
-        void initGeometry();
+        void initGeometry(PstreamBuffers&);
 
         //- Calculate the patch geometry
-        void calcGeometry();
+        void calcGeometry(PstreamBuffers&);
 
         //- Initialise the patches for moving points
-        void initMovePoints(const pointField&);
+        void initMovePoints(PstreamBuffers&, const pointField&);
 
         //- Correct patches after moving points
-        void movePoints(const pointField&);
+        void movePoints(PstreamBuffers&, const pointField&);
 
         //- Initialise the update of the patch topology
-        virtual void initUpdateMesh();
+        virtual void initUpdateMesh(PstreamBuffers&);
 
         //- Update of the patch topology
-        virtual void updateMesh();
+        virtual void updateMesh(PstreamBuffers&);
 
 
 public:
@@ -283,7 +281,7 @@ public:
 
         //- Initialize ordering for primitivePatch. Does not
         //  refer to *this (except for name() and type() etc.)
-        virtual void initOrder(const primitivePatch&) const;
+        virtual void initOrder(PstreamBuffers&, const primitivePatch&) const;
 
         //- Return new ordering for primitivePatch.
         //  Ordering is -faceMap: for every face
@@ -292,6 +290,7 @@ public:
         //  (faceMap is identity, rotation is 0), true otherwise.
         virtual bool order
         (
+            PstreamBuffers&,
             const primitivePatch&,
             labelList& faceMap,
             labelList& rotation

src/OpenFOAM/meshes/polyMesh/polyPatches/polyPatch/polyPatch.C

@@ -55,12 +55,12 @@ namespace Foam
 
 // * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
 
-void Foam::polyPatch::movePoints(const pointField& p)
+void Foam::polyPatch::movePoints(PstreamBuffers&, const pointField& p)
 {
     primitivePatch::movePoints(p);
 }
 
-void Foam::polyPatch::updateMesh()
+void Foam::polyPatch::updateMesh(PstreamBuffers&)
 {
     clearAddressing();
 }
@@ -334,12 +334,13 @@ void Foam::polyPatch::write(Ostream& os) const
 }
 
 
-void Foam::polyPatch::initOrder(const primitivePatch&) const
+void Foam::polyPatch::initOrder(PstreamBuffers&, const primitivePatch&) const
 {}
 
 
 bool Foam::polyPatch::order
 (
+    PstreamBuffers&,
     const primitivePatch&,
     labelList& faceMap,
     labelList& rotation

src/OpenFOAM/meshes/polyMesh/polyPatches/polyPatch/polyPatch.H

@@ -56,6 +56,7 @@ namespace Foam
 
 class polyBoundaryMesh;
 class polyPatch;
+class PstreamBuffers;
 
 Ostream& operator<<(Ostream&, const polyPatch&);
 
@@ -101,26 +102,26 @@ protected:
         friend class polyBoundaryMesh;
 
         //- Initialise the calculation of the patch geometry
-        virtual void initGeometry()
+        virtual void initGeometry(PstreamBuffers&)
         {}
 
         //- Calculate the patch geometry
-        virtual void calcGeometry()
+        virtual void calcGeometry(PstreamBuffers&)
         {}
 
         //- Initialise the patches for moving points
-        virtual void initMovePoints(const pointField&)
+        virtual void initMovePoints(PstreamBuffers&, const pointField&)
         {}
 
         //- Correct patches after moving points
-        virtual void movePoints(const pointField& p);
+        virtual void movePoints(PstreamBuffers&, const pointField& p);
 
         //- Initialise the update of the patch topology
-        virtual void initUpdateMesh()
+        virtual void initUpdateMesh(PstreamBuffers&)
         {}
 
         //- Update of the patch topology
-        virtual void updateMesh();
+        virtual void updateMesh(PstreamBuffers&);
 
 
 public:
@@ -358,7 +359,7 @@ public:
 
         //- Initialize ordering for primitivePatch. Does not
         //  refer to *this (except for name() and type() etc.)
-        virtual void initOrder(const primitivePatch&) const;
+        virtual void initOrder(PstreamBuffers&, const primitivePatch&) const;
 
         //- Return new ordering for primitivePatch.
         //  Ordering is -faceMap: for every face
@@ -367,6 +368,7 @@ public:
         //  (faceMap is identity, rotation is 0), true otherwise.
         virtual bool order
         (
+            PstreamBuffers&,
             const primitivePatch&,
             labelList& faceMap,
             labelList& rotation

src/OpenFOAM/meshes/primitiveMesh/PrimitivePatch/PrimitivePatch.C

@@ -28,7 +28,6 @@ License
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
-// Construct from components
 template
 <
     class Face,
@@ -36,7 +35,6 @@ template
     class PointField,
     class PointType
 >
-
 Foam::PrimitivePatch<Face, FaceList, PointField, PointType>::
 PrimitivePatch
 (
@@ -60,12 +58,12 @@ PrimitivePatch
     edgeLoopsPtr_(NULL),
     localPointsPtr_(NULL),
     localPointOrderPtr_(NULL),
+    faceCentresPtr_(NULL),
     faceNormalsPtr_(NULL),
     pointNormalsPtr_(NULL)
 {}
 
 
-// Construct from components
 template
 <
     class Face,
@@ -73,7 +71,6 @@ template
     class PointField,
     class PointType
 >
-
 Foam::PrimitivePatch<Face, FaceList, PointField, PointType>::
 PrimitivePatch
 (
@@ -98,12 +95,12 @@ PrimitivePatch
     edgeLoopsPtr_(NULL),
     localPointsPtr_(NULL),
     localPointOrderPtr_(NULL),
+    faceCentresPtr_(NULL),
     faceNormalsPtr_(NULL),
     pointNormalsPtr_(NULL)
 {}
 
 
-// Construct as copy
 template
 <
     class Face,
@@ -111,7 +108,6 @@ template
     class PointField,
     class PointType
 >
-
 Foam::PrimitivePatch<Face, FaceList, PointField, PointType>::
 PrimitivePatch
 (
@@ -135,6 +131,7 @@ PrimitivePatch
     edgeLoopsPtr_(NULL),
     localPointsPtr_(NULL),
     localPointOrderPtr_(NULL),
+    faceCentresPtr_(NULL),
     faceNormalsPtr_(NULL),
     pointNormalsPtr_(NULL)
 {}
@@ -149,8 +146,8 @@ template
     class PointField,
     class PointType
 >
-
+Foam::PrimitivePatch<Face, FaceList, PointField, PointType>::
-Foam::PrimitivePatch<Face, FaceList, PointField, PointType>::~PrimitivePatch()
+~PrimitivePatch()
 {
     clearOut();
 }
@@ -158,7 +155,6 @@ Foam::PrimitivePatch<Face, FaceList, PointField, PointType>::~PrimitivePatch()
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
-// Correct patch after moving points
 template
 <
     class Face,
@@ -166,7 +162,6 @@ template
     class PointField,
     class PointType
 >
-
 void
 Foam::PrimitivePatch<Face, FaceList, PointField, PointType>::
 movePoints
@@ -193,7 +188,6 @@ template
     class PointField,
     class PointType
 >
-
 const Foam::edgeList&
 Foam::PrimitivePatch<Face, FaceList, PointField, PointType>::
 edges() const
@@ -214,7 +208,6 @@ template
     class PointField,
     class PointType
 >
-
 Foam::label
 Foam::PrimitivePatch<Face, FaceList, PointField, PointType>::
 nInternalEdges() const
@@ -235,7 +228,6 @@ template
     class PointField,
     class PointType
 >
-
 const Foam::labelList&
 Foam::PrimitivePatch<Face, FaceList, PointField, PointType>::
 boundaryPoints() const
@@ -256,7 +248,6 @@ template
     class PointField,
     class PointType
 >
-
 const Foam::labelListList&
 Foam::PrimitivePatch<Face, FaceList, PointField, PointType>::
 faceFaces() const
@@ -277,7 +268,6 @@ template
     class PointField,
     class PointType
 >
-
 const Foam::labelListList&
 Foam::PrimitivePatch<Face, FaceList, PointField, PointType>::
 edgeFaces() const
@@ -298,7 +288,6 @@ template
     class PointField,
     class PointType
 >
-
 const Foam::labelListList&
 Foam::PrimitivePatch<Face, FaceList, PointField, PointType>::
 faceEdges() const
@@ -319,7 +308,6 @@ template
     class PointField,
     class PointType
 >
-
 const Foam::labelListList&
 Foam::PrimitivePatch<Face, FaceList, PointField, PointType>::
 pointEdges() const
@@ -340,7 +328,6 @@ template
     class PointField,
     class PointType
 >
-
 const Foam::labelListList&
 Foam::PrimitivePatch<Face, FaceList, PointField, PointType>::
 pointFaces() const
@@ -361,7 +348,6 @@ template
     class PointField,
     class PointType
 >
-
 const Foam::List<Face>&
 Foam::PrimitivePatch<Face, FaceList, PointField, PointType>::
 localFaces() const
@@ -382,7 +368,6 @@ template
     class PointField,
     class PointType
 >
-
 const Foam::labelList&
 Foam::PrimitivePatch<Face, FaceList, PointField, PointType>::
 meshPoints() const
@@ -403,7 +388,6 @@ template
     class PointField,
     class PointType
 >
-
 const Foam::Map<Foam::label>&
 Foam::PrimitivePatch<Face, FaceList, PointField, PointType>::
 meshPointMap() const
@@ -424,7 +408,6 @@ template
     class PointField,
     class PointType
 >
-
 const Foam::Field<PointType>&
 Foam::PrimitivePatch<Face, FaceList, PointField, PointType>::
 localPoints() const
@@ -445,7 +428,6 @@ template
     class PointField,
     class PointType
 >
-
 const Foam::labelList&
 Foam::PrimitivePatch<Face, FaceList, PointField, PointType>::
 localPointOrder() const
@@ -466,7 +448,6 @@ template
     class PointField,
     class PointType
 >
-
 Foam::label
 Foam::PrimitivePatch<Face, FaceList, PointField, PointType>::
 whichPoint
@@ -495,7 +476,26 @@ template
     class PointField,
     class PointType
 >
+const Foam::Field<PointType>&
+Foam::PrimitivePatch<Face, FaceList, PointField, PointType>::
+faceCentres() const
+{
+    if (!faceCentresPtr_)
+    {
+        calcFaceCentres();
+    }
 
+    return *faceCentresPtr_;
+}
+
+
+template
+<
+    class Face,
+    template<class> class FaceList,
+    class PointField,
+    class PointType
+>
 const Foam::Field<PointType>&
 Foam::PrimitivePatch<Face, FaceList, PointField, PointType>::
 faceNormals() const
@@ -516,7 +516,6 @@ template
     class PointField,
     class PointType
 >
-
 const Foam::Field<PointType>&
 Foam::PrimitivePatch<Face, FaceList, PointField, PointType>::
 pointNormals() const
@@ -539,7 +538,6 @@ template
     class PointField,
     class PointType
 >
-
 void
 Foam::PrimitivePatch<Face, FaceList, PointField, PointType>::
 operator=
@@ -552,6 +550,7 @@ operator=
     FaceList<Face>::operator=(pp);
 }
 
+
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 #include "PrimitivePatchAddressing.C"

src/OpenFOAM/meshes/primitiveMesh/PrimitivePatch/PrimitivePatch.H

@@ -166,6 +166,9 @@ private:
         //- Local point order for most efficient search
         mutable labelList* localPointOrderPtr_;
 
+        //- Face centres
+        mutable Field<PointType>* faceCentresPtr_;
+
         //- Face unit normals
         mutable Field<PointType>* faceNormalsPtr_;
 
@@ -205,6 +208,9 @@ private:
         //- Calculate local point order
         void calcLocalPointOrder() const;
 
+        //- Calculate face centres
+        void calcFaceCentres() const;
+
         //- Calculate unit face normals
         void calcFaceNormals() const;
 
@@ -370,6 +376,9 @@ public:
                 const labelListList& pointEdges
             ) const;
 
+            //- Return face centres for patch
+            const Field<PointType>& faceCentres() const;
+
             //- Return face normals for patch
             const Field<PointType>& faceNormals() const;
 

src/OpenFOAM/meshes/primitiveMesh/PrimitivePatch/PrimitivePatchAddressing.C

@@ -48,7 +48,6 @@ template
     class PointField,
     class PointType
 >
-
 void
 Foam::PrimitivePatch<Face, FaceList, PointField, PointType>::
 calcAddressing() const

src/OpenFOAM/meshes/primitiveMesh/PrimitivePatch/PrimitivePatchBdryPoints.C

@@ -22,8 +22,6 @@ License
     along with OpenFOAM; if not, write to the Free Software Foundation,
     Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 
-Description
-
 \*---------------------------------------------------------------------------*/
 
 #include "PrimitivePatch.H"
@@ -39,7 +37,6 @@ template
     class PointField,
     class PointType
 >
-
 void
 Foam::PrimitivePatch<Face, FaceList, PointField, PointType>::
 calcBdryPoints() const

src/OpenFOAM/meshes/primitiveMesh/PrimitivePatch/PrimitivePatchCheck.C

@@ -41,7 +41,6 @@ template
     class PointField,
     class PointType
 >
-
 void
 Foam::PrimitivePatch<Face, FaceList, PointField, PointType>::
 visitPointRegion
@@ -120,7 +119,6 @@ template
     class PointField,
     class PointType
 >
-
 typename Foam::PrimitivePatch<Face, FaceList, PointField, PointType>::surfaceTopo
 Foam::PrimitivePatch<Face, FaceList, PointField, PointType>::
 surfaceType() const
@@ -174,7 +172,6 @@ template
     class PointField,
     class PointType
 >
-
 bool
 Foam::PrimitivePatch<Face, FaceList, PointField, PointType>::
 checkTopology
@@ -245,7 +242,6 @@ template
     class PointField,
     class PointType
 >
-
 bool
 Foam::PrimitivePatch<Face, FaceList, PointField, PointType>::
 checkPointManifold

src/OpenFOAM/meshes/primitiveMesh/PrimitivePatch/PrimitivePatchClear.C

@@ -22,8 +22,6 @@ License
     along with OpenFOAM; if not, write to the Free Software Foundation,
     Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 
-Description
-
 \*---------------------------------------------------------------------------*/
 
 #include "PrimitivePatch.H"
@@ -39,7 +37,6 @@ template
     class PointField,
     class PointType
 >
-
 void
 Foam::PrimitivePatch<Face, FaceList, PointField, PointType>::
 clearGeom()
@@ -52,6 +49,7 @@ clearGeom()
     }
 
     deleteDemandDrivenData(localPointsPtr_);
+    deleteDemandDrivenData(faceCentresPtr_);
     deleteDemandDrivenData(faceNormalsPtr_);
     deleteDemandDrivenData(pointNormalsPtr_);
 }
@@ -64,7 +62,6 @@ template
     class PointField,
     class PointType
 >
-
 void
 Foam::PrimitivePatch<Face, FaceList, PointField, PointType>::
 clearTopology()
@@ -106,7 +103,6 @@ template
     class PointField,
     class PointType
 >
-
 void
 Foam::PrimitivePatch<Face, FaceList, PointField, PointType>::
 clearPatchMeshAddr()
@@ -132,7 +128,6 @@ template
     class PointField,
     class PointType
 >
-
 void
 Foam::PrimitivePatch<Face, FaceList, PointField, PointType>::
 clearOut()

src/OpenFOAM/meshes/primitiveMesh/PrimitivePatch/PrimitivePatchEdgeLoops.C

@@ -31,7 +31,6 @@ Description
 #include "PrimitivePatch.H"
 
 
-
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
 template
@@ -41,7 +40,6 @@ template
     class PointField,
     class PointType
 >
-
 void
 Foam::PrimitivePatch<Face, FaceList, PointField, PointType>::
 calcEdgeLoops() const
@@ -174,7 +172,6 @@ template
     class PointField,
     class PointType
 >
-
 const Foam::labelListList&
 Foam::PrimitivePatch<Face, FaceList, PointField, PointType>::
 edgeLoops() const

src/OpenFOAM/meshes/primitiveMesh/PrimitivePatch/PrimitivePatchLocalPointOrder.C

@@ -39,7 +39,6 @@ template
     class PointField,
     class PointType
 >
-
 void
 Foam::PrimitivePatch<Face, FaceList, PointField, PointType>::
 calcLocalPointOrder() const
@@ -137,4 +136,5 @@ calcLocalPointOrder() const
     }
 }
 
+
 // ************************************************************************* //

src/OpenFOAM/meshes/primitiveMesh/PrimitivePatch/PrimitivePatchMeshData.C

@@ -27,8 +27,6 @@ License
 #include "PrimitivePatch.H"
 #include "Map.H"
 
-
-
 // * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
 
 template
@@ -38,7 +36,6 @@ template
     class PointField,
     class PointType
 >
-
 void
 Foam::PrimitivePatch<Face, FaceList, PointField, PointType>::
 calcMeshData() const
@@ -76,13 +73,13 @@ calcMeshData() const
 
     ////- 1.5 code:
     //// if the point is used, set the mark to 1
-    //forAll (*this, faceI)
+    //forAll(*this, facei)
     //{
-    //    const Face& curPoints = this->operator[](faceI);
+    //    const Face& curPoints = this->operator[](facei);
     //
-    //    forAll (curPoints, pointI)
+    //    forAll(curPoints, pointi)
     //    {
-    //        markedPoints.insert(curPoints[pointI], -1);
+    //        markedPoints.insert(curPoints[pointi], -1);
     //    }
     //}
     //
@@ -95,22 +92,22 @@ calcMeshData() const
     //sort(pointPatch);
     //
     //// For every point in map give it its label in mesh points
-    //forAll (pointPatch, pointI)
+    //forAll(pointPatch, pointi)
     //{
-    //    markedPoints.find(pointPatch[pointI])() = pointI;
+    //    markedPoints.find(pointPatch[pointi])() = pointi;
     //}
 
     //- Unsorted version:
     DynamicList<label> meshPoints(2*this->size());
-    forAll (*this, faceI)
+    forAll(*this, facei)
     {
-        const Face& curPoints = this->operator[](faceI);
+        const Face& curPoints = this->operator[](facei);
 
-        forAll (curPoints, pointI)
+        forAll(curPoints, pointi)
         {
-            if (markedPoints.insert(curPoints[pointI], meshPoints.size()))
+            if (markedPoints.insert(curPoints[pointi], meshPoints.size()))
             {
-                meshPoints.append(curPoints[pointI]);
+                meshPoints.append(curPoints[pointi]);
             }
         }
     }
@@ -124,14 +121,14 @@ calcMeshData() const
     localFacesPtr_ = new List<Face>(*this);
     List<Face>& lf = *localFacesPtr_;
 
-    forAll (*this, faceI)
+    forAll(*this, facei)
     {
-        const Face& curFace = this->operator[](faceI);
+        const Face& curFace = this->operator[](facei);
-        lf[faceI].setSize(curFace.size());
+        lf[facei].setSize(curFace.size());
 
-        forAll (curFace, labelI)
+        forAll(curFace, labelI)
         {
-            lf[faceI][labelI] = markedPoints.find(curFace[labelI])();
+            lf[facei][labelI] = markedPoints.find(curFace[labelI])();
         }
     }
 
@@ -152,7 +149,6 @@ template
     class PointField,
     class PointType
 >
-
 void
 Foam::PrimitivePatch<Face, FaceList, PointField, PointType>::
 calcMeshPointMap() const
@@ -182,7 +178,7 @@ calcMeshPointMap() const
     meshPointMapPtr_ = new Map<label>(2*mp.size());
     Map<label>& mpMap = *meshPointMapPtr_;
 
-    forAll (mp, i)
+    forAll(mp, i)
     {
         mpMap.insert(mp[i], i);
     }
@@ -204,7 +200,6 @@ template
     class PointField,
     class PointType
 >
-
 void
 Foam::PrimitivePatch<Face, FaceList, PointField, PointType>::
 calcLocalPoints() const
@@ -235,9 +230,9 @@ calcLocalPoints() const
 
     Field<PointType>& locPts = *localPointsPtr_;
 
-    forAll (meshPts, pointI)
+    forAll(meshPts, pointi)
     {
-        locPts[pointI] = points_[meshPts[pointI]];
+        locPts[pointi] = points_[meshPts[pointi]];
     }
 
     if (debug)
@@ -257,7 +252,6 @@ template
     class PointField,
     class PointType
 >
-
 void
 Foam::PrimitivePatch<Face, FaceList, PointField, PointType>::
 calcPointNormals() const
@@ -294,15 +288,15 @@ calcPointNormals() const
 
     Field<PointType>& n = *pointNormalsPtr_;
 
-    forAll (pf, pointI)
+    forAll(pf, pointi)
     {
-        PointType& curNormal = n[pointI];
+        PointType& curNormal = n[pointi];
 
-        const labelList& curFaces = pf[pointI];
+        const labelList& curFaces = pf[pointi];
 
-        forAll (curFaces, faceI)
+        forAll(curFaces, facei)
         {
-            curNormal += faceUnitNormals[curFaces[faceI]];
+            curNormal += faceUnitNormals[curFaces[facei]];
         }
 
         curNormal /= mag(curNormal) + VSMALL;
@@ -325,7 +319,56 @@ template
     class PointField,
     class PointType
 >
+void
+Foam::PrimitivePatch<Face, FaceList, PointField, PointType>::
+calcFaceCentres() const
+{
+    if (debug)
+    {
+        Pout<< "PrimitivePatch<Face, FaceList, PointField, PointType>::"
+               "calcFaceCentres() : "
+               "calculating faceCentres in PrimitivePatch"
+            << endl;
+    }
 
+    // It is considered an error to attempt to recalculate faceCentres
+    // if they have already been calculated.
+    if (faceCentresPtr_)
+    {
+        FatalErrorIn
+        (
+            "PrimitivePatch<Face, FaceList, PointField, PointType>::"
+            "calcFaceCentres()"
+        )   << "faceCentresPtr_already allocated"
+            << abort(FatalError);
+    }
+
+    faceCentresPtr_ = new Field<PointType>(this->size());
+
+    Field<PointType>& c = *faceCentresPtr_;
+
+    forAll(c, facei)
+    {
+        c[facei] = this->operator[](facei).centre(points_);
+    }
+
+    if (debug)
+    {
+        Pout<< "PrimitivePatch<Face, FaceList, PointField, PointType>::"
+               "calcFaceCentres() : "
+               "finished calculating faceCentres in PrimitivePatch"
+            << endl;
+    }
+}
+
+
+template
+<
+    class Face,
+    template<class> class FaceList,
+    class PointField,
+    class PointType
+>
 void
 Foam::PrimitivePatch<Face, FaceList, PointField, PointType>::
 calcFaceNormals() const
@@ -354,10 +397,10 @@ calcFaceNormals() const
 
     Field<PointType>& n = *faceNormalsPtr_;
 
-    forAll (n, faceI)
+    forAll(n, facei)
     {
-        n[faceI] = this->operator[](faceI).normal(points_);
+        n[facei] = this->operator[](facei).normal(points_);
-        n[faceI] /= mag(n[faceI]) + VSMALL;
+        n[facei] /= mag(n[facei]) + VSMALL;
     }
 
     if (debug)

src/OpenFOAM/meshes/primitiveMesh/PrimitivePatch/PrimitivePatchMeshEdges.C

@@ -22,8 +22,6 @@ License
     along with OpenFOAM; if not, write to the Free Software Foundation,
     Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
 
-Description
-
 \*---------------------------------------------------------------------------*/
 
 #include "PrimitivePatch.H"
@@ -38,7 +36,6 @@ template
     class PointField,
     class PointType
 >
-
 Foam::labelList
 Foam::PrimitivePatch<Face, FaceList, PointField, PointType>::
 meshEdges
@@ -116,7 +113,6 @@ template
     class PointField,
     class PointType
 >
-
 Foam::labelList
 Foam::PrimitivePatch<Face, FaceList, PointField, PointType>::
 meshEdges
@@ -174,7 +170,6 @@ template
     class PointField,
     class PointType
 >
-
 Foam::label
 Foam::PrimitivePatch<Face, FaceList, PointField, PointType>::
 whichEdge

src/OpenFOAM/meshes/primitiveMesh/PrimitivePatch/PrimitivePatchPointAddressing.C

@@ -40,7 +40,6 @@ template
     class PointField,
     class PointType
 >
-
 void
 Foam::PrimitivePatch<Face, FaceList, PointField, PointType>::
 calcPointEdges() const
@@ -112,7 +111,6 @@ template
     class PointField,
     class PointType
 >
-
 void
 Foam::PrimitivePatch<Face, FaceList, PointField, PointType>::
 calcPointFaces() const

src/OpenFOAM/meshes/primitiveMesh/PrimitivePatch/PrimitivePatchProjectPoints.C

@@ -42,7 +42,6 @@ template
     class PointField,
     class PointType
 >
-
 template <class ToPatch>
 Foam::List<Foam::objectHit>
 Foam::PrimitivePatch<Face, FaceList, PointField, PointType>::
@@ -290,7 +289,6 @@ template
     class PointField,
     class PointType
 >
-
 template <class ToPatch>
 Foam::List<Foam::objectHit>
 Foam::PrimitivePatch<Face, FaceList, PointField, PointType>::

src/dynamicMesh/polyTopoChange/polyTopoChange/polyTopoChange.C

@@ -1844,6 +1844,8 @@ void Foam::polyTopoChange::reorderCoupledFaces
     // Rotation on new faces.
     labelList rotation(faces_.size(), 0);
 
+    PstreamBuffers pBufs(Pstream::nonBlocking);
+
     // Send ordering
     forAll(boundary, patchI)
     {
@@ -1851,6 +1853,7 @@ void Foam::polyTopoChange::reorderCoupledFaces
         {
             boundary[patchI].initOrder
             (
+                pBufs,
                 primitivePatch
                 (
                     SubList<face>
@@ -1865,6 +1868,8 @@ void Foam::polyTopoChange::reorderCoupledFaces
         }
     }
 
+    pBufs.finishedSends();
+
     // Receive and calculate ordering
 
     bool anyChanged = false;
@@ -1878,6 +1883,7 @@ void Foam::polyTopoChange::reorderCoupledFaces
 
             bool changed = boundary[patchI].order
             (
+                pBufs,
                 primitivePatch
                 (
                     SubList<face>

src/fvMotionSolver/pointPatchFields/derived/angularOscillatingDisplacement/angularOscillatingDisplacementPointPatchVectorField.C

@@ -100,7 +100,7 @@ angularOscillatingDisplacementPointPatchVectorField
     angle0_(ptf.angle0_),
     amplitude_(ptf.amplitude_),
     omega_(ptf.omega_),
-    p0_(ptf.p0_)
+    p0_(ptf.p0_, mapper)
 {}
 
 

src/fvMotionSolver/pointPatchFields/derived/oscillatingVelocity/oscillatingVelocityPointPatchVectorField.C

@@ -91,7 +91,7 @@ oscillatingVelocityPointPatchVectorField
     fixedValuePointPatchField<vector>(ptf, p, iF, mapper),
     amplitude_(ptf.amplitude_),
     omega_(ptf.omega_),
-    p0_(ptf.p0_)
+    p0_(ptf.p0_, mapper)
 {}
 
 

src/fvMotionSolver/pointPatchFields/derived/sixDoFRigidBodyDisplacement/sixDoFRigidBodyDisplacementPointPatchVectorField.C

@@ -93,7 +93,7 @@ sixDoFRigidBodyDisplacementPointPatchVectorField
 :
     fixedValuePointPatchField<vector>(ptf, p, iF, mapper),
     motion_(ptf.motion_),
-    p0_(ptf.p0_),
+    p0_(ptf.p0_, mapper),
     rhoInf_(ptf.rhoInf_)
 {}
 

src/lagrangian/basic/Cloud/Cloud.C

@@ -105,20 +105,15 @@ void Foam::Cloud<ParticleType>::move(TrackingData& td)
     const globalMeshData& pData = polyMesh_.globalData();
     const labelList& processorPatches = pData.processorPatches();
     const labelList& processorPatchIndices = pData.processorPatchIndices();
-    const labelList& processorPatchNeighbours =
-        pData.processorPatchNeighbours();
 
-    // Initialise the setpFraction moved for the particles
+    // Initialise the stepFraction moved for the particles
     forAllIter(typename Cloud<ParticleType>, *this, pIter)
     {
         pIter().stepFraction() = 0;
     }
 
-    // Assume there will be particles to transfer
-    bool transfered = true;
-
     // While there are particles to transfer
-    while (transfered)
+    while (true)
     {
         // List of lists of particles to be transfered for all the processor
         // patches
@@ -158,104 +153,93 @@ void Foam::Cloud<ParticleType>::move(TrackingData& td)
             }
         }
 
-        if (Pstream::parRun())
+        if (!Pstream::parRun())
         {
-            // List of the numbers of particles to be transfered across the
+            break;
-            // processor patches
+        }
-            labelList nsTransPs(transferList.size());
 
-            forAll(transferList, i)
+
+        // Allocate transfer buffers
+        PstreamBuffers pBufs(Pstream::nonBlocking);
+
+        // Stream into send buffers
+        forAll(transferList, i)
+        {
+            if (transferList[i].size())
             {
-                nsTransPs[i] = transferList[i].size();
+                UOPstream particleStream
-            }
+                (
-
-            // List of the numbers of particles to be transfered across the
-            // processor patches for all the processors
-            labelListList allNTrans(Pstream::nProcs());
-            allNTrans[Pstream::myProcNo()] = nsTransPs;
-            combineReduce(allNTrans, UPstream::listEq());
-
-            transfered = false;
-
-            forAll(allNTrans, i)
-            {
-                forAll(allNTrans[i], j)
-                {
-                    if (allNTrans[i][j])
-                    {
-                        transfered = true;
-                        break;
-                    }
-                }
-            }
-
-            if (!transfered)
-            {
-                break;
-            }
-
-            forAll(transferList, i)
-            {
-                if (transferList[i].size())
-                {
-                    OPstream particleStream
-                    (
-                        Pstream::blocking,
-                        refCast<const processorPolyPatch>
-                        (
-                            pMesh().boundaryMesh()[processorPatches[i]]
-                        ).neighbProcNo()
-                    );
-
-                    particleStream << transferList[i];
-                }
-            }
-
-            forAll(processorPatches, i)
-            {
-                label patchi = processorPatches[i];
-
-                const processorPolyPatch& procPatch =
                     refCast<const processorPolyPatch>
-                    (pMesh().boundaryMesh()[patchi]);
+                    (
+                        pMesh().boundaryMesh()[processorPatches[i]]
+                    ).neighbProcNo(),
+                    pBufs
+                );
 
-                label neighbProci =
+                particleStream << transferList[i];
-                    procPatch.neighbProcNo() - Pstream::masterNo();
+            }
+        }
 
-                label neighbProcPatchi = processorPatchNeighbours[patchi];
+        // Set up transfers when in non-blocking mode. Returns sizes (in bytes)
+        // to be sent/received.
+        labelListList allNTrans(Pstream::nProcs());
+        pBufs.finishedSends(allNTrans);
 
-                label nRecPs = allNTrans[neighbProci][neighbProcPatchi];
+        bool transfered = false;
 
-                if (nRecPs)
+        forAll(allNTrans, i)
+        {
+            forAll(allNTrans[i], j)
+            {
+                if (allNTrans[i][j])
                 {
-                    IPstream particleStream
+                    transfered = true;
-                    (
+                    break;
-                        Pstream::blocking,
-                        procPatch.neighbProcNo()
-                    );
-                    IDLList<ParticleType> newParticles
-                    (
-                        particleStream,
-                        typename ParticleType::iNew(*this)
-                    );
-
-                    forAllIter
-                    (
-                        typename Cloud<ParticleType>,
-                        newParticles,
-                        newpIter
-                    )
-                    {
-                        ParticleType& newp = newpIter();
-                        newp.correctAfterParallelTransfer(patchi, td);
-                        addParticle(newParticles.remove(&newp));
-                    }
                 }
             }
         }
-        else
+
+        if (!transfered)
         {
-            transfered = false;
+            break;
+        }
+
+
+        // Retrieve from receive buffers
+        forAll(processorPatches, i)
+        {
+            label patchi = processorPatches[i];
+
+            const processorPolyPatch& procPatch =
+                refCast<const processorPolyPatch>
+                (pMesh().boundaryMesh()[patchi]);
+
+            label neighbProci = procPatch.neighbProcNo();
+
+            label nRecPs = allNTrans[neighbProci][Pstream::myProcNo()];
+
+            if (nRecPs)
+            {
+                UIPstream particleStream(neighbProci, pBufs);
+
+                IDLList<ParticleType> newParticles
+                (
+                    particleStream,
+                    typename ParticleType::iNew(*this)
+                );
+
+                forAllIter
+                (
+                    typename Cloud<ParticleType>,
+                    newParticles,
+                    newpIter
+                )
+                {
+                    ParticleType& newp = newpIter();
+                    newp.correctAfterParallelTransfer(patchi, td);
+                    addParticle(newParticles.remove(&newp));
+                }
+            }
         }
     }
 }

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

@@ -2411,6 +2411,9 @@ Foam::autoPtr<Foam::mapPolyMesh> Foam::meshRefinement::zonify
     }
     syncTools::swapBoundaryFaceList(mesh_, neiCellZone, false);
 
+    // Get per face whether is it master (of a coupled set of faces)
+    PackedBoolList isMasterFace(syncTools::getMasterFaces(mesh_));
+
     // Set owner as no-flip
     forAll(patches, patchI)
     {
@@ -2428,14 +2431,27 @@ Foam::autoPtr<Foam::mapPolyMesh> Foam::meshRefinement::zonify
                 label neiZone = neiCellZone[faceI-mesh_.nInternalFaces()];
 
                 bool flip;
-                if (ownZone == max(ownZone, neiZone))
+
+                label maxZone = max(ownZone, neiZone);
+
+                if (maxZone == -1)
                 {
                     flip = false;
                 }
-                else
+                else if (ownZone == neiZone)
+                {
+                    // Can only happen for coupled boundaries. Keep master
+                    // face unflipped.
+                    flip = !isMasterFace[faceI];
+                }
+                else if (neiZone == maxZone)
                 {
                     flip = true;
                 }
+                else
+                {
+                    flip = false;
+                }
 
                 meshMod.setAction
                 (

src/meshTools/directMapped/directMappedPolyPatch/directMappedPolyPatch.C

@@ -145,44 +145,49 @@ Foam::directMappedPolyPatch::~directMappedPolyPatch()
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
 //- Initialise the calculation of the patch geometry
-void Foam::directMappedPolyPatch::initGeometry()
+void Foam::directMappedPolyPatch::initGeometry(PstreamBuffers& pBufs)
 {
-    polyPatch::initGeometry();
+    polyPatch::initGeometry(pBufs);
-    directMappedPatchBase::clearOut();
 }
 
 //- Calculate the patch geometry
-void Foam::directMappedPolyPatch::calcGeometry()
+void Foam::directMappedPolyPatch::calcGeometry(PstreamBuffers& pBufs)
 {
-    polyPatch::calcGeometry();
+    polyPatch::calcGeometry(pBufs);
     directMappedPatchBase::clearOut();
 }
 
 //- Initialise the patches for moving points
-void Foam::directMappedPolyPatch::initMovePoints(const pointField& p)
+void Foam::directMappedPolyPatch::initMovePoints
+(
+    PstreamBuffers& pBufs,
+    const pointField& p
+)
 {
-    polyPatch::initMovePoints(p);
+    polyPatch::initMovePoints(pBufs, p);
-    directMappedPatchBase::clearOut();
 }
 
 //- Correct patches after moving points
-void Foam::directMappedPolyPatch::movePoints(const pointField& p)
+void Foam::directMappedPolyPatch::movePoints
+(
+    PstreamBuffers& pBufs,
+    const pointField& p
+)
 {
-    polyPatch::movePoints(p);
+    polyPatch::movePoints(pBufs, p);
     directMappedPatchBase::clearOut();
 }
 
 //- Initialise the update of the patch topology
-void Foam::directMappedPolyPatch::initUpdateMesh()
+void Foam::directMappedPolyPatch::initUpdateMesh(PstreamBuffers& pBufs)
 {
-    polyPatch::initUpdateMesh();
+    polyPatch::initUpdateMesh(pBufs);
-    directMappedPatchBase::clearOut();
 }
 
 //- Update of the patch topology
-void Foam::directMappedPolyPatch::updateMesh()
+void Foam::directMappedPolyPatch::updateMesh(PstreamBuffers& pBufs)
 {
-    polyPatch::updateMesh();
+    polyPatch::updateMesh(pBufs);
     directMappedPatchBase::clearOut();
 }
 

src/meshTools/directMapped/directMappedPolyPatch/directMappedPolyPatch.H

@@ -65,22 +65,22 @@ class directMappedPolyPatch
 protected:
 
         //- Initialise the calculation of the patch geometry
-        virtual void initGeometry();
+        virtual void initGeometry(PstreamBuffers&);
 
         //- Calculate the patch geometry
-        virtual void calcGeometry();
+        virtual void calcGeometry(PstreamBuffers&);
 
         //- Initialise the patches for moving points
-        virtual void initMovePoints(const pointField&);
+        virtual void initMovePoints(PstreamBuffers&, const pointField&);
 
         //- Correct patches after moving points
-        virtual void movePoints(const pointField&);
+        virtual void movePoints(PstreamBuffers&, const pointField&);
 
         //- Initialise the update of the patch topology
-        virtual void initUpdateMesh();
+        virtual void initUpdateMesh(PstreamBuffers&);
 
         //- Update of the patch topology
-        virtual void updateMesh();
+        virtual void updateMesh(PstreamBuffers&);
 
 
 public:

src/meshTools/directMapped/directMappedPolyPatch/directMappedWallPolyPatch.C

@@ -150,44 +150,49 @@ Foam::directMappedWallPolyPatch::~directMappedWallPolyPatch()
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
 //- Initialise the calculation of the patch geometry
-void Foam::directMappedWallPolyPatch::initGeometry()
+void Foam::directMappedWallPolyPatch::initGeometry(PstreamBuffers& pBufs)
 {
-    wallPolyPatch::initGeometry();
+    wallPolyPatch::initGeometry(pBufs);
-    directMappedPatchBase::clearOut();
 }
 
 //- Calculate the patch geometry
-void Foam::directMappedWallPolyPatch::calcGeometry()
+void Foam::directMappedWallPolyPatch::calcGeometry(PstreamBuffers& pBufs)
 {
-    wallPolyPatch::calcGeometry();
+    wallPolyPatch::calcGeometry(pBufs);
     directMappedPatchBase::clearOut();
 }
 
 //- Initialise the patches for moving points
-void Foam::directMappedWallPolyPatch::initMovePoints(const pointField& p)
+void Foam::directMappedWallPolyPatch::initMovePoints
+(
+    PstreamBuffers& pBufs,
+    const pointField& p
+)
 {
-    wallPolyPatch::initMovePoints(p);
+    wallPolyPatch::initMovePoints(pBufs, p);
-    directMappedPatchBase::clearOut();
 }
 
 //- Correct patches after moving points
-void Foam::directMappedWallPolyPatch::movePoints(const pointField& p)
+void Foam::directMappedWallPolyPatch::movePoints
+(
+    PstreamBuffers& pBufs,
+    const pointField& p
+)
 {
-    wallPolyPatch::movePoints(p);
+    wallPolyPatch::movePoints(pBufs, p);
     directMappedPatchBase::clearOut();
 }
 
 //- Initialise the update of the patch topology
-void Foam::directMappedWallPolyPatch::initUpdateMesh()
+void Foam::directMappedWallPolyPatch::initUpdateMesh(PstreamBuffers& pBufs)
 {
-    wallPolyPatch::initUpdateMesh();
+    wallPolyPatch::initUpdateMesh(pBufs);
-    directMappedPatchBase::clearOut();
 }
 
 //- Update of the patch topology
-void Foam::directMappedWallPolyPatch::updateMesh()
+void Foam::directMappedWallPolyPatch::updateMesh(PstreamBuffers& pBufs)
 {
-    wallPolyPatch::updateMesh();
+    wallPolyPatch::updateMesh(pBufs);
     directMappedPatchBase::clearOut();
 }
 

src/meshTools/directMapped/directMappedPolyPatch/directMappedWallPolyPatch.H

@@ -65,22 +65,22 @@ class directMappedWallPolyPatch
 protected:
 
         //- Initialise the calculation of the patch geometry
-        virtual void initGeometry();
+        virtual void initGeometry(PstreamBuffers&);
 
         //- Calculate the patch geometry
-        virtual void calcGeometry();
+        virtual void calcGeometry(PstreamBuffers&);
 
         //- Initialise the patches for moving points
-        virtual void initMovePoints(const pointField&);
+        virtual void initMovePoints(PstreamBuffers&, const pointField&);
 
         //- Correct patches after moving points
-        virtual void movePoints(const pointField&);
+        virtual void movePoints(PstreamBuffers&, const pointField&);
 
         //- Initialise the update of the patch topology
-        virtual void initUpdateMesh();
+        virtual void initUpdateMesh(PstreamBuffers&);
 
         //- Update of the patch topology
-        virtual void updateMesh();
+        virtual void updateMesh(PstreamBuffers&);
 
 
 public:

src/postProcessing/functionObjects/field/fieldValues/cellSource/cellSource.C

@@ -117,45 +117,6 @@ void Foam::fieldValues::cellSource::initialise()
 }
 
 
-void Foam::fieldValues::cellSource::makeFile()
-{
-    // Create the forces file if not already created
-    if (outputFilePtr_.empty())
-    {
-        if (debug)
-        {
-            Info<< "Creating output file." << endl;
-        }
-
-        // File update
-        if (Pstream::master())
-        {
-            fileName outputDir;
-            if (Pstream::parRun())
-            {
-                // Put in undecomposed case (Note: gives problems for
-                // distributed data running)
-                outputDir =
-                    obr_.time().path()/".."/name_/obr_.time().timeName();
-            }
-            else
-            {
-                outputDir = obr_.time().path()/name_/obr_.time().timeName();
-            }
-
-            // Create directory if does not exist
-            mkDir(outputDir);
-
-            // Open new file at start up
-            outputFilePtr_.reset(new OFstream(outputDir/(type() + ".dat")));
-
-            // Add headers to output data
-            writeFileHeader();
-        }
-    }
-}
-
-
 void Foam::fieldValues::cellSource::writeFileHeader()
 {
     if (outputFilePtr_.valid())
@@ -190,16 +151,9 @@ Foam::fieldValues::cellSource::cellSource
     fieldValue(name, obr, dict, loadFromFiles),
     source_(sourceTypeNames_.read(dict.lookup("source"))),
     operation_(operationTypeNames_.read(dict.lookup("operation"))),
-    cellId_(),
+    cellId_()
-    outputFilePtr_(NULL)
 {
-    initialise();
+    read(dict);
-
-    if (active_)
-    {
-        // Create the output file if not already created
-        makeFile();
-    }
 }
 
 
@@ -213,9 +167,11 @@ Foam::fieldValues::cellSource::~cellSource()
 
 void Foam::fieldValues::cellSource::read(const dictionary& dict)
 {
+    fieldValue::read(dict);
+
     if (active_)
     {
-        fieldValue::read(dict);
+        // no additional info to read
         initialise();
     }
 }
@@ -223,13 +179,10 @@ void Foam::fieldValues::cellSource::read(const dictionary& dict)
 
 void Foam::fieldValues::cellSource::write()
 {
+    fieldValue::write();
+
     if (active_)
     {
-        if (log_)
-        {
-            Info<< type() << " " << name_ << " output:" << nl;
-        }
-
         outputFilePtr_()
             << obr_.time().value() << tab
             << sum(filterField(mesh().V()));

src/postProcessing/functionObjects/field/fieldValues/cellSource/cellSource.H

@@ -58,7 +58,6 @@ SourceFiles
 #include "NamedEnum.H"
 #include "fieldValue.H"
 #include "labelList.H"
-#include "OFstream.H"
 #include "volFieldsFwd.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@@ -114,9 +113,6 @@ private:
         //- Set cells to evaluate based on a patch
         void setPatchCells();
 
-        //- Create the output file if not already created
-        void makeFile();
-
 
 protected:
 
@@ -131,9 +127,6 @@ protected:
         //- Local list of cell IDs
         labelList cellId_;
 
-        //- Output file pointer
-        autoPtr<OFstream> outputFilePtr_;
-
 
     // Protected member functions
 

src/postProcessing/functionObjects/field/fieldValues/faceSource/faceSource.C

@@ -258,45 +258,6 @@ void Foam::fieldValues::faceSource::initialise(const dictionary& dict)
 }
 
 
-void Foam::fieldValues::faceSource::makeFile()
-{
-    // Create the forces file if not already created
-    if (outputFilePtr_.empty())
-    {
-        if (debug)
-        {
-            Info<< "Creating output file." << endl;
-        }
-
-        // File update
-        if (Pstream::master())
-        {
-            fileName outputDir;
-            if (Pstream::parRun())
-            {
-                // Put in undecomposed case (Note: gives problems for
-                // distributed data running)
-                outputDir =
-                    obr_.time().path()/".."/name_/obr_.time().timeName();
-            }
-            else
-            {
-                outputDir = obr_.time().path()/name_/obr_.time().timeName();
-            }
-
-            // Create directory if does not exist
-            mkDir(outputDir);
-
-            // Open new file at start up
-            outputFilePtr_.reset(new OFstream(outputDir/(type() + ".dat")));
-
-            // Add headers to output data
-            writeFileHeader();
-        }
-    }
-}
-
-
 void Foam::fieldValues::faceSource::writeFileHeader()
 {
     if (outputFilePtr_.valid())
@@ -334,16 +295,9 @@ Foam::fieldValues::faceSource::faceSource
     faceId_(),
     facePatchId_(),
     flipMap_(),
-    outputFilePtr_(NULL),
     weightFieldName_("undefinedWeightedFieldName")
 {
-    if (active_)
+    read(dict);
-    {
-        initialise(dict);
-
-        // Create the output file if not already created
-        makeFile();
-    }
 }
 
 
@@ -357,9 +311,10 @@ Foam::fieldValues::faceSource::~faceSource()
 
 void Foam::fieldValues::faceSource::read(const dictionary& dict)
 {
+    fieldValue::read(dict);
+
     if (active_)
     {
-        fieldValue::read(dict);
         initialise(dict);
     }
 }
@@ -367,13 +322,10 @@ void Foam::fieldValues::faceSource::read(const dictionary& dict)
 
 void Foam::fieldValues::faceSource::write()
 {
+    fieldValue::write();
+
     if (active_)
     {
-        if (log_)
-        {
-            Info<< type() << " " << name_ << " output:" << nl;
-        }
-
         outputFilePtr_()
             << obr_.time().value() << tab
             << sum(filterField(mesh().magSf()));

src/postProcessing/functionObjects/field/fieldValues/faceSource/faceSource.H

@@ -66,7 +66,6 @@ SourceFiles
 #include "NamedEnum.H"
 #include "fieldValue.H"
 #include "labelList.H"
-#include "OFstream.H"
 #include "surfaceFieldsFwd.H"
 #include "volFieldsFwd.H"
 
@@ -125,9 +124,6 @@ private:
         //- Set faces to evaluate based on a patch
         void setPatchFaces();
 
-        //- Create the output file if not already created
-        void makeFile();
-
 
 protected:
 
@@ -148,9 +144,6 @@ protected:
         //- List of +1/-1 representing face flip map
         labelList flipMap_;
 
-        //- Output file pointer
-        autoPtr<OFstream> outputFilePtr_;
-
         //- Weight field name - only used for opWeightedAverage mode
         word weightFieldName_;
 

src/postProcessing/functionObjects/field/fieldValues/fieldValue/fieldValue.C

@@ -26,6 +26,7 @@ License
 
 #include "fieldValue.H"
 #include "fvMesh.H"
+#include "Time.H"
 
 // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
@@ -54,6 +55,73 @@ void Foam::fieldValue::movePoints(const Field<point>&)
 }
 
 
+void Foam::fieldValue::makeFile()
+{
+    // Create the forces file if not already created
+    if (outputFilePtr_.empty())
+    {
+        if (debug)
+        {
+            Info<< "Creating output file." << endl;
+        }
+
+        // File update
+        if (Pstream::master())
+        {
+            fileName outputDir;
+            word startTimeName =
+                obr_.time().timeName(obr_.time().startTime().value());
+
+            if (Pstream::parRun())
+            {
+                // Put in undecomposed case (Note: gives problems for
+                // distributed data running)
+                outputDir =
+                    obr_.time().path()/".."/name_/startTimeName;
+            }
+            else
+            {
+                outputDir = obr_.time().path()/name_/startTimeName;
+            }
+
+            // Create directory if does not exist
+            mkDir(outputDir);
+
+            // Open new file at start up
+            outputFilePtr_.reset(new OFstream(outputDir/(type() + ".dat")));
+
+            // Add headers to output data
+            writeFileHeader();
+        }
+    }
+}
+
+
+void Foam::fieldValue::read(const dictionary& dict)
+{
+    if (active_)
+    {
+        log_ = dict.lookupOrDefault<Switch>("log", false);
+        dict.lookup("fields") >> fields_;
+        dict.lookup("valueOutput") >> valueOutput_;
+    }
+}
+
+
+void Foam::fieldValue::write()
+{
+    if (active_)
+    {
+        if (log_)
+        {
+            Info<< type() << " " << name_ << " output:" << nl;
+        }
+
+        makeFile();
+    }
+}
+
+
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
 Foam::fieldValue::fieldValue
@@ -70,7 +138,8 @@ Foam::fieldValue::fieldValue
     log_(false),
     sourceName_(dict.lookup("sourceName")),
     fields_(dict.lookup("fields")),
-    valueOutput_(dict.lookup("valueOutput"))
+    valueOutput_(dict.lookup("valueOutput")),
+    outputFilePtr_(NULL)
 {
     // Only active if obr is an fvMesh
     if (isA<fvMesh>(obr_))
@@ -103,65 +172,6 @@ Foam::fieldValue::~fieldValue()
 
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
-const Foam::word& Foam::fieldValue::name() const
-{
-    return name_;
-}
-
-
-const Foam::objectRegistry& Foam::fieldValue::obr() const
-{
-    return obr_;
-}
-
-
-bool Foam::fieldValue::active() const
-{
-    return active_;
-}
-
-
-const Foam::Switch& Foam::fieldValue::log() const
-{
-    return log_;
-}
-
-
-const Foam::word& Foam::fieldValue::sourceName() const
-{
-    return sourceName_;
-}
-
-
-const Foam::wordList& Foam::fieldValue::fields() const
-{
-    return fields_;
-}
-
-
-const Foam::Switch& Foam::fieldValue::valueOutput() const
-{
-    return valueOutput_;
-}
-
-
-const Foam::fvMesh& Foam::fieldValue::mesh() const
-{
-    return refCast<const fvMesh>(obr_);
-}
-
-
-void Foam::fieldValue::read(const dictionary& dict)
-{
-    if (active_)
-    {
-        log_ = dict.lookupOrDefault<Switch>("log", false);
-        dict.lookup("fields") >> fields_;
-        dict.lookup("valueOutput") >> valueOutput_;
-    }
-}
-
-
 void Foam::fieldValue::execute()
 {
     // Do nothing

src/postProcessing/functionObjects/field/fieldValues/fieldValue/fieldValue.H

@@ -38,6 +38,7 @@ SourceFiles
 
 #include "Switch.H"
 #include "pointFieldFwd.H"
+#include "OFstream.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -82,9 +83,18 @@ protected:
         //- Output field values flag
         Switch valueOutput_;
 
+        //- Output file pointer
+        autoPtr<OFstream> outputFilePtr_;
+
 
         // Functions to be over-ridden from IOoutputFilter class
 
+            //- Make the output file
+            virtual void makeFile();
+
+            //- Write the output file header
+            virtual void writeFileHeader() = 0;
+
             //- Update mesh
             virtual void updateMesh(const mapPolyMesh&);
 
@@ -117,28 +127,28 @@ public:
         // Access
 
             //- Return the name of the geometric source
-            const word& name() const;
+            inline const word& name() const;
 
             //- Return the reference to the object registry
-            const objectRegistry& obr() const;
+            inline const objectRegistry& obr() const;
 
             //- Return the active flag
-            bool active() const;
+            inline bool active() const;
 
             //- Return the switch to send output to Info as well as to file
-            const Switch& log() const;
+            inline const Switch& log() const;
 
             //- Return the source name
-            const word& sourceName() const;
+            inline const word& sourceName() const;
 
             //- Return the list of field names
-            const wordList& fields() const;
+            inline const wordList& fields() const;
 
             //- Return the output field values flag
-            const Switch& valueOutput() const;
+            inline const Switch& valueOutput() const;
 
             //- Helper function to return the reference to the mesh
-            const fvMesh& mesh() const;
+            inline const fvMesh& mesh() const;
 
 
         // Function object functions
@@ -146,6 +156,9 @@ public:
             //- Read from dictionary
             virtual void read(const dictionary& dict);
 
+            //- Write to screen/file
+            virtual void write();
+
             //- Execute
             virtual void execute();
 
@@ -160,6 +173,10 @@ public:
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
+#include "fieldValueI.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
 #endif
 
 // ************************************************************************* //

src/postProcessing/functionObjects/field/fieldValues/fieldValue/fieldValueI.H

@@ -0,0 +1,79 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2009-2009 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+\*---------------------------------------------------------------------------*/
+
+#include "fieldValue.H"
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+inline const Foam::word& Foam::fieldValue::name() const
+{
+    return name_;
+}
+
+
+inline const Foam::objectRegistry& Foam::fieldValue::obr() const
+{
+    return obr_;
+}
+
+
+inline bool Foam::fieldValue::active() const
+{
+    return active_;
+}
+
+
+inline const Foam::Switch& Foam::fieldValue::log() const
+{
+    return log_;
+}
+
+
+inline const Foam::word& Foam::fieldValue::sourceName() const
+{
+    return sourceName_;
+}
+
+
+inline const Foam::wordList& Foam::fieldValue::fields() const
+{
+    return fields_;
+}
+
+
+inline const Foam::Switch& Foam::fieldValue::valueOutput() const
+{
+    return valueOutput_;
+}
+
+
+inline const Foam::fvMesh& Foam::fieldValue::mesh() const
+{
+    return refCast<const fvMesh>(obr_);
+}
+
+
+// ************************************************************************* //

src/postProcessing/functionObjects/forces/forces/forces.H

@@ -160,6 +160,9 @@ protected:
         //- If the forces file has not been created create it
         void makeFile();
 
+        //- Output file header information
+        virtual void writeFileHeader();
+
         //- Return the effective viscous stress (laminar + turbulent).
         tmp<volSymmTensorField> devRhoReff() const;
 
@@ -176,9 +179,6 @@ protected:
         //- Disallow default bitwise assignment
         void operator=(const forces&);
 
-        //- Output file header information
-        virtual void writeFileHeader();
-
 
 public:
 

src/postProcessing/functionObjects/utilities/Make/files

@@ -7,4 +7,7 @@ staticPressure/staticPressureFunctionObject.C
 dsmcFields/dsmcFields.C
 dsmcFields/dsmcFieldsFunctionObject.C
 
+timeActivatedFileUpdate/timeActivatedFileUpdate.C
+timeActivatedFileUpdate/timeActivatedFileUpdateFunctionObject.C
+
 LIB = $(FOAM_LIBBIN)/libutilityFunctionObjects

src/postProcessing/functionObjects/utilities/dsmcFields/dsmcFields.C

@@ -62,7 +62,12 @@ Foam::dsmcFields::dsmcFields
         WarningIn
         (
             "dsmcFields::dsmcFields"
-            "(const objectRegistry&, const dictionary&)"
+            "("
+                "const word&, "
+                "const objectRegistry&, "
+                "const dictionary&, "
+                "const bool"
+            ")"
         )   << "No fvMesh available, deactivating." << nl
             << endl;
     }

src/postProcessing/functionObjects/utilities/staticPressure/staticPressure.C

@@ -68,7 +68,12 @@ Foam::staticPressure::staticPressure
         WarningIn
         (
             "staticPressure::staticPressure"
-            "(const objectRegistry&, const dictionary&)"
+            "("
+                "const word&, "
+                "const objectRegistry&, "
+                "const dictionary&, "
+                "const bool"
+            ")"
         )   << "No fvMesh available, deactivating." << nl
             << endl;
     }
@@ -81,7 +86,12 @@ Foam::staticPressure::staticPressure
             WarningIn
             (
                 "staticPressure::staticPressure"
-                "(const objectRegistry&, const dictionary&)"
+                "("
+                    "const word&, "
+                    "const objectRegistry&, "
+                    "const dictionary&, "
+                    "const bool"
+                ")"
             )   << "Pressure is not kinematic pressure, deactivating." << nl
                 << endl;
         }

src/postProcessing/functionObjects/utilities/timeActivatedFileUpdate/IOtimeActivatedFileUpdate.H

@@ -0,0 +1,50 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2009-2009 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Typedef
+    Foam::IOtimeActivatedFileUpdate
+
+Description
+    Instance of the generic IOOutputFilter for timeActivatedFileUpdate.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef IOtimeActivatedFileUpdate_H
+#define IOtimeActivatedFileUpdate_H
+
+#include "timeActivatedFileUpdate.H"
+#include "IOOutputFilter.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    typedef IOOutputFilter<timeActivatedFileUpdate> IOtimeActivatedFileUpdate;
+}
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/postProcessing/functionObjects/utilities/timeActivatedFileUpdate/controlDict

@@ -0,0 +1,67 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  1.6                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    location    "system";
+    object      controlDict;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+application     icoFoam;
+
+startFrom       startTime;
+
+startTime       0;
+
+stopAt          endTime;
+
+endTime         0.5;
+
+deltaT          0.005;
+
+writeControl    timeStep;
+
+writeInterval   20;
+
+purgeWrite      0;
+
+writeFormat     ascii;
+
+writePrecision  6;
+
+writeCompression uncompressed;
+
+timeFormat      general;
+
+timePrecision   6;
+
+runTimeModifiable yes;
+
+functions
+{
+    fileUpdate1
+    {
+        type              timeActivatedFileUpdate;
+        functionObjectLibs ("libutilityFunctionObjects.so");
+        outputControl     timeStep;
+        outputInterval    1;
+        fileToUpdate      "$FOAM_CASE/system/fvSolution";
+        timeVsFile
+        (
+            (-1 "$FOAM_CASE/system/fvSolution.0")
+            (0.10 "$FOAM_CASE/system/fvSolution.10")
+            (0.20 "$FOAM_CASE/system/fvSolution.20")
+            (0.35 "$FOAM_CASE/system/fvSolution.35")
+        );
+    }
+}
+
+// ************************************************************************* //

src/postProcessing/functionObjects/utilities/timeActivatedFileUpdate/timeActivatedFileUpdate.C

@@ -0,0 +1,146 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2009-2009 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+\*---------------------------------------------------------------------------*/
+
+#include "timeActivatedFileUpdate.H"
+#include "objectRegistry.H"
+#include "Time.H"
+#include "dictionary.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineTypeNameAndDebug(timeActivatedFileUpdate, 0);
+}
+
+
+// * * * * * * * * * * * * * Private Member Functions  * * * * * * * * * * * //
+
+void Foam::timeActivatedFileUpdate::updateFile()
+{
+    label i = lastIndex_;
+    while
+    (
+        i < timeVsFile_.size()-1
+     && timeVsFile_[i+1].first() < obr_.time().value()
+    )
+    {
+        i++;
+    }
+
+    if (i > lastIndex_)
+    {
+        Info<< nl << type() << ": copying file" << nl << timeVsFile_[i].second()
+            << nl << "to:" << nl << fileToUpdate_ << nl << endl;
+
+        cp(timeVsFile_[i].second(), fileToUpdate_);
+        lastIndex_ = i;
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::timeActivatedFileUpdate::timeActivatedFileUpdate
+(
+    const word& name,
+    const objectRegistry& obr,
+    const dictionary& dict,
+    const bool loadFromFiles
+)
+:
+    name_(name),
+    obr_(obr),
+    active_(true),
+    fileToUpdate_(dict.lookup("fileToUpdate")),
+    timeVsFile_(),
+    lastIndex_(-1)
+{
+    read(dict);
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::timeActivatedFileUpdate::~timeActivatedFileUpdate()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+void Foam::timeActivatedFileUpdate::read(const dictionary& dict)
+{
+    if (active_)
+    {
+        dict.lookup("fileToUpdate") >> fileToUpdate_;
+        dict.lookup("timeVsFile") >> timeVsFile_;
+
+        lastIndex_ = -1;
+        fileToUpdate_.expand();
+
+        Info<< type() << ": time vs file list:" << nl;
+        forAll(timeVsFile_, i)
+        {
+            timeVsFile_[i].second() = timeVsFile_[i].second().expand();
+            if (!isFile(timeVsFile_[i].second()))
+            {
+                FatalErrorIn("timeActivatedFileUpdate::read(const dictionary&)")
+                    << "File: " << timeVsFile_[i].second() << " not found"
+                    << nl << exit(FatalError);
+            }
+
+            Info<< "    " << timeVsFile_[i].first() << tab
+                << timeVsFile_[i].second() << endl;
+        }
+        Info<< endl;
+
+        updateFile();
+    }
+}
+
+
+void Foam::timeActivatedFileUpdate::execute()
+{
+    if (active_)
+    {
+        updateFile();
+    }
+}
+
+
+void Foam::timeActivatedFileUpdate::end()
+{
+    // Do nothing
+}
+
+
+void Foam::timeActivatedFileUpdate::write()
+{
+    // Do nothing
+}
+
+
+// ************************************************************************* //

src/postProcessing/functionObjects/utilities/timeActivatedFileUpdate/timeActivatedFileUpdate.H

@@ -0,0 +1,173 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2009-2009 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Class
+    Foam::timeActivatedFileUpdate
+
+Description
+    Performs a file copy/replacement once a specified time has been reached.
+
+    Example usage to update the fvSolution dictionary at various times
+    throughout the calculation:
+
+        fileUpdate1
+        {
+            type              timeActivatedFileUpdate;
+            functionObjectLibs ("libutilityFunctionObjects.so");
+            outputControl     timeStep;
+            outputInterval    1;
+            fileToUpdate      "$FOAM_CASE/system/fvSolution";
+            timeVsFile
+            (
+                (-1 "$FOAM_CASE/system/fvSolution.0")
+                (0.10 "$FOAM_CASE/system/fvSolution.10")
+                (0.20 "$FOAM_CASE/system/fvSolution.20")
+                (0.35 "$FOAM_CASE/system/fvSolution.35")
+            );
+        }
+
+
+SourceFiles
+    timeActivatedFileUpdate.C
+    IOtimeActivatedFileUpdate.H
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef timeActivatedFileUpdate_H
+#define timeActivatedFileUpdate_H
+
+#include "pointFieldFwd.H"
+#include "Tuple2.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// Forward declaration of classes
+class objectRegistry;
+class dictionary;
+class mapPolyMesh;
+
+/*---------------------------------------------------------------------------*\
+                  Class timeActivatedFileUpdate Declaration
+\*---------------------------------------------------------------------------*/
+
+class timeActivatedFileUpdate
+{
+    // Private data
+
+        //- Name of this set of timeActivatedFileUpdate objects
+        word name_;
+
+        //- Owner database
+        const objectRegistry& obr_;
+
+        //- On/off switch
+        bool active_;
+
+        //- Name of file to update
+        fileName fileToUpdate_;
+
+        //- List of times vs filenames
+        List<Tuple2<scalar, fileName> > timeVsFile_;
+
+        //- Index of last file copied
+        label lastIndex_;
+
+
+    // Private Member Functions
+
+        //- Update file
+        void updateFile();
+
+        //- Disallow default bitwise copy construct
+        timeActivatedFileUpdate(const timeActivatedFileUpdate&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const timeActivatedFileUpdate&);
+
+
+public:
+
+    //- Runtime type information
+    TypeName("timeActivatedFileUpdate");
+
+
+    // Constructors
+
+        //- Construct for given objectRegistry and dictionary.
+        //  Allow the possibility to load fields from files
+        timeActivatedFileUpdate
+        (
+            const word& name,
+            const objectRegistry&,
+            const dictionary&,
+            const bool loadFromFiles = false
+        );
+
+
+    //- Destructor
+    virtual ~timeActivatedFileUpdate();
+
+
+    // Member Functions
+
+        //- Return name of the set of timeActivatedFileUpdate
+        virtual const word& name() const
+        {
+            return name_;
+        }
+
+        //- Read the timeActivatedFileUpdate data
+        virtual void read(const dictionary&);
+
+        //- Execute, currently does nothing
+        virtual void execute();
+
+        //- Execute at the final time-loop, currently does nothing
+        virtual void end();
+
+        //- Calculate the timeActivatedFileUpdate and write
+        virtual void write();
+
+        //- Update for changes of mesh
+        virtual void updateMesh(const mapPolyMesh&)
+        {}
+
+        //- Update for changes of mesh
+        virtual void movePoints(const pointField&)
+        {}
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/postProcessing/functionObjects/utilities/timeActivatedFileUpdate/timeActivatedFileUpdateFunctionObject.C

@@ -0,0 +1,47 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2009-2009 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+\*---------------------------------------------------------------------------*/
+
+#include "timeActivatedFileUpdateFunctionObject.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    defineNamedTemplateTypeNameAndDebug
+    (
+        timeActivatedFileUpdateFunctionObject,
+        0
+    );
+
+    addToRunTimeSelectionTable
+    (
+        functionObject,
+        timeActivatedFileUpdateFunctionObject,
+        dictionary
+    );
+}
+
+// ************************************************************************* //

src/postProcessing/functionObjects/utilities/timeActivatedFileUpdate/timeActivatedFileUpdateFunctionObject.H

@@ -0,0 +1,55 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2009-2009 OpenCFD Ltd.
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software; you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by the
+    Free Software Foundation; either version 2 of the License, or (at your
+    option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM; if not, write to the Free Software Foundation,
+    Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Typedef
+    Foam::timeActivatedFileUpdateFunctionObject
+
+Description
+    FunctionObject wrapper around timeActivatedFileUpdate to allow it to be
+    created via the functions list within controlDict.
+
+SourceFiles
+    timeActivatedFileUpdateFunctionObject.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef timeActivatedFileUpdateFunctionObject_H
+#define timeActivatedFileUpdateFunctionObject_H
+
+#include "timeActivatedFileUpdate.H"
+#include "OutputFilterFunctionObject.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+    typedef OutputFilterFunctionObject<timeActivatedFileUpdate>
+        timeActivatedFileUpdateFunctionObject;
+}
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/sampling/cuttingPlane/cuttingPlane.C

@@ -258,6 +258,7 @@ bool Foam::cuttingPlane::walkCell
 void Foam::cuttingPlane::walkCellCuts
 (
     const primitiveMesh& mesh,
+    const bool triangulate,
     const UList<label>& edgePoint
 )
 {
@@ -293,7 +294,7 @@ void Foam::cuttingPlane::walkCellCuts
         // Check for the unexpected ...
         if (startEdgeI == -1)
         {
-            FatalErrorIn("Foam::cuttingPlane::walkCellCuts")
+            FatalErrorIn("Foam::cuttingPlane::walkCellCuts(..)")
                 << "Cannot find cut edge for cut cell " << cellI
                 << abort(FatalError);
         }
@@ -318,10 +319,18 @@ void Foam::cuttingPlane::walkCellCuts
                 f = f.reverseFace();
             }
 
-            // the cut faces are usually quite ugly, so always triangulate
+            // the cut faces are usually quite ugly, so optionally triangulate
-            label nTri = f.triangles(cutPoints, dynCutFaces);
+            if (triangulate)
-            while (nTri--)
             {
+                label nTri = f.triangles(cutPoints, dynCutFaces);
+                while (nTri--)
+                {
+                    dynCutCells.append(cellI);
+                }
+            }
+            else
+            {
+                dynCutFaces.append(f);
                 dynCutCells.append(cellI);
             }
         }
@@ -346,12 +355,13 @@ Foam::cuttingPlane::cuttingPlane
 (
     const plane& pln,
     const primitiveMesh& mesh,
+    const bool triangulate,
     const UList<label>& cellIdLabels
 )
 :
     plane(pln)
 {
-    reCut(mesh, cellIdLabels);
+    reCut(mesh, triangulate, cellIdLabels);
 }
 
 
@@ -362,6 +372,7 @@ Foam::cuttingPlane::cuttingPlane
 void Foam::cuttingPlane::reCut
 (
     const primitiveMesh& mesh,
+    const bool triangulate,
     const UList<label>& cellIdLabels
 )
 {
@@ -379,7 +390,7 @@ void Foam::cuttingPlane::reCut
     intersectEdges(mesh, dotProducts, edgePoint);
 
     // Do topological walk around cell to find closed loop.
-    walkCellCuts(mesh, edgePoint);
+    walkCellCuts(mesh, triangulate, edgePoint);
 }
 
 

src/sampling/cuttingPlane/cuttingPlane.H

@@ -105,6 +105,7 @@ class cuttingPlane
         void walkCellCuts
         (
             const primitiveMesh& mesh,
+            const bool triangulate,
             const UList<label>& edgePoint
         );
 
@@ -122,6 +123,7 @@ protected:
         void reCut
         (
             const primitiveMesh&,
+            const bool triangulate,
             const UList<label>& cellIdLabels = UList<label>::null()
         );
 
@@ -138,6 +140,7 @@ public:
         (
             const plane&,
             const primitiveMesh&,
+            const bool triangulate,
             const UList<label>& cellIdLabels = UList<label>::null()
         );
 

src/sampling/sampledSurface/sampledPlane/sampledPlane.C

@@ -150,11 +150,11 @@ bool Foam::sampledPlane::update()
 
     if (zoneId < 0)
     {
-        reCut(mesh());
+        reCut(mesh(), true);    // always triangulate. Note:Make option?
     }
     else
     {
-        reCut(mesh(), mesh().cellZones()[zoneId]);
+        reCut(mesh(), true, mesh().cellZones()[zoneId]);
     }
 
     if (debug)

src/thermophysicalModels/specie/reaction/reactions/makeReactionThermo.H

@@ -30,7 +30,7 @@ Description
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef makeReactionTherno_H
+#ifndef makeReactionThermo_H
 #define makeReactionThermo_H
 
 #include "Reaction.H"

src/turbulenceModels/compressible/RAS/derivedFvPatchFields/turbulentTemperatureCoupledBaffle/turbulentTemperatureCoupledBaffleFvPatchScalarField.H

@@ -97,7 +97,7 @@ class turbulentTemperatureCoupledBaffleFvPatchScalarField
 public:
 
     //- Runtime type information
-    TypeName("turbulentTemperatureCoupledBaffle");
+    TypeName("compressible::turbulentTemperatureCoupledBaffle");
 
 
     // Constructors

src/turbulenceModels/incompressible/LES/Smagorinsky/Smagorinsky.C

@@ -73,6 +73,8 @@ Smagorinsky::Smagorinsky
     )
 {
     updateSubGridScaleFields(fvc::grad(U));
+
+    printCoeffs();
 }
 
 

tutorials/incompressible/simpleFoam/pitzDaily/constant/polyMesh/boundary

@@ -1,7 +1,7 @@
 /*--------------------------------*- C++ -*----------------------------------*\
 | =========                 |                                                 |
 | \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
-|  \\    /   O peration     | Version:  1.6                                   |
+|  \\    /   O peration     | Version:  dev                                   |
 |   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
 |    \\/     M anipulation  |                                                 |
 \*---------------------------------------------------------------------------*/

tutorials/lagrangian/rhoPisoTwinParcelFoam/simplifiedSiwek/system/decomposeParDict

@@ -34,7 +34,7 @@ hierarchicalCoeffs
 
 metisCoeffs
 {
-    processorWeights ( 1 1 1 1 );
+    //processorWeights ( 1 1 1 1 );
 }
 
 manualCoeffs