Merge branch 'master' of /home/dm4/OpenFOAM/OpenFOAM-dev

src/OpenFOAM/db/IOobjects/IOdictionary/IOdictionaryIO.C

@@ -105,6 +105,7 @@ void Foam::IOdictionary::readFile(const bool masterOnly)
                 myComm.above(),
                 0,
                 Pstream::msgType(),
+                Pstream::worldComm,
                 IOstream::ASCII
             );
             IOdictionary::readData(fromAbove);
@@ -124,6 +125,7 @@ void Foam::IOdictionary::readFile(const bool masterOnly)
                 myComm.below()[belowI],
                 0,
                 Pstream::msgType(),
+                Pstream::worldComm,
                 IOstream::ASCII
             );
             IOdictionary::writeData(toBelow);

src/OpenFOAM/db/regIOobject/regIOobjectRead.C

@@ -243,6 +243,7 @@ bool Foam::regIOobject::read()
                 myComm.above(),
                 0,
                 Pstream::msgType(),
+                Pstream::worldComm,
                 IOstream::ASCII
             );
             ok = readData(fromAbove);
@@ -257,6 +258,7 @@ bool Foam::regIOobject::read()
                 myComm.below()[belowI],
                 0,
                 Pstream::msgType(),
+                Pstream::worldComm,
                 IOstream::ASCII
             );
             writeData(toBelow);

src/OpenFOAM/fields/Fields/Field/Field.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -677,7 +677,6 @@ template<class Type>
 template<class Form, class Cmpt, int nCmpt>
 void Foam::Field<Type>::operator=(const VectorSpace<Form,Cmpt,nCmpt>& vs)
 {
-    typedef VectorSpace<Form,Cmpt,nCmpt> VSType;
     TFOR_ALL_F_OP_S(Type, *this, =, VSType, vs)
 }
 

src/OpenFOAM/fields/pointPatchFields/constraint/processorCyclic/processorCyclicPointPatchField.C

@@ -122,7 +122,8 @@ void Foam::processorCyclicPointPatchField<Type>::initSwapAddSeparated
                 procPatch_.neighbProcNo(),
                 reinterpret_cast<char*>(receiveBuf_.begin()),
                 receiveBuf_.byteSize(),
-                procPatch_.tag()
+                procPatch_.tag(),
+                procPatch_.comm()
             );
         }
         OPstream::write
@@ -131,7 +132,8 @@ void Foam::processorCyclicPointPatchField<Type>::initSwapAddSeparated
             procPatch_.neighbProcNo(),
             reinterpret_cast<const char*>(pf.begin()),
             pf.byteSize(),
-            procPatch_.tag()
+            procPatch_.tag(),
+            procPatch_.comm()
         );
     }
 }
@@ -156,7 +158,8 @@ void Foam::processorCyclicPointPatchField<Type>::swapAddSeparated
                 procPatch_.neighbProcNo(),
                 reinterpret_cast<char*>(receiveBuf_.begin()),
                 receiveBuf_.byteSize(),
-                procPatch_.tag()
+                procPatch_.tag(),
+                procPatch_.comm()
             );
         }
 

src/OpenFOAM/global/argList/argList.C

@@ -373,7 +373,8 @@ Foam::argList::argList
     int& argc,
     char**& argv,
     bool checkArgs,
-    bool checkOpts
+    bool checkOpts,
+    const bool initialise
 )
 :
     args_(argc),
@@ -405,12 +406,12 @@ Foam::argList::argList
 
     // Check arguments and options, we already have argv[0]
     int nArgs = 1;
-    string argListString = args_[0];
+    argListStr_ = args_[0];
 
     for (int argI = 1; argI < args_.size(); ++argI)
     {
-        argListString += ' ';
-        argListString += args_[argI];
+        argListStr_ += ' ';
+        argListStr_ += args_[argI];
 
         if (args_[argI][0] == '-')
         {
@@ -438,8 +439,8 @@ Foam::argList::argList
                     FatalError.exit();
                 }
 
-                argListString += ' ';
-                argListString += args_[argI];
+                argListStr_ += ' ';
+                argListStr_ += args_[argI];
                 options_.insert(optionName, args_[argI]);
             }
             else
@@ -459,6 +460,39 @@ Foam::argList::argList
 
     args_.setSize(nArgs);
 
+    parse(checkArgs, checkOpts, initialise);
+}
+
+
+Foam::argList::argList
+(
+    const argList& args,
+    const HashTable<string>& options,
+    bool checkArgs,
+    bool checkOpts,
+    bool initialise
+)
+:
+    args_(args.args_),
+    options_(options),
+    executable_(args.executable_),
+    rootPath_(args.rootPath_),
+    globalCase_(args.globalCase_),
+    case_(args.case_),
+    argListStr_(args.argListStr_),
+    parRunControl_(args.parRunControl_)
+{
+    parse(checkArgs, checkOpts, initialise);
+}
+
+
+void Foam::argList::parse
+(
+    bool checkArgs,
+    bool checkOpts,
+    bool initialise
+)
+{
     // Help/documentation options:
     //   -help    print the usage
     //   -doc     display application documentation in browser
@@ -495,42 +529,44 @@ Foam::argList::argList
     }
 
 
-    string dateString = clock::date();
-    string timeString = clock::clockTime();
-
-    // Print the banner once only for parallel runs
-    if (Pstream::master() && bannerEnabled)
+    if (initialise)
     {
-        IOobject::writeBanner(Info, true)
-            << "Build  : " << Foam::FOAMbuild << nl
-            << "Exec   : " << argListString.c_str() << nl
-            << "Date   : " << dateString.c_str() << nl
-            << "Time   : " << timeString.c_str() << nl
-            << "Host   : " << hostName() << nl
-            << "PID    : " << pid() << endl;
-    }
+        string dateString = clock::date();
+        string timeString = clock::clockTime();
 
-    jobInfo.add("startDate", dateString);
-    jobInfo.add("startTime", timeString);
-    jobInfo.add("userName", userName());
-    jobInfo.add("foamVersion", word(FOAMversion));
-    jobInfo.add("code", executable_);
-    jobInfo.add("argList", argListString);
-    jobInfo.add("currentDir", cwd());
-    jobInfo.add("PPID", ppid());
-    jobInfo.add("PGID", pgid());
-
-    // add build information - only use the first word
-    {
-        std::string build(Foam::FOAMbuild);
-        std::string::size_type found = build.find(' ');
-        if (found != std::string::npos)
+        // Print the banner once only for parallel runs
+        if (Pstream::master() && bannerEnabled)
         {
-            build.resize(found);
+            IOobject::writeBanner(Info, true)
+                << "Build  : " << Foam::FOAMbuild << nl
+                << "Exec   : " << argListStr_.c_str() << nl
+                << "Date   : " << dateString.c_str() << nl
+                << "Time   : " << timeString.c_str() << nl
+                << "Host   : " << hostName() << nl
+                << "PID    : " << pid() << endl;
         }
-        jobInfo.add("foamBuild", build);
-    }
 
+        jobInfo.add("startDate", dateString);
+        jobInfo.add("startTime", timeString);
+        jobInfo.add("userName", userName());
+        jobInfo.add("foamVersion", word(FOAMversion));
+        jobInfo.add("code", executable_);
+        jobInfo.add("argList", argListStr_);
+        jobInfo.add("currentDir", cwd());
+        jobInfo.add("PPID", ppid());
+        jobInfo.add("PGID", pgid());
+
+        // add build information - only use the first word
+        {
+            std::string build(Foam::FOAMbuild);
+            std::string::size_type found = build.find(' ');
+            if (found != std::string::npos)
+            {
+                build.resize(found);
+            }
+            jobInfo.add("foamBuild", build);
+        }
+    }
 
     // Case is a single processor run unless it is running parallel
     int nProcs = 1;
@@ -781,51 +817,55 @@ Foam::argList::argList
         }
     }
 
-    jobInfo.add("root", rootPath_);
-    jobInfo.add("case", globalCase_);
-    jobInfo.add("nProcs", nProcs);
-    if (slaveProcs.size())
+    if (initialise)
     {
-        jobInfo.add("slaves", slaveProcs);
-    }
-    if (roots.size())
-    {
-        jobInfo.add("roots", roots);
-    }
-    jobInfo.write();
-
-    // Switch on signal trapping. We have to wait until after Pstream::init
-    // since this sets up its own ones.
-    sigFpe_.set(bannerEnabled);
-    sigInt_.set(bannerEnabled);
-    sigQuit_.set(bannerEnabled);
-    sigSegv_.set(bannerEnabled);
-
-    if (bannerEnabled)
-    {
-        Info<< "fileModificationChecking : "
-            << "Monitoring run-time modified files using "
-            << regIOobject::fileCheckTypesNames
-                [
-                    regIOobject::fileModificationChecking
-                ]
-            << endl;
-
-        Info<< "allowSystemOperations : ";
-        if (dynamicCode::allowSystemOperations)
+        jobInfo.add("root", rootPath_);
+        jobInfo.add("case", globalCase_);
+        jobInfo.add("nProcs", nProcs);
+        if (slaveProcs.size())
         {
-            Info<< "Allowing user-supplied system call operations" << endl;
+            jobInfo.add("slaves", slaveProcs);
         }
-        else
+        if (roots.size())
         {
-            Info<< "Disallowing user-supplied system call operations" << endl;
+            jobInfo.add("roots", roots);
         }
-    }
+        jobInfo.write();
 
-    if (Pstream::master() && bannerEnabled)
-    {
-        Info<< endl;
-        IOobject::writeDivider(Info);
+        // Switch on signal trapping. We have to wait until after Pstream::init
+        // since this sets up its own ones.
+        sigFpe_.set(bannerEnabled);
+        sigInt_.set(bannerEnabled);
+        sigQuit_.set(bannerEnabled);
+        sigSegv_.set(bannerEnabled);
+
+        if (bannerEnabled)
+        {
+            Info<< "fileModificationChecking : "
+                << "Monitoring run-time modified files using "
+                << regIOobject::fileCheckTypesNames
+                    [
+                        regIOobject::fileModificationChecking
+                    ]
+                << endl;
+
+            Info<< "allowSystemOperations : ";
+            if (dynamicCode::allowSystemOperations)
+            {
+                Info<< "Allowing user-supplied system call operations" << endl;
+            }
+            else
+            {
+                Info<< "Disallowing user-supplied system call operations"
+                    << endl;
+            }
+        }
+
+        if (Pstream::master() && bannerEnabled)
+        {
+            Info<< endl;
+            IOobject::writeDivider(Info);
+        }
     }
 }
 

src/OpenFOAM/global/argList/argList.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -41,7 +41,7 @@ Description
 
     \par Default command-line options
     \param -case \<dir\> \n
-        select an case directory instead of the current working directory
+        select a case directory instead of the current working directory
     \param -parallel \n
         specify case as a parallel job
     \param -doc \n
@@ -69,6 +69,7 @@ Note
 
 SourceFiles
     argList.C
+    argListI.H
 
 \*---------------------------------------------------------------------------*/
 
@@ -111,6 +112,7 @@ class argList
         fileName rootPath_;
         fileName globalCase_;
         fileName case_;
+        string argListStr_;
 
         ParRunControl parRunControl_;
 
@@ -186,17 +188,37 @@ public:
         (
             int& argc,
             char**& argv,
-            bool checkArgs=true,
-            bool checkOpts=true
+            bool checkArgs = true,
+            bool checkOpts = true,
+            bool initialise = true
+        );
+
+        //- Construct copy with new options
+        argList
+        (
+            const argList& args,
+            const HashTable<string>& options,
+            bool checkArgs = true,
+            bool checkOpts = true,
+            bool initialise = true
         );
 
 
-        //- Destructor
-        virtual ~argList();
+    //- Destructor
+    virtual ~argList();
 
 
     // Member functions
 
+        //- Parse
+        void parse
+        (
+            bool checkArgs,
+            bool checkOpts,
+            bool initialise
+        );
+
+
         // Access
 
             //- Name of executable without the path
@@ -211,12 +233,18 @@ public:
             //- Return case name
             inline const fileName& globalCaseName() const;
 
+            //- Return parRunControl
+            inline const ParRunControl& parRunControl() const;
+
             //- Return the path to the caseName
             inline fileName path() const;
 
             //- Return arguments
             inline const stringList& args() const;
 
+            //- Return non-const access to arguments
+            inline stringList& args();
+
             //- Return the argument corresponding to index.
             inline const string& arg(const label index) const;
 
@@ -240,6 +268,9 @@ public:
             //- Return options
             inline const Foam::HashTable<string>& options() const;
 
+            //- Return non-const access to options
+            inline Foam::HashTable<string>& options();
+
             //- Return the argument string associated with the named option
             inline const string& option(const word& opt) const;
 
@@ -295,6 +326,7 @@ public:
             //  \sa option()
             inline const string& operator[](const word& opt) const;
 
+
         // Edit
 
             //- Add to a bool option to validOptions with usage information

src/OpenFOAM/global/argList/argListI.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -51,6 +51,12 @@ inline const Foam::fileName& Foam::argList::globalCaseName() const
 }
 
 
+inline const Foam::ParRunControl& Foam::argList::parRunControl() const
+{
+    return parRunControl_;
+}
+
+
 inline Foam::fileName Foam::argList::path() const
 {
     return rootPath()/caseName();
@@ -63,6 +69,12 @@ inline const Foam::stringList& Foam::argList::args() const
 }
 
 
+inline Foam::stringList& Foam::argList::args()
+{
+    return args_;
+}
+
+
 inline const Foam::string& Foam::argList::arg(const label index) const
 {
     return args_[index];
@@ -81,6 +93,12 @@ inline const Foam::HashTable<Foam::string>& Foam::argList::options() const
 }
 
 
+inline Foam::HashTable<Foam::string>& Foam::argList::options()
+{
+    return options_;
+}
+
+
 inline const Foam::string& Foam::argList::option(const word& opt) const
 {
     return options_[opt];

src/OpenFOAM/meshes/lduMesh/lduPrimitiveMesh.C

@@ -122,7 +122,7 @@ void Foam::lduPrimitiveMesh::checkUpperTriangular
 }
 
 
-Foam::label Foam::lduPrimitiveMesh::size
+Foam::label Foam::lduPrimitiveMesh::totalSize
 (
     const PtrList<lduPrimitiveMesh>& meshes
 )
@@ -294,7 +294,7 @@ Foam::lduPrimitiveMesh::lduPrimitiveMesh
     labelListListList& boundaryFaceMap
 )
 :
-    lduAddressing(myMesh.lduAddr().size() + size(otherMeshes)),
+    lduAddressing(myMesh.lduAddr().size() + totalSize(otherMeshes)),
     lowerAddr_(0),
     upperAddr_(0),
     interfaces_(0),

src/OpenFOAM/meshes/lduMesh/lduPrimitiveMesh.H

@@ -76,7 +76,7 @@ class lduPrimitiveMesh
     // Private Member Functions
 
         //- Get size of all meshes
-        static label size(const PtrList<lduPrimitiveMesh>&);
+        static label totalSize(const PtrList<lduPrimitiveMesh>&);
 
         static labelList upperTriOrder
         (

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

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -134,6 +134,12 @@ public:
             return procPolyPatch_.tag();
         }
 
+        //- Return communicator used for communication
+        virtual label comm() const
+        {
+            return procPolyPatch_.comm();
+        }
+
         //- Return the constraint type this pointPatch implements.
         virtual const word& constraintType() const
         {

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

@@ -246,14 +246,6 @@ public:
             }
         }
 
-
-        //- Return communicator used for communication
-        label comm() const
-        {
-            //return comm_;
-            return boundaryMesh().mesh().comm();
-        }
-
         //- Return processor number
         int myProcNo() const
         {
@@ -266,30 +258,6 @@ public:
             return neighbProcNo_;
         }
 
-
-        // For testing
-
-//            //- Return communicator used for communication
-//            label& comm()
-//            {
-//                return comm_;
-//            }
-
-            //- Return processor number
-            int& myProcNo()
-            {
-                return myProcNo_;
-            }
-
-            //- Return neigbour processor number
-            int& neighbProcNo()
-            {
-                return neighbProcNo_;
-            }
-
-
-
-
         //- Does the processor own the patch ?
         virtual bool owner() const
         {
@@ -332,6 +300,12 @@ public:
             return Pstream::msgType();
         }
 
+        //- Return communicator used for communication
+        virtual label comm() const
+        {
+            return boundaryMesh().mesh().comm();
+        }
+
         //- Transform a patch-based position from other side to this side
         virtual void transformPosition(pointField& l) const
         {}

src/dynamicMesh/polyMeshAdder/faceCoupleInfo.C

@@ -1542,7 +1542,7 @@ void Foam::faceCoupleInfo::perfectPointMatch
         )   << "Did not match all of the master faces to the slave faces"
             << endl
             << "This usually means that the slave patch and master patch"
-            << " do not align to within " << absTol << " meter."
+            << " do not align to within " << absTol << " metre."
             << abort(FatalError);
     }
 

src/dynamicMesh/polyMeshFilter/polyMeshFilter.C

@@ -485,7 +485,7 @@ Foam::polyMeshFilter::polyMeshFilter(const fvMesh& mesh)
     faceFilterFactor_()
 {
     Info<< "Merging:" << nl
-        << "    edges with length less than " << minLen_ << " meters" << nl
+        << "    edges with length less than " << minLen_ << " metres" << nl
         << "    edges split by a point with edges in line to within "
         << radToDeg(::acos(maxCos_)) << " degrees" << nl
         << "    Minimum edge length reduction factor = "

src/finiteVolume/Make/files

@@ -181,6 +181,7 @@ $(derivedFvPatchFields)/translatingWallVelocity/translatingWallVelocityFvPatchVe
 $(derivedFvPatchFields)/turbulentInlet/turbulentInletFvPatchFields.C
 $(derivedFvPatchFields)/turbulentIntensityKineticEnergyInlet/turbulentIntensityKineticEnergyInletFvPatchScalarField.C
 $(derivedFvPatchFields)/uniformDensityHydrostaticPressure/uniformDensityHydrostaticPressureFvPatchScalarField.C
+$(derivedFvPatchFields)/uniformFixedGradient/uniformFixedGradientFvPatchFields.C
 $(derivedFvPatchFields)/uniformFixedValue/uniformFixedValueFvPatchFields.C
 $(derivedFvPatchFields)/uniformJump/uniformJumpFvPatchFields.C
 $(derivedFvPatchFields)/uniformJumpAMI/uniformJumpAMIFvPatchFields.C
@@ -321,8 +322,6 @@ $(ddtSchemes)/CoEulerDdtScheme/CoEulerDdtSchemes.C
 $(ddtSchemes)/SLTSDdtScheme/SLTSDdtSchemes.C
 $(ddtSchemes)/localEulerDdtScheme/localEulerDdtSchemes.C
 $(ddtSchemes)/backwardDdtScheme/backwardDdtSchemes.C
-$(ddtSchemes)/boundedBackwardDdtScheme/boundedBackwardDdtScheme.C
-$(ddtSchemes)/boundedBackwardDdtScheme/boundedBackwardDdtSchemes.C
 $(ddtSchemes)/CrankNicolsonDdtScheme/CrankNicolsonDdtSchemes.C
 $(ddtSchemes)/boundedDdtScheme/boundedDdtSchemes.C
 
@@ -404,5 +403,4 @@ $(SRF)/SRFModel/rpm/rpm.C
 $(SRF)/derivedFvPatchFields/SRFVelocityFvPatchVectorField/SRFVelocityFvPatchVectorField.C
 $(SRF)/derivedFvPatchFields/SRFFreestreamVelocityFvPatchVectorField/SRFFreestreamVelocityFvPatchVectorField.C
 
-
 LIB = $(FOAM_LIBBIN)/libfiniteVolume

src/finiteVolume/cfdTools/general/include/alphaControls.H

@@ -0,0 +1,12 @@
+const dictionary& alphaControls = mesh.solverDict(alpha1.name());
+label nAlphaCorr(readLabel(alphaControls.lookup("nAlphaCorr")));
+label nAlphaSubCycles(readLabel(alphaControls.lookup("nAlphaSubCycles")));
+Switch MULESCorr(alphaControls.lookupOrDefault<Switch>("MULESCorr", false));
+
+if (nAlphaSubCycles > 1 && pimple.nCorrPIMPLE() != 1)
+{
+    FatalErrorIn(args.executable())
+        << "Sub-cycling alpha is only allowed for PISO operation, "
+           "i.e. when the number of outer-correctors = 1"
+        << exit(FatalError);
+}

src/finiteVolume/fields/fvPatchFields/derived/mappedFixedPushedInternalValue/mappedFixedPushedInternalValueFvPatchField.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -95,8 +95,6 @@ mappedFixedPushedInternalValueFvPatchField
 template<class Type>
 void Foam::mappedFixedPushedInternalValueFvPatchField<Type>::updateCoeffs()
 {
-    typedef GeometricField<Type, fvPatchField, volMesh> FieldType;
-
     if (this->updated())
     {
         return;

src/finiteVolume/fields/fvPatchFields/derived/uniformFixedGradient/uniformFixedGradientFvPatchField.C

@@ -0,0 +1,172 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "uniformFixedGradientFvPatchField.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+template<class Type>
+uniformFixedGradientFvPatchField<Type>::uniformFixedGradientFvPatchField
+(
+    const fvPatch& p,
+    const DimensionedField<Type, volMesh>& iF
+)
+:
+    fixedGradientFvPatchField<Type>(p, iF),
+    uniformGradient_()
+{}
+
+
+template<class Type>
+uniformFixedGradientFvPatchField<Type>::uniformFixedGradientFvPatchField
+(
+    const fvPatch& p,
+    const DimensionedField<Type, volMesh>& iF,
+    const Field<Type>& fld
+)
+:
+    fixedGradientFvPatchField<Type>(p, iF, fld),
+    uniformGradient_()
+{}
+
+
+template<class Type>
+uniformFixedGradientFvPatchField<Type>::uniformFixedGradientFvPatchField
+(
+    const uniformFixedGradientFvPatchField<Type>& ptf,
+    const fvPatch& p,
+    const DimensionedField<Type, volMesh>& iF,
+    const fvPatchFieldMapper& mapper
+)
+:
+    fixedGradientFvPatchField<Type>(ptf, p, iF, mapper),
+    uniformGradient_(ptf.uniformGradient_().clone().ptr())
+{
+    // For safety re-evaluate
+    const scalar t = this->db().time().timeOutputValue();
+    this->gradient() = uniformGradient_->value(t);
+}
+
+
+template<class Type>
+uniformFixedGradientFvPatchField<Type>::uniformFixedGradientFvPatchField
+(
+    const fvPatch& p,
+    const DimensionedField<Type, volMesh>& iF,
+    const dictionary& dict
+)
+:
+    fixedGradientFvPatchField<Type>(p, iF),
+    uniformGradient_(DataEntry<Type>::New("uniformGradient", dict))
+{
+    if (dict.found("gradient"))
+    {
+        this->gradient() = Field<Type>("gradient", dict, p.size());
+    }
+    else
+    {
+        const scalar t = this->db().time().timeOutputValue();
+        this->gradient() = uniformGradient_->value(t);
+    }
+}
+
+
+template<class Type>
+uniformFixedGradientFvPatchField<Type>::uniformFixedGradientFvPatchField
+(
+    const uniformFixedGradientFvPatchField<Type>& ptf
+)
+:
+    fixedGradientFvPatchField<Type>(ptf),
+    uniformGradient_
+    (
+        ptf.uniformGradient_.valid()
+      ? ptf.uniformGradient_().clone().ptr()
+      : NULL
+    )
+{}
+
+
+template<class Type>
+uniformFixedGradientFvPatchField<Type>::uniformFixedGradientFvPatchField
+(
+    const uniformFixedGradientFvPatchField<Type>& ptf,
+    const DimensionedField<Type, volMesh>& iF
+)
+:
+    fixedGradientFvPatchField<Type>(ptf, iF),
+    uniformGradient_
+    (
+        ptf.uniformGradient_.valid()
+      ? ptf.uniformGradient_().clone().ptr()
+      : NULL
+    )
+{
+    // For safety re-evaluate
+    const scalar t = this->db().time().timeOutputValue();
+
+    if (ptf.uniformGradient_.valid())
+    {
+        this->gradient() = uniformGradient_->value(t);
+    }
+}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+template<class Type>
+void uniformFixedGradientFvPatchField<Type>::updateCoeffs()
+{
+    if (this->updated())
+    {
+        return;
+    }
+
+    const scalar t = this->db().time().timeOutputValue();
+    this->gradient() = uniformGradient_->value(t);
+
+    fixedGradientFvPatchField<Type>::updateCoeffs();
+}
+
+
+template<class Type>
+void uniformFixedGradientFvPatchField<Type>::write(Ostream& os) const
+{
+    fixedGradientFvPatchField<Type>::write(os);
+    uniformGradient_->writeData(os);
+    this->writeEntry("value", os);
+}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// ************************************************************************* //

src/finiteVolume/fields/fvPatchFields/derived/uniformFixedGradient/uniformFixedGradientFvPatchField.H

@@ -0,0 +1,193 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::uniformFixedGradientFvPatchField
+
+Group
+    grpGenericBoundaryConditions
+
+Description
+    This boundary condition provides a uniform fixed gradient condition.
+
+    \heading Patch usage
+
+    \table
+        Property     | Description             | Required    | Default value
+        uniformGradient | uniform gradient     | yes         |
+    \endtable
+
+    Example of the boundary condition specification:
+    \verbatim
+    myPatch
+    {
+        type            uniformFixedGradient;
+        uniformGradient constant 0.2;
+    }
+    \endverbatim
+
+Note
+    The uniformGradient entry is a DataEntry type, able to describe time
+    varying functions.  The example above gives the usage for supplying a
+    constant value.
+
+SeeAlso
+    Foam::DataEntry
+    Foam::fixedGradientFvPatchField
+
+SourceFiles
+    uniformFixedGradientFvPatchField.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef uniformFixedGradientFvPatchField_H
+#define uniformFixedGradientFvPatchField_H
+
+#include "fixedGradientFvPatchFields.H"
+#include "DataEntry.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+              Class uniformFixedGradientFvPatchField Declaration
+\*---------------------------------------------------------------------------*/
+
+template<class Type>
+class uniformFixedGradientFvPatchField
+:
+    public fixedGradientFvPatchField<Type>
+{
+    // Private data
+
+        //- Gradient
+        autoPtr<DataEntry<Type> > uniformGradient_;
+
+
+public:
+
+    //- Runtime type information
+    TypeName("uniformFixedGradient");
+
+
+    // Constructors
+
+        //- Construct from patch and internal field
+        uniformFixedGradientFvPatchField
+        (
+            const fvPatch&,
+            const DimensionedField<Type, volMesh>&
+        );
+
+        //- Construct from patch and internal field and patch field
+        uniformFixedGradientFvPatchField
+        (
+            const fvPatch&,
+            const DimensionedField<Type, volMesh>&,
+            const Field<Type>& fld
+        );
+
+        //- Construct from patch, internal field and dictionary
+        uniformFixedGradientFvPatchField
+        (
+            const fvPatch&,
+            const DimensionedField<Type, volMesh>&,
+            const dictionary&
+        );
+
+        //- Construct by mapping given uniformFixedGradientFvPatchField
+        //  onto a new patch
+        uniformFixedGradientFvPatchField
+        (
+            const uniformFixedGradientFvPatchField<Type>&,
+            const fvPatch&,
+            const DimensionedField<Type, volMesh>&,
+            const fvPatchFieldMapper&
+        );
+
+        //- Construct as copy
+        uniformFixedGradientFvPatchField
+        (
+            const uniformFixedGradientFvPatchField<Type>&
+        );
+
+        //- Construct and return a clone
+        virtual tmp<fvPatchField<Type> > clone() const
+        {
+            return tmp<fvPatchField<Type> >
+            (
+                new uniformFixedGradientFvPatchField<Type>(*this)
+            );
+        }
+
+        //- Construct as copy setting internal field reference
+        uniformFixedGradientFvPatchField
+        (
+            const uniformFixedGradientFvPatchField<Type>&,
+            const DimensionedField<Type, volMesh>&
+        );
+
+        //- Construct and return a clone setting internal field reference
+        virtual tmp<fvPatchField<Type> > clone
+        (
+            const DimensionedField<Type, volMesh>& iF
+        ) const
+        {
+            return tmp<fvPatchField<Type> >
+            (
+                new uniformFixedGradientFvPatchField<Type>(*this, iF)
+            );
+        }
+
+
+    // Member functions
+
+
+        // Evaluation functions
+
+            //- Update the coefficients associated with the patch field
+            virtual void updateCoeffs();
+
+
+        //- Write
+        virtual void write(Ostream&) const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+#   include "uniformFixedGradientFvPatchField.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/finiteVolume/fields/fvPatchFields/derived/uniformFixedGradient/uniformFixedGradientFvPatchFields.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -23,22 +23,21 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-#include "boundedBackwardDdtScheme.H"
-#include "fvMesh.H"
+#include "uniformFixedGradientFvPatchFields.H"
+#include "addToRunTimeSelectionTable.H"
+#include "volFields.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 namespace Foam
 {
-namespace fv
-{
 
-defineTypeNameAndDebug(boundedBackwardDdtScheme, 0);
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
 
-ddtScheme<scalar>::addIstreamConstructorToTable<boundedBackwardDdtScheme>
-    addboundedBackwardDdtSchemeIstreamConstructorToTable_;
+makePatchFields(uniformFixedGradient);
 
-}
-}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
 
 // ************************************************************************* //

src/finiteVolume/fields/fvPatchFields/derived/uniformFixedGradient/uniformFixedGradientFvPatchFields.H

@@ -0,0 +1,49 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef uniformFixedGradientFvPatchFields_H
+#define uniformFixedGradientFvPatchFields_H
+
+#include "uniformFixedGradientFvPatchField.H"
+#include "fieldTypes.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+makePatchTypeFieldTypedefs(uniformFixedGradient);
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/finiteVolume/fields/fvPatchFields/derived/uniformFixedGradient/uniformFixedGradientFvPatchFieldsFwd.H

@@ -0,0 +1,50 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef uniformFixedGradientFvPatchFieldsFwd_H
+#define uniformFixedGradientFvPatchFieldsFwd_H
+
+#include "fieldTypes.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+template<class Type> class uniformFixedGradientFvPatchField;
+
+makePatchTypeFieldTypedefs(uniform);
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/finiteVolume/finiteVolume/ddtSchemes/boundedBackwardDdtScheme/boundedBackwardDdtScheme.C

@@ -1,708 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-\*---------------------------------------------------------------------------*/
-
-#include "boundedBackwardDdtScheme.H"
-#include "surfaceInterpolate.H"
-#include "fvcDiv.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-namespace Foam
-{
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-namespace fv
-{
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-scalar boundedBackwardDdtScheme::deltaT_() const
-{
-    return mesh().time().deltaTValue();
-}
-
-
-scalar boundedBackwardDdtScheme::deltaT0_() const
-{
-    return mesh().time().deltaT0Value();
-}
-
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-tmp<volScalarField>
-boundedBackwardDdtScheme::fvcDdt
-(
-    const dimensionedScalar& dt
-)
-{
-    // No change compared to backward
-
-    dimensionedScalar rDeltaT = 1.0/mesh().time().deltaT();
-
-    IOobject ddtIOobject
-    (
-        "ddt("+dt.name()+')',
-        mesh().time().timeName(),
-        mesh()
-    );
-
-    scalar deltaT = deltaT_();
-    scalar deltaT0 = deltaT0_();
-
-    scalar coefft   = 1 + deltaT/(deltaT + deltaT0);
-    scalar coefft00 = deltaT*deltaT/(deltaT0*(deltaT + deltaT0));
-    scalar coefft0  = coefft + coefft00;
-
-    if (mesh().moving())
-    {
-        tmp<volScalarField> tdtdt
-        (
-            new volScalarField
-            (
-                ddtIOobject,
-                mesh(),
-                dimensionedScalar
-                (
-                    "0",
-                    dt.dimensions()/dimTime,
-                    0.0
-                )
-            )
-        );
-
-        tdtdt().internalField() = rDeltaT.value()*dt.value()*
-        (
-            coefft - (coefft0*mesh().V0() - coefft00*mesh().V00())/mesh().V()
-        );
-
-        return tdtdt;
-    }
-    else
-    {
-        return tmp<volScalarField>
-        (
-            new volScalarField
-            (
-                ddtIOobject,
-                mesh(),
-                dimensionedScalar
-                (
-                    "0",
-                    dt.dimensions()/dimTime,
-                    0.0
-                ),
-                calculatedFvPatchScalarField::typeName
-            )
-        );
-    }
-}
-
-
-tmp<volScalarField>
-boundedBackwardDdtScheme::fvcDdt
-(
-    const volScalarField& vf
-)
-{
-    dimensionedScalar rDeltaT = 1.0/mesh().time().deltaT();
-
-    IOobject ddtIOobject
-    (
-        "ddt("+vf.name()+')',
-        mesh().time().timeName(),
-        mesh()
-    );
-
-    scalar deltaT = deltaT_();
-    scalar deltaT0 = deltaT0_(vf);
-
-    // Calculate unboundedness indicator
-    // Note: all times moved by one because access to internal field
-    // copies current field into the old-time level.
-    const volScalarField phict
-    (
-        mag
-        (
-            vf.oldTime().oldTime()
-          - vf.oldTime().oldTime().oldTime()
-        )/
-        (
-            mag
-            (
-                vf.oldTime()
-              - vf.oldTime().oldTime()
-            )
-          + dimensionedScalar("small", vf.dimensions(), VSMALL)
-        )
-    );
-
-    const volScalarField limiter(pos(phict) - pos(phict - scalar(1)));
-    const volScalarField coefft(scalar(1) + limiter*deltaT/(deltaT + deltaT0));
-    const volScalarField coefft00
-    (
-        limiter*sqr(deltaT)/(deltaT0*(deltaT + deltaT0))
-    );
-    const volScalarField coefft0(coefft + coefft00);
-
-    if (mesh().moving())
-    {
-        return tmp<volScalarField>
-        (
-            new volScalarField
-            (
-                ddtIOobject,
-                mesh(),
-                rDeltaT.dimensions()*vf.dimensions(),
-                rDeltaT.value()*
-                (
-                    coefft*vf.internalField() -
-                    (
-                        coefft0.internalField()
-                        *vf.oldTime().internalField()*mesh().V0()
-                      - coefft00.internalField()
-                        *vf.oldTime().oldTime().internalField()
-                       *mesh().V00()
-                    )/mesh().V()
-                ),
-                rDeltaT.value()*
-                (
-                    coefft.boundaryField()*vf.boundaryField() -
-                    (
-                        coefft0.boundaryField()*
-                        vf.oldTime().boundaryField()
-                      - coefft00.boundaryField()*
-                        vf.oldTime().oldTime().boundaryField()
-                    )
-                )
-            )
-        );
-    }
-    else
-    {
-        return tmp<volScalarField>
-        (
-            new volScalarField
-            (
-                ddtIOobject,
-                rDeltaT*
-                (
-                    coefft*vf
-                  - coefft0*vf.oldTime()
-                  + coefft00*vf.oldTime().oldTime()
-                )
-            )
-        );
-    }
-}
-
-
-tmp<volScalarField>
-boundedBackwardDdtScheme::fvcDdt
-(
-    const dimensionedScalar& rho,
-    const volScalarField& vf
-)
-{
-    dimensionedScalar rDeltaT = 1.0/mesh().time().deltaT();
-
-    IOobject ddtIOobject
-    (
-        "ddt("+rho.name()+','+vf.name()+')',
-        mesh().time().timeName(),
-        mesh()
-    );
-
-    scalar deltaT = deltaT_();
-    scalar deltaT0 = deltaT0_(vf);
-
-    // Calculate unboundedness indicator
-    // Note: all times moved by one because access to internal field
-    // copies current field into the old-time level.
-    const volScalarField phict
-    (
-        mag
-        (
-            vf.oldTime().oldTime()
-          - vf.oldTime().oldTime().oldTime()
-        )/
-        (
-            mag
-            (
-                vf.oldTime()
-              - vf.oldTime().oldTime()
-            )
-          + dimensionedScalar("small", vf.dimensions(), VSMALL)
-        )
-    );
-
-    const volScalarField limiter(pos(phict) - pos(phict - scalar(1)));
-    const volScalarField coefft(scalar(1) + limiter*deltaT/(deltaT + deltaT0));
-    const volScalarField coefft00
-    (
-            limiter*sqr(deltaT)/(deltaT0*(deltaT + deltaT0))
-    );
-    const volScalarField coefft0(coefft + coefft00);
-
-    if (mesh().moving())
-    {
-        return tmp<volScalarField>
-        (
-            new volScalarField
-            (
-                ddtIOobject,
-                mesh(),
-                rDeltaT.dimensions()*rho.dimensions()*vf.dimensions(),
-                rDeltaT.value()*rho.value()*
-                (
-                    coefft*vf.internalField() -
-                    (
-                        coefft0.internalField()*
-                        vf.oldTime().internalField()*mesh().V0()
-                      - coefft00.internalField()*
-                        vf.oldTime().oldTime().internalField()
-                       *mesh().V00()
-                    )/mesh().V()
-                ),
-                rDeltaT.value()*rho.value()*
-                (
-                    coefft.boundaryField()*vf.boundaryField() -
-                    (
-                        coefft0.boundaryField()*
-                        vf.oldTime().boundaryField()
-                      - coefft00.boundaryField()*
-                        vf.oldTime().oldTime().boundaryField()
-                    )
-                )
-            )
-        );
-    }
-    else
-    {
-        return tmp<volScalarField>
-        (
-            new volScalarField
-            (
-                ddtIOobject,
-                rDeltaT*rho*
-                (
-                    coefft*vf
-                  - coefft0*vf.oldTime()
-                 + coefft00*vf.oldTime().oldTime()
-                )
-            )
-        );
-    }
-}
-
-
-tmp<volScalarField>
-boundedBackwardDdtScheme::fvcDdt
-(
-    const volScalarField& rho,
-    const volScalarField& vf
-)
-{
-    dimensionedScalar rDeltaT = 1.0/mesh().time().deltaT();
-
-    IOobject ddtIOobject
-    (
-        "ddt("+rho.name()+','+vf.name()+')',
-        mesh().time().timeName(),
-        mesh()
-    );
-
-    scalar deltaT = deltaT_();
-    scalar deltaT0 = deltaT0_(vf);
-
-    // Calculate unboundedness indicator
-    // Note: all times moved by one because access to internal field
-    // copies current field into the old-time level.
-    const volScalarField phict
-    (
-        mag
-        (
-            rho.oldTime().oldTime()*vf.oldTime().oldTime()
-          - rho.oldTime().oldTime().oldTime()*vf.oldTime().oldTime().oldTime()
-        )/
-        (
-            mag
-            (
-                rho.oldTime()*vf.oldTime()
-              - rho.oldTime().oldTime()*vf.oldTime().oldTime()
-            )
-          + dimensionedScalar("small", rho.dimensions()*vf.dimensions(), VSMALL)
-        )
-    );
-
-    const volScalarField limiter(pos(phict) - pos(phict - scalar(1)));
-    const volScalarField coefft(scalar(1) + limiter*deltaT/(deltaT + deltaT0));
-    const volScalarField coefft00
-    (
-        limiter*sqr(deltaT)/(deltaT0*(deltaT + deltaT0))
-    );
-    const volScalarField coefft0(coefft + coefft00);
-
-    if (mesh().moving())
-    {
-        return tmp<volScalarField>
-        (
-            new volScalarField
-            (
-                ddtIOobject,
-                mesh(),
-                rDeltaT.dimensions()*rho.dimensions()*vf.dimensions(),
-                rDeltaT.value()*
-                (
-                    coefft*rho.internalField()*vf.internalField() -
-                    (
-                        coefft0.internalField()*
-                        rho.oldTime().internalField()*
-                        vf.oldTime().internalField()*mesh().V0()
-                      - coefft00.internalField()*
-                        rho.oldTime().oldTime().internalField()
-                       *vf.oldTime().oldTime().internalField()*mesh().V00()
-                    )/mesh().V()
-                ),
-                rDeltaT.value()*
-                (
-                    coefft.boundaryField()*vf.boundaryField() -
-                    (
-                        coefft0.boundaryField()*
-                        rho.oldTime().boundaryField()*
-                        vf.oldTime().boundaryField()
-                      - coefft00.boundaryField()*
-                        rho.oldTime().oldTime().boundaryField()*
-                        vf.oldTime().oldTime().boundaryField()
-                    )
-                )
-            )
-        );
-    }
-    else
-    {
-        return tmp<volScalarField>
-        (
-            new volScalarField
-            (
-                ddtIOobject,
-                rDeltaT*
-                (
-                    coefft*rho*vf
-                  - coefft0*rho.oldTime()*vf.oldTime()
-                  + coefft00*rho.oldTime().oldTime()*vf.oldTime().oldTime()
-                )
-            )
-        );
-    }
-}
-
-
-tmp<fvScalarMatrix>
-boundedBackwardDdtScheme::fvmDdt
-(
-    const volScalarField& vf
-)
-{
-    tmp<fvScalarMatrix> tfvm
-    (
-        new fvScalarMatrix
-        (
-            vf,
-            vf.dimensions()*dimVol/dimTime
-        )
-    );
-
-    fvScalarMatrix& fvm = tfvm();
-
-    scalar rDeltaT = 1.0/deltaT_();
-
-    scalar deltaT = deltaT_();
-    scalar deltaT0 = deltaT0_(vf);
-
-    // Calculate unboundedness indicator
-    // Note: all times moved by one because access to internal field
-    // copies current field into the old-time level.
-    const scalarField phict
-    (
-        mag
-        (
-            vf.oldTime().oldTime().internalField()
-          - vf.oldTime().oldTime().oldTime().internalField()
-        )/
-        (
-            mag
-            (
-                vf.oldTime().internalField()
-              - vf.oldTime().oldTime().internalField()
-            )
-            + VSMALL
-        )
-    );
-
-    const scalarField limiter(pos(phict) - pos(phict - 1.0));
-    const scalarField coefft(1.0 + limiter*deltaT/(deltaT + deltaT0));
-    const scalarField coefft00
-    (
-        limiter*deltaT*deltaT/(deltaT0*(deltaT + deltaT0))
-    );
-    const scalarField coefft0(coefft + coefft00);
-
-    fvm.diag() = (coefft*rDeltaT)*mesh().V();
-
-    if (mesh().moving())
-    {
-        fvm.source() = rDeltaT*
-        (
-            coefft0*vf.oldTime().internalField()*mesh().V0()
-          - coefft00*vf.oldTime().oldTime().internalField()
-           *mesh().V00()
-        );
-    }
-    else
-    {
-        fvm.source() = rDeltaT*mesh().V()*
-        (
-            coefft0*vf.oldTime().internalField()
-          - coefft00*vf.oldTime().oldTime().internalField()
-        );
-    }
-
-    return tfvm;
-}
-
-
-tmp<fvScalarMatrix>
-boundedBackwardDdtScheme::fvmDdt
-(
-    const dimensionedScalar& rho,
-    const volScalarField& vf
-)
-{
-    tmp<fvScalarMatrix> tfvm
-    (
-        new fvScalarMatrix
-        (
-            vf,
-            rho.dimensions()*vf.dimensions()*dimVol/dimTime
-        )
-    );
-    fvScalarMatrix& fvm = tfvm();
-
-    scalar rDeltaT = 1.0/deltaT_();
-
-    scalar deltaT = deltaT_();
-    scalar deltaT0 = deltaT0_(vf);
-
-    // Calculate unboundedness indicator
-    // Note: all times moved by one because access to internal field
-    // copies current field into the old-time level.
-    const scalarField phict
-    (
-        mag
-        (
-            vf.oldTime().oldTime().internalField()
-          - vf.oldTime().oldTime().oldTime().internalField()
-        )/
-        (
-            mag
-            (
-                vf.oldTime().internalField()
-              - vf.oldTime().oldTime().internalField()
-            )
-            + VSMALL
-        )
-    );
-
-    const scalarField limiter(pos(phict) - pos(phict - 1.0));
-    const scalarField coefft(1.0 + limiter*deltaT/(deltaT + deltaT0));
-    const scalarField coefft00
-    (
-        limiter*deltaT*deltaT/(deltaT0*(deltaT + deltaT0))
-    );
-    const scalarField coefft0(coefft + coefft00);
-
-    fvm.diag() = (coefft*rDeltaT*rho.value())*mesh().V();
-
-    if (mesh().moving())
-    {
-        fvm.source() = rDeltaT*rho.value()*
-        (
-            coefft0*vf.oldTime().internalField()*mesh().V0()
-          - coefft00*vf.oldTime().oldTime().internalField()
-           *mesh().V00()
-        );
-    }
-    else
-    {
-        fvm.source() = rDeltaT*mesh().V()*rho.value()*
-        (
-            coefft0*vf.oldTime().internalField()
-          - coefft00*vf.oldTime().oldTime().internalField()
-        );
-    }
-
-    return tfvm;
-}
-
-
-tmp<fvScalarMatrix>
-boundedBackwardDdtScheme::fvmDdt
-(
-    const volScalarField& rho,
-    const volScalarField& vf
-)
-{
-    tmp<fvScalarMatrix> tfvm
-    (
-        new fvScalarMatrix
-        (
-            vf,
-            rho.dimensions()*vf.dimensions()*dimVol/dimTime
-        )
-    );
-    fvScalarMatrix& fvm = tfvm();
-
-    scalar rDeltaT = 1.0/deltaT_();
-
-    scalar deltaT = deltaT_();
-    scalar deltaT0 = deltaT0_(vf);
-
-    // Calculate unboundedness indicator
-    // Note: all times moved by one because access to internal field
-    // copies current field into the old-time level.
-    const scalarField phict
-    (
-        mag
-        (
-            rho.oldTime().oldTime().internalField()*
-            vf.oldTime().oldTime().internalField()
-          - rho.oldTime().oldTime().oldTime().internalField()*
-            vf.oldTime().oldTime().oldTime().internalField()
-        )/
-        (
-            mag
-            (
-                rho.oldTime().internalField()*
-                vf.oldTime().internalField()
-              - rho.oldTime().oldTime().internalField()*
-                vf.oldTime().oldTime().internalField()
-            )
-            + VSMALL
-        )
-    );
-
-    const scalarField limiter(pos(phict) - pos(phict - 1.0));
-    const scalarField coefft(1.0 + limiter*deltaT/(deltaT + deltaT0));
-    const scalarField coefft00
-    (
-        limiter*deltaT*deltaT/(deltaT0*(deltaT + deltaT0))
-    );
-    const scalarField coefft0(coefft + coefft00);
-
-    fvm.diag() = (coefft*rDeltaT)*rho.internalField()*mesh().V();
-
-    if (mesh().moving())
-    {
-        fvm.source() = rDeltaT*
-        (
-            coefft0*rho.oldTime().internalField()
-           *vf.oldTime().internalField()*mesh().V0()
-          - coefft00*rho.oldTime().oldTime().internalField()
-           *vf.oldTime().oldTime().internalField()*mesh().V00()
-        );
-    }
-    else
-    {
-        fvm.source() = rDeltaT*mesh().V()*
-        (
-            coefft0*rho.oldTime().internalField()
-           *vf.oldTime().internalField()
-          - coefft00*rho.oldTime().oldTime().internalField()
-           *vf.oldTime().oldTime().internalField()
-        );
-    }
-
-    return tfvm;
-}
-
-
-tmp<surfaceScalarField> boundedBackwardDdtScheme::fvcDdtPhiCorr
-(
-    const volScalarField& rA,
-    const volScalarField& U,
-    const surfaceScalarField& phi
-)
-{
-    notImplemented
-    (
-        "boundedBackwardDdtScheme::fvcDdtPhiCorr"
-    );
-
-    return surfaceScalarField::null();
-}
-
-
-tmp<surfaceScalarField> boundedBackwardDdtScheme::fvcDdtPhiCorr
-(
-    const volScalarField& rA,
-    const volScalarField& rho,
-    const volScalarField& U,
-    const surfaceScalarField& phi
-)
-{
-    notImplemented
-    (
-        "boundedBackwardDdtScheme::fvcDdtPhiCorr"
-    );
-
-    return surfaceScalarField::null();
-}
-
-
-tmp<surfaceScalarField> boundedBackwardDdtScheme::meshPhi
-(
-    const volScalarField& vf
-)
-{
-    notImplemented
-    (
-        "boundedBackwardDdtScheme::meshPhi(const volScalarField& vf)"
-    );
-
-    return surfaceScalarField::null();
-}
-
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace fv
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
-
-// ************************************************************************* //

src/finiteVolume/finiteVolume/ddtSchemes/boundedBackwardDdtScheme/boundedBackwardDdtScheme.H

@@ -1,193 +0,0 @@
-/*---------------------------------------------------------------------------*\
-  =========                 |
-  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
-   \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
-     \\/     M anipulation  |
--------------------------------------------------------------------------------
-License
-    This file is part of OpenFOAM.
-
-    OpenFOAM is free software: you can redistribute it and/or modify it
-    under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
-    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
-    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
-    for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
-
-Class
-    Foam::fv::boundedBackwardDdtScheme
-
-Description
-    Second-order bounded-backward-differencing ddt using the current and
-    two previous time-step values.
-
-SourceFiles
-    boundedBackwardDdtScheme.C
-
-\*---------------------------------------------------------------------------*/
-
-#ifndef boundedBackwardDdtScheme_H
-#define boundedBackwardDdtScheme_H
-
-#include "ddtScheme.H"
-#include "fvMatrices.H"
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-namespace Foam
-{
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-namespace fv
-{
-
-/*---------------------------------------------------------------------------*\
-                       Class boundedBackwardDdtScheme Declaration
-\*---------------------------------------------------------------------------*/
-
-class boundedBackwardDdtScheme
-:
-    public fv::ddtScheme<scalar>
-{
-    // Private Member Functions
-
-        //- Return the current time-step
-        scalar deltaT_() const;
-
-        //- Return the previous time-step
-        scalar deltaT0_() const;
-
-        //- Return the previous time-step or GREAT if the old timestep field
-        //  wasn't available in which case Euler ddt is used
-        template<class GeoField>
-        scalar deltaT0_(const GeoField& vf) const
-        {
-            if (vf.oldTime().timeIndex() == vf.oldTime().oldTime().timeIndex())
-            {
-                return GREAT;
-            }
-            else
-            {
-                return deltaT0_();
-            }
-        }
-
-
-        //- Disallow default bitwise copy construct
-        boundedBackwardDdtScheme(const boundedBackwardDdtScheme&);
-
-        //- Disallow default bitwise assignment
-        void operator=(const boundedBackwardDdtScheme&);
-
-
-public:
-
-    //- Runtime type information
-    TypeName("boundedBackward");
-
-
-    // Constructors
-
-        //- Construct from mesh
-        boundedBackwardDdtScheme(const fvMesh& mesh)
-        :
-            ddtScheme<scalar>(mesh)
-        {}
-
-        //- Construct from mesh and Istream
-        boundedBackwardDdtScheme(const fvMesh& mesh, Istream& is)
-        :
-            ddtScheme<scalar>(mesh, is)
-        {}
-
-
-    // Member Functions
-
-        //- Return mesh reference
-        const fvMesh& mesh() const
-        {
-            return fv::ddtScheme<scalar>::mesh();
-        }
-
-        tmp<volScalarField> fvcDdt
-        (
-            const dimensionedScalar&
-        );
-
-        tmp<volScalarField> fvcDdt
-        (
-            const volScalarField&
-        );
-
-        tmp<volScalarField> fvcDdt
-        (
-            const dimensionedScalar&,
-            const volScalarField&
-        );
-
-        tmp<volScalarField> fvcDdt
-        (
-            const volScalarField&,
-            const volScalarField&
-        );
-
-        tmp<fvScalarMatrix> fvmDdt
-        (
-            const volScalarField&
-        );
-
-        tmp<fvScalarMatrix> fvmDdt
-        (
-            const dimensionedScalar&,
-            const volScalarField&
-        );
-
-        tmp<fvScalarMatrix> fvmDdt
-        (
-            const volScalarField&,
-            const volScalarField&
-        );
-
-        tmp<surfaceScalarField> fvcDdtPhiCorr
-        (
-            const volScalarField& rA,
-            const volScalarField& U,
-            const surfaceScalarField& phi
-        );
-
-        tmp<surfaceScalarField> fvcDdtPhiCorr
-        (
-            const volScalarField& rA,
-            const volScalarField& rho,
-            const volScalarField& U,
-            const surfaceScalarField& phi
-        );
-
-        tmp<surfaceScalarField> meshPhi
-        (
-            const volScalarField&
-        );
-};
-
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace fv
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-} // End namespace Foam
-
-// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
-
-#endif
-
-// ************************************************************************* //

src/finiteVolume/fvMatrices/solvers/MULES/MULES.C

@@ -48,6 +48,25 @@ void Foam::MULES::explicitSolve
 }
 
 
+void Foam::MULES::correct
+(
+    volScalarField& psi,
+    surfaceScalarField& phiPsiCorr,
+    const scalar psiMax,
+    const scalar psiMin
+)
+{
+    correct
+    (
+        geometricOneField(),
+        psi,
+        phiPsiCorr,
+        zeroField(), zeroField(),
+        psiMax, psiMin
+    );
+}
+
+
 void Foam::MULES::limitSum(UPtrList<scalarField>& phiPsiCorrs)
 {
     forAll(phiPsiCorrs[0], facei)

src/finiteVolume/fvMatrices/solvers/MULES/MULES.H

@@ -92,6 +92,38 @@ void explicitSolve
     const scalar psiMin
 );
 
+
+template<class RhoType, class SpType, class SuType>
+void correct
+(
+    const RhoType& rho,
+    volScalarField& psi,
+    const surfaceScalarField& phiCorr,
+    const SpType& Sp,
+    const SuType& Su
+);
+
+template<class RhoType, class SpType, class SuType>
+void correct
+(
+    const RhoType& rho,
+    volScalarField& psi,
+    surfaceScalarField& phiCorr,
+    const SpType& Sp,
+    const SuType& Su,
+    const scalar psiMax,
+    const scalar psiMin
+);
+
+void correct
+(
+    volScalarField& psi,
+    surfaceScalarField& phiCorr,
+    const scalar psiMax,
+    const scalar psiMin
+);
+
+
 template<class RhoType, class SpType, class SuType>
 void limiter
 (
@@ -122,6 +154,35 @@ void limit
     const bool returnCorr
 );
 
+
+template<class RhoType, class SpType, class SuType>
+void limiterCorr
+(
+    scalarField& allLambda,
+    const RhoType& rho,
+    const volScalarField& psi,
+    const surfaceScalarField& phiCorr,
+    const SpType& Sp,
+    const SuType& Su,
+    const scalar psiMax,
+    const scalar psiMin,
+    const label nLimiterIter
+);
+
+template<class RhoType, class SpType, class SuType>
+void limitCorr
+(
+    const RhoType& rho,
+    const volScalarField& psi,
+    surfaceScalarField& phiCorr,
+    const SpType& Sp,
+    const SuType& Su,
+    const scalar psiMax,
+    const scalar psiMin,
+    const label nLimiterIter
+);
+
+
 void limitSum(UPtrList<scalarField>& phiPsiCorrs);
 
 template<class SurfaceScalarFieldList>

src/finiteVolume/fvMatrices/solvers/MULES/MULESTemplates.C

@@ -96,6 +96,74 @@ void Foam::MULES::explicitSolve
 }
 
 
+template<class RhoType, class SpType, class SuType>
+void Foam::MULES::correct
+(
+    const RhoType& rho,
+    volScalarField& psi,
+    const surfaceScalarField& phiCorr,
+    const SpType& Sp,
+    const SuType& Su
+)
+{
+    Info<< "MULES: Correcting " << psi.name() << endl;
+
+    const fvMesh& mesh = psi.mesh();
+
+    const scalar deltaT = mesh.time().deltaTValue();
+
+    scalarField psiIf(psi.size(), 0);
+    fvc::surfaceIntegrate(psiIf, phiCorr);
+
+    if (mesh.moving())
+    {
+        psi.internalField() =
+        (
+            rho.field()*psi.internalField()/deltaT
+          + Su.field()
+          - psiIf
+        )/(rho.field()/deltaT - Sp.field());
+    }
+    else
+    {
+        psi.internalField() =
+        (
+            rho.field()*psi.internalField()/deltaT
+          + Su.field()
+          - psiIf
+        )/(rho.field()/deltaT - Sp.field());
+    }
+
+    psi.correctBoundaryConditions();
+}
+
+
+template<class RhoType, class SpType, class SuType>
+void Foam::MULES::correct
+(
+    const RhoType& rho,
+    volScalarField& psi,
+    surfaceScalarField& phiCorr,
+    const SpType& Sp,
+    const SuType& Su,
+    const scalar psiMax,
+    const scalar psiMin
+)
+{
+    const fvMesh& mesh = psi.mesh();
+
+    const dictionary& MULEScontrols = mesh.solverDict(psi.name());
+
+    label nLimiterIter
+    (
+        readLabel(MULEScontrols.lookup("nLimiterIter"))
+    );
+
+    limitCorr(rho, psi, phiCorr, Sp, Su, psiMax, psiMin, nLimiterIter);
+    correct(rho, psi, phiCorr, Sp, Su);
+}
+
+
 template<class RhoType, class SpType, class SuType>
 void Foam::MULES::limiter
 (
@@ -511,6 +579,364 @@ void Foam::MULES::limit
 }
 
 
+template<class RhoType, class SpType, class SuType>
+void Foam::MULES::limiterCorr
+(
+    scalarField& allLambda,
+    const RhoType& rho,
+    const volScalarField& psi,
+    const surfaceScalarField& phiCorr,
+    const SpType& Sp,
+    const SuType& Su,
+    const scalar psiMax,
+    const scalar psiMin,
+    const label nLimiterIter
+)
+{
+    const scalarField& psiIf = psi;
+    const volScalarField::GeometricBoundaryField& psiBf = psi.boundaryField();
+
+    const fvMesh& mesh = psi.mesh();
+
+    const labelUList& owner = mesh.owner();
+    const labelUList& neighb = mesh.neighbour();
+    tmp<volScalarField::DimensionedInternalField> tVsc = mesh.Vsc();
+    const scalarField& V = tVsc();
+    const scalar deltaT = mesh.time().deltaTValue();
+
+    const scalarField& phiCorrIf = phiCorr;
+    const surfaceScalarField::GeometricBoundaryField& phiCorrBf =
+        phiCorr.boundaryField();
+
+    slicedSurfaceScalarField lambda
+    (
+        IOobject
+        (
+            "lambda",
+            mesh.time().timeName(),
+            mesh,
+            IOobject::NO_READ,
+            IOobject::NO_WRITE,
+            false
+        ),
+        mesh,
+        dimless,
+        allLambda,
+        false   // Use slices for the couples
+    );
+
+    scalarField& lambdaIf = lambda;
+    surfaceScalarField::GeometricBoundaryField& lambdaBf =
+        lambda.boundaryField();
+
+    scalarField psiMaxn(psiIf.size(), psiMin);
+    scalarField psiMinn(psiIf.size(), psiMax);
+
+    scalarField sumPhip(psiIf.size(), VSMALL);
+    scalarField mSumPhim(psiIf.size(), VSMALL);
+
+    forAll(phiCorrIf, facei)
+    {
+        label own = owner[facei];
+        label nei = neighb[facei];
+
+        psiMaxn[own] = max(psiMaxn[own], psiIf[nei]);
+        psiMinn[own] = min(psiMinn[own], psiIf[nei]);
+
+        psiMaxn[nei] = max(psiMaxn[nei], psiIf[own]);
+        psiMinn[nei] = min(psiMinn[nei], psiIf[own]);
+
+        scalar phiCorrf = phiCorrIf[facei];
+
+        if (phiCorrf > 0.0)
+        {
+            sumPhip[own] += phiCorrf;
+            mSumPhim[nei] += phiCorrf;
+        }
+        else
+        {
+            mSumPhim[own] -= phiCorrf;
+            sumPhip[nei] -= phiCorrf;
+        }
+    }
+
+    forAll(phiCorrBf, patchi)
+    {
+        const fvPatchScalarField& psiPf = psiBf[patchi];
+        const scalarField& phiCorrPf = phiCorrBf[patchi];
+
+        const labelList& pFaceCells = mesh.boundary()[patchi].faceCells();
+
+        if (psiPf.coupled())
+        {
+            const scalarField psiPNf(psiPf.patchNeighbourField());
+
+            forAll(phiCorrPf, pFacei)
+            {
+                label pfCelli = pFaceCells[pFacei];
+
+                psiMaxn[pfCelli] = max(psiMaxn[pfCelli], psiPNf[pFacei]);
+                psiMinn[pfCelli] = min(psiMinn[pfCelli], psiPNf[pFacei]);
+            }
+        }
+        else
+        {
+            forAll(phiCorrPf, pFacei)
+            {
+                label pfCelli = pFaceCells[pFacei];
+
+                psiMaxn[pfCelli] = max(psiMaxn[pfCelli], psiPf[pFacei]);
+                psiMinn[pfCelli] = min(psiMinn[pfCelli], psiPf[pFacei]);
+            }
+        }
+
+        forAll(phiCorrPf, pFacei)
+        {
+            label pfCelli = pFaceCells[pFacei];
+
+            scalar phiCorrf = phiCorrPf[pFacei];
+
+            if (phiCorrf > 0.0)
+            {
+                sumPhip[pfCelli] += phiCorrf;
+            }
+            else
+            {
+                mSumPhim[pfCelli] -= phiCorrf;
+            }
+        }
+    }
+
+    psiMaxn = min(psiMaxn, psiMax);
+    psiMinn = max(psiMinn, psiMin);
+
+    // scalar smooth = 0.5;
+    // psiMaxn = min((1.0 - smooth)*psiIf + smooth*psiMaxn, psiMax);
+    // psiMinn = max((1.0 - smooth)*psiIf + smooth*psiMinn, psiMin);
+
+    psiMaxn =
+        V
+       *(
+           (rho.field()/deltaT - Sp.field())*psiMaxn
+         - Su.field()
+         - rho.field()*psi.internalField()/deltaT
+        );
+
+    psiMinn =
+        V
+       *(
+           Su.field()
+         - (rho.field()/deltaT - Sp.field())*psiMinn
+         + rho.field()*psi.internalField()/deltaT
+        );
+
+    scalarField sumlPhip(psiIf.size());
+    scalarField mSumlPhim(psiIf.size());
+
+    for (int j=0; j<nLimiterIter; j++)
+    {
+        sumlPhip = 0.0;
+        mSumlPhim = 0.0;
+
+        forAll(lambdaIf, facei)
+        {
+            label own = owner[facei];
+            label nei = neighb[facei];
+
+            scalar lambdaPhiCorrf = lambdaIf[facei]*phiCorrIf[facei];
+
+            if (lambdaPhiCorrf > 0.0)
+            {
+                sumlPhip[own] += lambdaPhiCorrf;
+                mSumlPhim[nei] += lambdaPhiCorrf;
+            }
+            else
+            {
+                mSumlPhim[own] -= lambdaPhiCorrf;
+                sumlPhip[nei] -= lambdaPhiCorrf;
+            }
+        }
+
+        forAll(lambdaBf, patchi)
+        {
+            scalarField& lambdaPf = lambdaBf[patchi];
+            const scalarField& phiCorrfPf = phiCorrBf[patchi];
+
+            const labelList& pFaceCells = mesh.boundary()[patchi].faceCells();
+
+            forAll(lambdaPf, pFacei)
+            {
+                label pfCelli = pFaceCells[pFacei];
+
+                scalar lambdaPhiCorrf = lambdaPf[pFacei]*phiCorrfPf[pFacei];
+
+                if (lambdaPhiCorrf > 0.0)
+                {
+                    sumlPhip[pfCelli] += lambdaPhiCorrf;
+                }
+                else
+                {
+                    mSumlPhim[pfCelli] -= lambdaPhiCorrf;
+                }
+            }
+        }
+
+        forAll(sumlPhip, celli)
+        {
+            sumlPhip[celli] =
+                max(min
+                (
+                    (sumlPhip[celli] + psiMaxn[celli])/mSumPhim[celli],
+                    1.0), 0.0
+                );
+
+            mSumlPhim[celli] =
+                max(min
+                (
+                    (mSumlPhim[celli] + psiMinn[celli])/sumPhip[celli],
+                    1.0), 0.0
+                );
+        }
+
+        const scalarField& lambdam = sumlPhip;
+        const scalarField& lambdap = mSumlPhim;
+
+        forAll(lambdaIf, facei)
+        {
+            if (phiCorrIf[facei] > 0.0)
+            {
+                lambdaIf[facei] = min
+                (
+                    lambdaIf[facei],
+                    min(lambdap[owner[facei]], lambdam[neighb[facei]])
+                );
+            }
+            else
+            {
+                lambdaIf[facei] = min
+                (
+                    lambdaIf[facei],
+                    min(lambdam[owner[facei]], lambdap[neighb[facei]])
+                );
+            }
+        }
+
+
+        forAll(lambdaBf, patchi)
+        {
+            fvsPatchScalarField& lambdaPf = lambdaBf[patchi];
+            const scalarField& phiCorrfPf = phiCorrBf[patchi];
+            const fvPatchScalarField& psiPf = psiBf[patchi];
+
+            if (isA<wedgeFvPatch>(mesh.boundary()[patchi]))
+            {
+                lambdaPf = 0;
+            }
+            else if (psiPf.coupled())
+            {
+                const labelList& pFaceCells =
+                    mesh.boundary()[patchi].faceCells();
+
+                forAll(lambdaPf, pFacei)
+                {
+                    label pfCelli = pFaceCells[pFacei];
+
+                    if (phiCorrfPf[pFacei] > 0.0)
+                    {
+                        lambdaPf[pFacei] =
+                            min(lambdaPf[pFacei], lambdap[pfCelli]);
+                    }
+                    else
+                    {
+                        lambdaPf[pFacei] =
+                            min(lambdaPf[pFacei], lambdam[pfCelli]);
+                    }
+                }
+            }
+            else
+            {
+                const labelList& pFaceCells =
+                    mesh.boundary()[patchi].faceCells();
+                const scalarField& phiCorrPf = phiCorrBf[patchi];
+
+                forAll(lambdaPf, pFacei)
+                {
+                    // Limit outlet faces only
+                    if (phiCorrPf[pFacei] > 0)
+                    {
+                        label pfCelli = pFaceCells[pFacei];
+
+                        if (phiCorrfPf[pFacei] > 0.0)
+                        {
+                            lambdaPf[pFacei] =
+                                min(lambdaPf[pFacei], lambdap[pfCelli]);
+                        }
+                        else
+                        {
+                            lambdaPf[pFacei] =
+                                min(lambdaPf[pFacei], lambdam[pfCelli]);
+                        }
+                    }
+                }
+            }
+        }
+
+        syncTools::syncFaceList(mesh, allLambda, minEqOp<scalar>());
+    }
+}
+
+
+template<class RhoType, class SpType, class SuType>
+void Foam::MULES::limitCorr
+(
+    const RhoType& rho,
+    const volScalarField& psi,
+    surfaceScalarField& phiCorr,
+    const SpType& Sp,
+    const SuType& Su,
+    const scalar psiMax,
+    const scalar psiMin,
+    const label nLimiterIter
+)
+{
+    const fvMesh& mesh = psi.mesh();
+
+    scalarField allLambda(mesh.nFaces(), 1.0);
+
+    slicedSurfaceScalarField lambda
+    (
+        IOobject
+        (
+            "lambda",
+            mesh.time().timeName(),
+            mesh,
+            IOobject::NO_READ,
+            IOobject::NO_WRITE,
+            false
+        ),
+        mesh,
+        dimless,
+        allLambda,
+        false   // Use slices for the couples
+    );
+
+    limiterCorr
+    (
+        allLambda,
+        rho,
+        psi,
+        phiCorr,
+        Sp,
+        Su,
+        psiMax,
+        psiMin,
+        nLimiterIter
+    );
+
+    phiCorr *= lambda;
+}
+
+
 template<class SurfaceScalarFieldList>
 void Foam::MULES::limitSum(SurfaceScalarFieldList& phiPsiCorrs)
 {

src/fvAgglomerationMethods/MGridGenGamgAgglomeration/MGridGenGAMGAgglomeration.C

@@ -119,7 +119,8 @@ Foam::MGridGenGAMGAgglomeration::MGridGenGAMGAgglomeration
                 new scalarField(meshLevels_[nCreatedLevels].size())
             );
 
-            restrictField(*aggVPtr, *VPtr, nCreatedLevels);
+            // Restrict but no parallel agglomeration (not supported)
+            restrictField(*aggVPtr, *VPtr, nCreatedLevels, false);
 
             if (nCreatedLevels)
             {
@@ -157,7 +158,8 @@ Foam::MGridGenGAMGAgglomeration::MGridGenGAMGAgglomeration
                 new scalarField(meshLevels_[nCreatedLevels].size())
             );
 
-            restrictField(*aggSbPtr, *SbPtr, nCreatedLevels);
+            // Restrict but no parallel agglomeration (not supported)
+            restrictField(*aggSbPtr, *SbPtr, nCreatedLevels, false);
 
             delete SbPtr;
             SbPtr = aggSbPtr;

src/fvAgglomerationMethods/pairPatchAgglomeration/pairPatchAgglomeration.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -43,8 +43,10 @@ bool Foam::pairPatchAgglomeration::continueAgglomerating
 )
 {
     // Check the need for further agglomeration on all processors
-    bool contAgg = nCoarseFaces >= nFacesInCoarsestLevel_;
-    reduce(contAgg, andOp<bool>());
+    label localnCoarseFaces = nCoarseFaces;
+//     reduce(localnCoarseFaces, sumOp<label>());
+    bool contAgg = localnCoarseFaces >= nFacesInCoarsestLevel_;
+    //reduce(contAgg, andOp<bool>());
     return contAgg;
 }
 
@@ -263,6 +265,11 @@ bool Foam::pairPatchAgglomeration::agglomeratePatch
         )   << "min(fineToCoarse) == -1" << exit(FatalError);
     }
 
+    if (fineToCoarse.size() == 0)
+    {
+        return true;
+    }
+
     if (fineToCoarse.size() != patch.size())
     {
         FatalErrorIn
@@ -282,6 +289,7 @@ bool Foam::pairPatchAgglomeration::agglomeratePatch
     const label nCoarseI =  max(fineToCoarse)+1;
     List<face> patchFaces(nCoarseI);
 
+
     // Patch faces per agglomeration
     labelListList coarseToFine(invertOneToMany(nCoarseI, fineToCoarse));
 
@@ -335,6 +343,7 @@ bool Foam::pairPatchAgglomeration::agglomeratePatch
             patch.points()
         )
     );
+
     return true;
 }
 
@@ -343,59 +352,73 @@ void Foam::pairPatchAgglomeration:: agglomerate()
 {
     label nPairLevels = 0;
     label nCreatedLevels = 1; //0 level is the base patch
+    label nCoarseFaces = 0;
+    label nCoarseFacesOld = 0;
 
     while (nCreatedLevels < maxLevels_)
     {
-        label nCoarseCells = -1;
-
         const bPatch& patch = patchLevels_[nCreatedLevels - 1];
         tmp<labelField> finalAgglomPtr(new labelField(patch.size()));
 
         bool agglomOK = false;
-        while (!agglomOK && patch.size())
+        while (!agglomOK)
         {
             finalAgglomPtr = agglomerateOneLevel
             (
-                nCoarseCells,
+                nCoarseFaces,
                 patch
             );
 
-            agglomOK = agglomeratePatch
-            (
-                patch,
-                finalAgglomPtr,
-                nCreatedLevels
-            );
+            if (nCoarseFaces > 0)
+            {
+                agglomOK = agglomeratePatch
+                (
+                    patch,
+                    finalAgglomPtr,
+                    nCreatedLevels
+                );
+
+                restrictAddressing_.set(nCreatedLevels, finalAgglomPtr);
+                mapBaseToTopAgglom(nCreatedLevels);
+                setEdgeWeights(nCreatedLevels);
+
+                if (nPairLevels % mergeLevels_)
+                {
+                    combineLevels(nCreatedLevels);
+                }
+                else
+                {
+                    nCreatedLevels++;
+                }
+
+                nPairLevels++;
+            }
+            else
+            {
+                agglomOK = true;
+            }
+            reduce(nCoarseFaces, sumOp<label>());
         }
 
-        nFaces_[nCreatedLevels] = nCoarseCells;
-        restrictAddressing_.set(nCreatedLevels, finalAgglomPtr);
-        mapBaseToTopAgglom(nCreatedLevels);
+        nFaces_[nCreatedLevels] = nCoarseFaces;
 
-        if (!continueAgglomerating(nCoarseCells))
+        if
+        (
+            !continueAgglomerating(nCoarseFaces)
+          || (nCoarseFacesOld ==  nCoarseFaces)
+        )
         {
             break;
         }
 
-        setEdgeWeights(nCreatedLevels);
-
-        if (nPairLevels % mergeLevels_)
-        {
-            combineLevels(nCreatedLevels);
-        }
-        else
-        {
-            nCreatedLevels++;
-        }
-
-        nPairLevels++;
+        nCoarseFacesOld = nCoarseFaces;
     }
 }
 
 
 Foam::tmp<Foam::labelField> Foam::pairPatchAgglomeration::agglomerateOneLevel
 (
-    label& nCoarseCells,
+    label& nCoarseFaces,
     const bPatch& patch
 )
 {
@@ -406,7 +429,7 @@ Foam::tmp<Foam::labelField> Foam::pairPatchAgglomeration::agglomerateOneLevel
 
     const labelListList& faceFaces = patch.faceFaces();
 
-    nCoarseCells = 0;
+    nCoarseFaces = 0;
 
     forAll(faceFaces, facei)
     {
@@ -440,9 +463,9 @@ Foam::tmp<Foam::labelField> Foam::pairPatchAgglomeration::agglomerateOneLevel
             if (matchFaceNo >= 0)
             {
                 // Make a new group
-                coarseCellMap[matchFaceNo] = nCoarseCells;
-                coarseCellMap[matchFaceNeibNo] = nCoarseCells;
-                nCoarseCells++;
+                coarseCellMap[matchFaceNo] = nCoarseFaces;
+                coarseCellMap[matchFaceNeibNo] = nCoarseFaces;
+                nCoarseFaces++;
             }
             else
             {
@@ -475,8 +498,8 @@ Foam::tmp<Foam::labelField> Foam::pairPatchAgglomeration::agglomerateOneLevel
                 else
                 {
                     // if not create single-cell "clusters" for each
-                    coarseCellMap[facei] = nCoarseCells;
-                    nCoarseCells ++;
+                    coarseCellMap[facei] = nCoarseFaces;
+                    nCoarseFaces ++;
                 }
             }
         }

src/lagrangian/distributionModels/uniform/uniform.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -47,8 +47,7 @@ Foam::distributionModels::uniform::uniform
 :
     distributionModel(typeName, dict, rndGen),
     minValue_(readScalar(distributionModelDict_.lookup("minValue"))),
-    maxValue_(readScalar(distributionModelDict_.lookup("maxValue"))),
-    range_(maxValue_ - minValue_)
+    maxValue_(readScalar(distributionModelDict_.lookup("maxValue")))
 {
     check();
 }

src/lagrangian/distributionModels/uniform/uniform.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -60,9 +60,6 @@ class uniform
         //- Distribution maximum
         scalar maxValue_;
 
-        //- Distribution range
-        scalar range_;
-
 
 public:
 

src/lagrangian/intermediate/Make/files

@@ -25,7 +25,7 @@ $(KINEMATICCOLLIDINGPARCEL)/makeBasicKinematicCollidingParcelSubmodels.C
 
 
 /* thermo parcel sub-models */
-THERMOPARCEL=$(DERIVEDPARCELS)/fluidThermoParcel
+THERMOPARCEL=$(DERIVEDPARCELS)/basicThermoParcel
 $(THERMOPARCEL)/defineBasicThermoParcel.C
 $(THERMOPARCEL)/makeBasicThermoParcelSubmodels.C
 

src/lagrangian/intermediate/clouds/Templates/KinematicCloud/KinematicCloud.C

@@ -31,6 +31,7 @@ License
 #include "InjectionModelList.H"
 #include "DispersionModel.H"
 #include "PatchInteractionModel.H"
+#include "StochasticCollisionModel.H"
 #include "SurfaceFilmModel.H"
 
 // * * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * //
@@ -56,6 +57,15 @@ void Foam::KinematicCloud<CloudType>::setModels()
         ).ptr()
     );
 
+    stochasticCollisionModel_.reset
+    (
+        StochasticCollisionModel<KinematicCloud<CloudType> >::New
+        (
+            subModelProperties_,
+            *this
+        ).ptr()
+    );
+
     surfaceFilmModel_.reset
     (
         SurfaceFilmModel<KinematicCloud<CloudType> >::New
@@ -181,7 +191,6 @@ void Foam::KinematicCloud<CloudType>::evolveCloud(TrackData& td)
         if (preInjectionSize != this->size())
         {
             updateCellOccupancy();
-
             preInjectionSize = this->size();
         }
 
@@ -191,6 +200,8 @@ void Foam::KinematicCloud<CloudType>::evolveCloud(TrackData& td)
         // Assume that motion will update the cellOccupancy as necessary
         // before it is required.
         td.cloud().motion(td);
+
+        stochasticCollision().update(solution_.trackTime());
     }
     else
     {
@@ -249,6 +260,7 @@ void Foam::KinematicCloud<CloudType>::cloudReset(KinematicCloud<CloudType>& c)
 
     dispersionModel_.reset(c.dispersionModel_.ptr());
     patchInteractionModel_.reset(c.patchInteractionModel_.ptr());
+    stochasticCollisionModel_.reset(c.stochasticCollisionModel_.ptr());
     surfaceFilmModel_.reset(c.surfaceFilmModel_.ptr());
 
     UIntegrator_.reset(c.UIntegrator_.ptr());
@@ -338,6 +350,7 @@ Foam::KinematicCloud<CloudType>::KinematicCloud
     ),
     dispersionModel_(NULL),
     patchInteractionModel_(NULL),
+    stochasticCollisionModel_(NULL),
     surfaceFilmModel_(NULL),
     UIntegrator_(NULL),
     UTrans_
@@ -418,6 +431,7 @@ Foam::KinematicCloud<CloudType>::KinematicCloud
     injectors_(c.injectors_),
     dispersionModel_(c.dispersionModel_->clone()),
     patchInteractionModel_(c.patchInteractionModel_->clone()),
+    stochasticCollisionModel_(c.stochasticCollisionModel_->clone()),
     surfaceFilmModel_(c.surfaceFilmModel_->clone()),
     UIntegrator_(c.UIntegrator_->clone()),
     UTrans_
@@ -507,6 +521,7 @@ Foam::KinematicCloud<CloudType>::KinematicCloud
     injectors_(*this),
     dispersionModel_(NULL),
     patchInteractionModel_(NULL),
+    stochasticCollisionModel_(NULL),
     surfaceFilmModel_(NULL),
     UIntegrator_(NULL),
     UTrans_(NULL),

src/lagrangian/intermediate/clouds/Templates/KinematicCloud/KinematicCloud.H

@@ -39,6 +39,7 @@ Description
       - dispersion model
       - injection model
       - patch interaction model
+      - stochastic collision model
       - surface film model
 
 SourceFiles
@@ -84,6 +85,9 @@ class PatchInteractionModel;
 template<class CloudType>
 class SurfaceFilmModel;
 
+template<class CloudType>
+class StochasticCollisionModel;
+
 
 /*---------------------------------------------------------------------------*\
                        Class KinematicCloud Declaration
@@ -203,6 +207,10 @@ protected:
             autoPtr<PatchInteractionModel<KinematicCloud<CloudType> > >
                 patchInteractionModel_;
 
+            //- Stochastic collision model
+            autoPtr<StochasticCollisionModel<KinematicCloud<CloudType> > >
+                stochasticCollisionModel_;
+
             //- Surface film model
             autoPtr<SurfaceFilmModel<KinematicCloud<CloudType> > >
                 surfaceFilmModel_;
@@ -416,6 +424,15 @@ public:
                 inline PatchInteractionModel<KinematicCloud<CloudType> >&
                     patchInteraction();
 
+                //- Return const-access to the stochastic collision model
+                inline const
+                    StochasticCollisionModel<KinematicCloud<CloudType> >&
+                    stochasticCollision() const;
+
+                //- Return reference to the stochastic collision model
+                inline StochasticCollisionModel<KinematicCloud<CloudType> >&
+                    stochasticCollision();
+
                 //- Return const-access to the surface film model
                 inline const SurfaceFilmModel<KinematicCloud<CloudType> >&
                     surfaceFilm() const;
@@ -482,6 +499,9 @@ public:
 
             // Fields
 
+                //- Volume swept rate of parcels per cell
+                inline const tmp<volScalarField> vDotSweep() const;
+
                 //- Return the particle volume fraction field
                 //  Note: for particles belonging to this cloud only
                 inline const tmp<volScalarField> theta() const;

src/lagrangian/intermediate/clouds/Templates/KinematicCloud/KinematicCloudI.H

@@ -204,6 +204,22 @@ Foam::KinematicCloud<CloudType>::patchInteraction()
 }
 
 
+template<class CloudType>
+inline const Foam::StochasticCollisionModel<Foam::KinematicCloud<CloudType> >&
+Foam::KinematicCloud<CloudType>::stochasticCollision() const
+{
+    return stochasticCollisionModel_();
+}
+
+
+template<class CloudType>
+inline Foam::StochasticCollisionModel<Foam::KinematicCloud<CloudType> >&
+Foam::KinematicCloud<CloudType>::stochasticCollision()
+{
+    return stochasticCollisionModel_();
+}
+
+
 template<class CloudType>
 inline const Foam::SurfaceFilmModel<Foam::KinematicCloud<CloudType> >&
 Foam::KinematicCloud<CloudType>::surfaceFilm() const
@@ -571,6 +587,45 @@ Foam::KinematicCloud<CloudType>::SU(volVectorField& U) const
 }
 
 
+template<class CloudType>
+inline const Foam::tmp<Foam::volScalarField>
+Foam::KinematicCloud<CloudType>::vDotSweep() const
+{
+    tmp<volScalarField> tvDotSweep
+    (
+        new volScalarField
+        (
+            IOobject
+            (
+                this->name() + ":vDotSweep",
+                this->db().time().timeName(),
+                this->db(),
+                IOobject::NO_READ,
+                IOobject::NO_WRITE,
+                false
+            ),
+            mesh_,
+            dimensionedScalar("zero", dimless/dimTime, 0.0),
+            zeroGradientFvPatchScalarField::typeName
+        )
+    );
+
+    volScalarField& vDotSweep = tvDotSweep();
+    forAllConstIter(typename KinematicCloud<CloudType>, *this, iter)
+    {
+        const parcelType& p = iter();
+        const label cellI = p.cell();
+
+        vDotSweep[cellI] += p.nParticle()*p.areaP()*mag(p.U() - U_[cellI]);
+    }
+
+    vDotSweep.internalField() /= mesh_.V();
+    vDotSweep.correctBoundaryConditions();
+
+    return tvDotSweep;
+}
+
+
 template<class CloudType>
 inline const Foam::tmp<Foam::volScalarField>
 Foam::KinematicCloud<CloudType>::theta() const

src/lagrangian/intermediate/clouds/baseClasses/kinematicCloud/kinematicCloud.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -100,6 +100,9 @@ public:
 
             // Fields
 
+                //- Volume swept rate of parcels per cell
+                virtual const tmp<volScalarField> vDotSweep() const = 0;
+
                 //- Return the particle volume fraction field
                 //  Note: for particles belonging to this cloud only
                 virtual const tmp<volScalarField> theta() const = 0;

src/lagrangian/intermediate/clouds/derived/basicThermoCloud/basicThermoCloud.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -22,18 +22,18 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Class
-    Foam::fluidThermoCloud
+    Foam::basicThermoCloud
 
 Description
     Cloud class to introduce thermodynamic parcels
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef fluidThermoCloud_H
-#define fluidThermoCloud_H
+#ifndef basicThermoCloud_H
+#define basicThermoCloud_H
 
 #include "ThermoCloud.H"
-#include "fluidThermoParcel.H"
+#include "basicThermoParcel.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -45,10 +45,10 @@ namespace Foam
         <
             Cloud
             <
-                fluidThermoParcel
+                basicThermoParcel
             >
         >
-    > fluidThermoCloud;
+    > basicThermoCloud;
 }
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

src/lagrangian/intermediate/parcels/Templates/CollidingParcel/CollidingParcel.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -138,6 +138,8 @@ bool Foam::CollidingParcel<ParcelType>::move
                 }
 
                 p.age() += dt;
+
+                td.cloud().functions().postMove(p, cellI, dt, td.keepParticle);
             }
 
             break;

src/lagrangian/intermediate/parcels/Templates/KinematicParcel/KinematicParcel.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -520,8 +520,7 @@ public:
 
         // Helper functions
 
-            //- Return the index of the face to be used in the interpolation
-            //  routine
+            //- Return the index of the face used in the interpolation routine
             inline label faceInterpolation() const;
 
             //- Cell owner mass

src/lagrangian/intermediate/parcels/Templates/ReactingMultiphaseParcel/ReactingMultiphaseParcel.C

@@ -498,7 +498,7 @@ void Foam::ReactingMultiphaseParcel<ParcelType>::calcDevolatilisation
     const scalarField& YGasEff,
     const scalarField& YLiquidEff,
     const scalarField& YSolidEff,
-    bool& canCombust,
+    label& canCombust,
     scalarField& dMassDV,
     scalar& Sh,
     scalar& N,
@@ -512,6 +512,7 @@ void Foam::ReactingMultiphaseParcel<ParcelType>::calcDevolatilisation
     (
         !td.cloud().devolatilisation().active()
      || T < td.cloud().constProps().Tvap()
+     || canCombust == -1
     )
     {
         return;
@@ -588,7 +589,7 @@ void Foam::ReactingMultiphaseParcel<ParcelType>::calcSurfaceReactions
     const scalar d,
     const scalar T,
     const scalar mass,
-    const bool canCombust,
+    const label canCombust,
     const scalar N,
     const scalarField& YMix,
     const scalarField& YGas,
@@ -603,7 +604,7 @@ void Foam::ReactingMultiphaseParcel<ParcelType>::calcSurfaceReactions
 ) const
 {
     // Check that model is active
-    if (!td.cloud().surfaceReaction().active() || !canCombust)
+    if (!td.cloud().surfaceReaction().active() || (canCombust != 1))
     {
         return;
     }

src/lagrangian/intermediate/parcels/Templates/ReactingMultiphaseParcel/ReactingMultiphaseParcel.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -183,9 +183,13 @@ protected:
             //- Mass fractions of solids []
             scalarField YSolid_;
 
-            //- Flag to say that the particle is allowed to combust
-            //  Only true after volatile content falls below threshold value
-            bool canCombust_;
+            //- Flag to identify if the particle can devolatilise and combust
+            //  Combustion possible only after volatile content falls below
+            //  threshold value.  States include:
+            //  0 = can devolatilise, cannot combust but can change
+            //  1 = can devolatilise, can combust
+            // -1 = cannot devolatilise or combust, and cannot change
+            label canCombust_;
 
 
     // Protected Member Functions
@@ -205,7 +209,7 @@ protected:
             const scalarField& YGasEff,// gas component mass fractions
             const scalarField& YLiquidEff,// liquid component mass fractions
             const scalarField& YSolidEff,// solid component mass fractions
-            bool& canCombust,          // 'can combust' flag
+            label& canCombust,          // 'can combust' flag
             scalarField& dMassDV,      // mass transfer - local to particle
             scalar& Sh,                // explicit particle enthalpy source
             scalar& N,                 // flux of species emitted from particle
@@ -223,7 +227,7 @@ protected:
             const scalar d,            // diameter
             const scalar T,            // temperature
             const scalar mass,         // mass
-            const bool canCombust,     // 'can combust' flag
+            const label canCombust,     // 'can combust' flag
             const scalar N,            // flux of species emitted from particle
             const scalarField& YMix,   // mixture mass fractions
             const scalarField& YGas,   // gas-phase mass fractions
@@ -362,7 +366,7 @@ public:
             inline const scalarField& YSolid() const;
 
             //- Return const access to the canCombust flag
-            inline bool canCombust() const;
+            inline label canCombust() const;
 
 
         // Edit
@@ -377,7 +381,7 @@ public:
             inline scalarField& YSolid();
 
             //- Return access to the canCombust flag
-            inline bool& canCombust();
+            inline label& canCombust();
 
 
         // Main calculation loop

src/lagrangian/intermediate/parcels/Templates/ReactingMultiphaseParcel/ReactingMultiphaseParcelI.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -94,7 +94,7 @@ inline Foam::ReactingMultiphaseParcel<ParcelType>::ReactingMultiphaseParcel
     YGas_(0),
     YLiquid_(0),
     YSolid_(0),
-    canCombust_(false)
+    canCombust_(0)
 {}
 
 
@@ -142,7 +142,7 @@ inline Foam::ReactingMultiphaseParcel<ParcelType>::ReactingMultiphaseParcel
     YGas_(YGas0),
     YLiquid_(YLiquid0),
     YSolid_(YSolid0),
-    canCombust_(false)
+    canCombust_(0)
 {}
 
 
@@ -192,7 +192,8 @@ YSolid() const
 
 
 template<class ParcelType>
-inline bool Foam::ReactingMultiphaseParcel<ParcelType>::canCombust() const
+inline Foam::label
+Foam::ReactingMultiphaseParcel<ParcelType>::canCombust() const
 {
     return canCombust_;
 }
@@ -220,7 +221,7 @@ inline Foam::scalarField& Foam::ReactingMultiphaseParcel<ParcelType>::YSolid()
 
 
 template<class ParcelType>
-inline bool& Foam::ReactingMultiphaseParcel<ParcelType>::canCombust()
+inline Foam::label& Foam::ReactingMultiphaseParcel<ParcelType>::canCombust()
 {
     return canCombust_;
 }

src/lagrangian/intermediate/parcels/Templates/ReactingMultiphaseParcel/ReactingMultiphaseParcelIO.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -47,7 +47,7 @@ Foam::ReactingMultiphaseParcel<ParcelType>::ReactingMultiphaseParcel
     YGas_(0),
     YLiquid_(0),
     YSolid_(0),
-    canCombust_(false)
+    canCombust_(0)
 {
     if (readFields)
     {

src/lagrangian/intermediate/parcels/Templates/ReactingParcel/ReactingParcel.C

@@ -32,6 +32,169 @@ using namespace Foam::constant::mathematical;
 
 // * * * * * * * * * * *  Protected Member Functions * * * * * * * * * * * * //
 
+template<class ParcelType>
+template<class TrackData>
+void Foam::ReactingParcel<ParcelType>::calcPhaseChange
+(
+    TrackData& td,
+    const scalar dt,
+    const label cellI,
+    const scalar Re,
+    const scalar Pr,
+    const scalar Ts,
+    const scalar nus,
+    const scalar d,
+    const scalar T,
+    const scalar mass,
+    const label idPhase,
+    const scalar YPhase,
+    const scalarField& YComponents,
+    scalarField& dMassPC,
+    scalar& Sh,
+    scalar& N,
+    scalar& NCpW,
+    scalarField& Cs
+)
+{
+    if
+    (
+        !td.cloud().phaseChange().active()
+     || T < td.cloud().constProps().Tvap()
+     || YPhase < SMALL
+    )
+    {
+        return;
+    }
+
+    typedef typename TrackData::cloudType::reactingCloudType reactingCloudType;
+    const CompositionModel<reactingCloudType>& composition =
+        td.cloud().composition();
+
+    const scalar TMax = td.cloud().phaseChange().TMax(pc_, this->Tc_);
+    const scalar Tdash = min(T, TMax);
+    const scalar Tsdash = min(Ts, TMax);
+
+    // Calculate mass transfer due to phase change
+    td.cloud().phaseChange().calculate
+    (
+        dt,
+        cellI,
+        Re,
+        Pr,
+        d,
+        nus,
+        Tdash,
+        Tsdash,
+        pc_,
+        this->Tc_,
+        YComponents,
+        dMassPC
+    );
+
+    // Limit phase change mass by availability of each specie
+    dMassPC = min(mass*YPhase*YComponents, dMassPC);
+
+    const scalar dMassTot = sum(dMassPC);
+
+    // Add to cumulative phase change mass
+    td.cloud().phaseChange().addToPhaseChangeMass(this->nParticle_*dMassTot);
+
+    forAll(dMassPC, i)
+    {
+        const label idc = composition.localToGlobalCarrierId(idPhase, i);
+        const label idl = composition.globalIds(idPhase)[i];
+
+        const scalar dh = td.cloud().phaseChange().dh(idc, idl, pc_, Tdash);
+        Sh -= dMassPC[i]*dh/dt;
+    }
+
+
+    // Update molar emissions
+    if (td.cloud().heatTransfer().BirdCorrection())
+    {
+        // Average molecular weight of carrier mix - assumes perfect gas
+        const scalar Wc = this->rhoc_*specie::RR*this->Tc_/this->pc_;
+
+
+        forAll(dMassPC, i)
+        {
+            const label idc = composition.localToGlobalCarrierId(idPhase, i);
+            const label idl = composition.globalIds(idPhase)[i];
+
+            const scalar Cp = composition.carrier().Cp(idc, pc_, Tsdash);
+            const scalar W = composition.carrier().W(idc);
+            const scalar Ni = dMassPC[i]/(this->areaS(d)*dt*W);
+
+            const scalar Dab =
+                composition.liquids().properties()[idl].D(pc_, Tsdash, Wc);
+
+            // Molar flux of species coming from the particle (kmol/m^2/s)
+            N += Ni;
+
+            // Sum of Ni*Cpi*Wi of emission species
+            NCpW += Ni*Cp*W;
+
+            // Concentrations of emission species
+            Cs[idc] += Ni*d/(2.0*Dab);
+        }
+    }
+}
+
+
+template<class ParcelType>
+Foam::scalar Foam::ReactingParcel<ParcelType>::updateMassFraction
+(
+    const scalar mass0,
+    const scalarField& dMass,
+    scalarField& Y
+) const
+{
+    scalar mass1 = mass0 - sum(dMass);
+
+    // only update the mass fractions if the new particle mass is finite
+    if (mass1 > ROOTVSMALL)
+    {
+        forAll(Y, i)
+        {
+            Y[i] = (Y[i]*mass0 - dMass[i])/mass1;
+        }
+    }
+
+    return mass1;
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+template<class ParcelType>
+Foam::ReactingParcel<ParcelType>::ReactingParcel
+(
+    const ReactingParcel<ParcelType>& p
+)
+:
+    ParcelType(p),
+    mass0_(p.mass0_),
+    Y_(p.Y_),
+    pc_(p.pc_)
+{}
+
+
+template<class ParcelType>
+Foam::ReactingParcel<ParcelType>::ReactingParcel
+(
+    const ReactingParcel<ParcelType>& p,
+    const polyMesh& mesh
+)
+:
+    ParcelType(p, mesh),
+    mass0_(p.mass0_),
+    Y_(p.Y_),
+    pc_(p.pc_)
+{}
+
+
+// * * * * * * * * * * * * *  Member Functions * * * * * * * * * * * * * * * //
+
 template<class ParcelType>
 template<class TrackData>
 void Foam::ReactingParcel<ParcelType>::setCellValues
@@ -165,7 +328,7 @@ void Foam::ReactingParcel<ParcelType>::correctSurfaceValues
     const SLGThermo& thermo = td.cloud().thermo();
 
     // Far field carrier  molar fractions
-    scalarField Xinf(td.cloud().thermo().carrier().species().size());
+    scalarField Xinf(thermo.carrier().species().size());
 
     forAll(Xinf, i)
     {
@@ -234,29 +397,6 @@ void Foam::ReactingParcel<ParcelType>::correctSurfaceValues
 }
 
 
-template<class ParcelType>
-Foam::scalar Foam::ReactingParcel<ParcelType>::updateMassFraction
-(
-    const scalar mass0,
-    const scalarField& dMass,
-    scalarField& Y
-) const
-{
-    scalar mass1 = mass0 - sum(dMass);
-
-    // only update the mass fractions if the new particle mass is finite
-    if (mass1 > ROOTVSMALL)
-    {
-        forAll(Y, i)
-        {
-            Y[i] = (Y[i]*mass0 - dMass[i])/mass1;
-        }
-    }
-
-    return mass1;
-}
-
-
 template<class ParcelType>
 template<class TrackData>
 void Foam::ReactingParcel<ParcelType>::calc
@@ -472,144 +612,6 @@ void Foam::ReactingParcel<ParcelType>::calc
 }
 
 
-template<class ParcelType>
-template<class TrackData>
-void Foam::ReactingParcel<ParcelType>::calcPhaseChange
-(
-    TrackData& td,
-    const scalar dt,
-    const label cellI,
-    const scalar Re,
-    const scalar Pr,
-    const scalar Ts,
-    const scalar nus,
-    const scalar d,
-    const scalar T,
-    const scalar mass,
-    const label idPhase,
-    const scalar YPhase,
-    const scalarField& YComponents,
-    scalarField& dMassPC,
-    scalar& Sh,
-    scalar& N,
-    scalar& NCpW,
-    scalarField& Cs
-)
-{
-    if
-    (
-        !td.cloud().phaseChange().active()
-     || T < td.cloud().constProps().Tvap()
-     || YPhase < SMALL
-    )
-    {
-        return;
-    }
-
-    typedef typename TrackData::cloudType::reactingCloudType reactingCloudType;
-    const CompositionModel<reactingCloudType>& composition =
-        td.cloud().composition();
-
-    const scalar TMax = td.cloud().phaseChange().TMax(pc_, this->Tc_);
-    const scalar Tdash = min(T, TMax);
-    const scalar Tsdash = min(Ts, TMax);
-
-    // Calculate mass transfer due to phase change
-    td.cloud().phaseChange().calculate
-    (
-        dt,
-        cellI,
-        Re,
-        Pr,
-        d,
-        nus,
-        Tdash,
-        Tsdash,
-        pc_,
-        this->Tc_,
-        YComponents,
-        dMassPC
-    );
-
-    // Limit phase change mass by availability of each specie
-    dMassPC = min(mass*YPhase*YComponents, dMassPC);
-
-    const scalar dMassTot = sum(dMassPC);
-
-    // Add to cumulative phase change mass
-    td.cloud().phaseChange().addToPhaseChangeMass(this->nParticle_*dMassTot);
-
-    forAll(dMassPC, i)
-    {
-        const label idc = composition.localToGlobalCarrierId(idPhase, i);
-        const label idl = composition.globalIds(idPhase)[i];
-
-        const scalar dh = td.cloud().phaseChange().dh(idc, idl, pc_, Tdash);
-        Sh -= dMassPC[i]*dh/dt;
-    }
-
-
-    // Update molar emissions
-    if (td.cloud().heatTransfer().BirdCorrection())
-    {
-        // Average molecular weight of carrier mix - assumes perfect gas
-        const scalar Wc = this->rhoc_*specie::RR*this->Tc_/this->pc_;
-
-
-        forAll(dMassPC, i)
-        {
-            const label idc = composition.localToGlobalCarrierId(idPhase, i);
-            const label idl = composition.globalIds(idPhase)[i];
-
-            const scalar Cp = composition.carrier().Cp(idc, pc_, Tsdash);
-            const scalar W = composition.carrier().W(idc);
-            const scalar Ni = dMassPC[i]/(this->areaS(d)*dt*W);
-
-            const scalar Dab =
-                composition.liquids().properties()[idl].D(pc_, Tsdash, Wc);
-
-            // Molar flux of species coming from the particle (kmol/m^2/s)
-            N += Ni;
-
-            // Sum of Ni*Cpi*Wi of emission species
-            NCpW += Ni*Cp*W;
-
-            // Concentrations of emission species
-            Cs[idc] += Ni*d/(2.0*Dab);
-        }
-    }
-}
-
-
-// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
-
-template<class ParcelType>
-Foam::ReactingParcel<ParcelType>::ReactingParcel
-(
-    const ReactingParcel<ParcelType>& p
-)
-:
-    ParcelType(p),
-    mass0_(p.mass0_),
-    Y_(p.Y_),
-    pc_(p.pc_)
-{}
-
-
-template<class ParcelType>
-Foam::ReactingParcel<ParcelType>::ReactingParcel
-(
-    const ReactingParcel<ParcelType>& p,
-    const polyMesh& mesh
-)
-:
-    ParcelType(p, mesh),
-    mass0_(p.mass0_),
-    Y_(p.Y_),
-    pc_(p.pc_)
-{}
-
-
 // * * * * * * * * * * * * * * IOStream operators  * * * * * * * * * * * * * //
 
 #include "ReactingParcelIO.C"

src/lagrangian/intermediate/parcels/Templates/ReactingParcel/ReactingParcel.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License

src/lagrangian/intermediate/parcels/derived/basicKinematicCollidingParcel/makeBasicKinematicCollidingParcelSubmodels.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -33,6 +33,7 @@ License
 #include "makeParcelInjectionModels.H"
 #include "makeParcelCollisionModels.H"
 #include "makeParcelPatchInteractionModels.H"
+#include "makeParcelStochasticCollisionModels.H"
 #include "makeParcelSurfaceFilmModels.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@@ -47,6 +48,7 @@ namespace Foam
     makeParcelInjectionModels(basicKinematicCollidingCloud);
     makeParcelCollisionModels(basicKinematicCollidingCloud);
     makeParcelPatchInteractionModels(basicKinematicCollidingCloud);
+    makeParcelStochasticCollisionModels(basicKinematicCollidingCloud);
     makeParcelSurfaceFilmModels(basicKinematicCollidingCloud);
 }
 

src/lagrangian/intermediate/parcels/derived/basicKinematicParcel/makeBasicKinematicParcelSubmodels.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -32,6 +32,7 @@ License
 #include "makeParcelDispersionModels.H"
 #include "makeParcelInjectionModels.H"
 #include "makeParcelPatchInteractionModels.H"
+#include "makeParcelStochasticCollisionModels.H"
 #include "makeParcelSurfaceFilmModels.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@@ -45,6 +46,7 @@ namespace Foam
     makeParcelDispersionModels(basicKinematicCloud);
     makeParcelInjectionModels(basicKinematicCloud);
     makeParcelPatchInteractionModels(basicKinematicCloud);
+    makeParcelStochasticCollisionModels(basicKinematicCloud);
     makeParcelSurfaceFilmModels(basicKinematicCloud);
 }
 

src/lagrangian/intermediate/parcels/derived/basicReactingMultiphaseParcel/makeBasicReactingMultiphaseParcelSubmodels.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -32,6 +32,8 @@ License
 #include "makeParcelDispersionModels.H"
 #include "makeReactingMultiphaseParcelInjectionModels.H" // MP variant
 #include "makeParcelPatchInteractionModels.H"
+#include "makeReactingMultiphaseParcelStochasticCollisionModels.H" // MP variant
+#include "makeReactingParcelSurfaceFilmModels.H" // Reacting variant
 
 // Thermodynamic
 #include "makeParcelHeatTransferModels.H"
@@ -39,7 +41,6 @@ License
 // Reacting
 #include "makeReactingMultiphaseParcelCompositionModels.H" // MP Variant
 #include "makeReactingParcelPhaseChangeModels.H"
-#include "makeReactingParcelSurfaceFilmModels.H"
 
 // Reacting multiphase
 #include "makeReactingMultiphaseParcelDevolatilisationModels.H"
@@ -56,6 +57,11 @@ namespace Foam
     makeParcelDispersionModels(basicReactingMultiphaseCloud);
     makeReactingMultiphaseParcelInjectionModels(basicReactingMultiphaseCloud);
     makeParcelPatchInteractionModels(basicReactingMultiphaseCloud);
+    makeReactingMultiphaseParcelStochasticCollisionModels
+    (
+        basicReactingMultiphaseCloud
+    );
+    makeReactingParcelSurfaceFilmModels(basicReactingMultiphaseCloud);
 
     // Thermo sub-models
     makeParcelHeatTransferModels(basicReactingMultiphaseCloud);
@@ -72,10 +78,6 @@ namespace Foam
     (
         basicReactingMultiphaseCloud
     );
-    makeReactingParcelSurfaceFilmModels
-    (
-        basicReactingMultiphaseCloud
-    );
     makeReactingMultiphaseParcelSurfaceReactionModels
     (
         basicReactingMultiphaseCloud

src/lagrangian/intermediate/parcels/derived/basicReactingParcel/makeBasicReactingParcelSubmodels.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -32,6 +32,8 @@ License
 #include "makeParcelDispersionModels.H"
 #include "makeReactingParcelInjectionModels.H" // Reacting variant
 #include "makeParcelPatchInteractionModels.H"
+#include "makeParcelStochasticCollisionModels.H"
+#include "makeReactingParcelSurfaceFilmModels.H" // Reacting variant
 
 // Thermodynamic
 #include "makeParcelHeatTransferModels.H"
@@ -39,7 +41,6 @@ License
 // Reacting
 #include "makeReactingParcelCompositionModels.H"
 #include "makeReactingParcelPhaseChangeModels.H"
-#include "makeReactingParcelSurfaceFilmModels.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -52,6 +53,8 @@ namespace Foam
     makeParcelDispersionModels(basicReactingCloud);
     makeReactingParcelInjectionModels(basicReactingCloud);
     makeParcelPatchInteractionModels(basicReactingCloud);
+    makeParcelStochasticCollisionModels(basicReactingCloud);
+    makeReactingParcelSurfaceFilmModels(basicReactingCloud);
 
     // Thermo sub-models
     makeParcelHeatTransferModels(basicReactingCloud);
@@ -59,7 +62,6 @@ namespace Foam
     // Reacting sub-models
     makeReactingParcelCompositionModels(basicReactingCloud);
     makeReactingParcelPhaseChangeModels(basicReactingCloud);
-    makeReactingParcelSurfaceFilmModels(basicReactingCloud);
 }
 
 

src/lagrangian/intermediate/parcels/derived/basicThermoParcel/basicThermoParcel.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -22,18 +22,18 @@ License
     along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
 
 Class
-    Foam::fluidThermoParcel
+    Foam::basicThermoParcel
 
 Description
     Definition of basic thermo parcel
 
 SourceFiles
-    fluidThermoParcel.C
+    basicThermoParcel.C
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef fluidThermoParcel_H
-#define fluidThermoParcel_H
+#ifndef basicThermoParcel_H
+#define basicThermoParcel_H
 
 #include "contiguous.H"
 #include "particle.H"
@@ -44,10 +44,10 @@ SourceFiles
 
 namespace Foam
 {
-    typedef ThermoParcel<KinematicParcel<particle> > fluidThermoParcel;
+    typedef ThermoParcel<KinematicParcel<particle> > basicThermoParcel;
 
     template<>
-    inline bool contiguous<fluidThermoParcel>()
+    inline bool contiguous<basicThermoParcel>()
     {
         return true;
     }

src/lagrangian/intermediate/parcels/derived/basicThermoParcel/defineBasicThermoParcel.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -23,15 +23,15 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-#include "fluidThermoParcel.H"
+#include "basicThermoParcel.H"
 #include "Cloud.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 namespace Foam
 {
-    defineTemplateTypeNameAndDebug(fluidThermoParcel, 0);
-    defineTemplateTypeNameAndDebug(Cloud<fluidThermoParcel>, 0);
+    defineTemplateTypeNameAndDebug(basicThermoParcel, 0);
+    defineTemplateTypeNameAndDebug(Cloud<basicThermoParcel>, 0);
 }
 
 // ************************************************************************* //

src/lagrangian/intermediate/parcels/derived/basicThermoParcel/makeBasicThermoParcelSubmodels.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -23,7 +23,7 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-#include "fluidThermoCloud.H"
+#include "basicThermoCloud.H"
 
 #include "makeParcelCloudFunctionObjects.H"
 
@@ -32,26 +32,28 @@ License
 #include "makeParcelDispersionModels.H"
 #include "makeParcelInjectionModels.H"
 #include "makeParcelPatchInteractionModels.H"
+#include "makeParcelStochasticCollisionModels.H"
+#include "makeThermoParcelSurfaceFilmModels.H" // thermo variant
 
 // Thermodynamic
 #include "makeParcelHeatTransferModels.H"
-#include "makeThermoParcelSurfaceFilmModels.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 namespace Foam
 {
-    makeParcelCloudFunctionObjects(fluidThermoCloud);
+    makeParcelCloudFunctionObjects(basicThermoCloud);
 
     // Kinematic sub-models
-    makeThermoParcelForces(fluidThermoCloud);
-    makeParcelDispersionModels(fluidThermoCloud);
-    makeParcelInjectionModels(fluidThermoCloud);
-    makeParcelPatchInteractionModels(fluidThermoCloud);
+    makeThermoParcelForces(basicThermoCloud);
+    makeParcelDispersionModels(basicThermoCloud);
+    makeParcelInjectionModels(basicThermoCloud);
+    makeParcelPatchInteractionModels(basicThermoCloud);
+    makeParcelStochasticCollisionModels(basicThermoCloud);
+    makeParcelSurfaceFilmModels(basicThermoCloud);
 
     // Thermo sub-models
-    makeParcelHeatTransferModels(fluidThermoCloud);
-    makeParcelSurfaceFilmModels(fluidThermoCloud);
+    makeParcelHeatTransferModels(basicThermoCloud);
 }
 
 

src/lagrangian/intermediate/parcels/include/makeParcelStochasticCollisionModels.H

@@ -0,0 +1,45 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef makeParcelStochasticCollisionModels_H
+#define makeParcelStochasticCollisionModels_H
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#include "NoStochasticCollision.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#define makeParcelStochasticCollisionModels(CloudType)                             \
+                                                                              \
+    makeStochasticCollisionModel(CloudType);                                  \
+    makeStochasticCollisionModelType(NoStochasticCollision, CloudType);
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/lagrangian/intermediate/parcels/include/makeReactingMultiphaseParcelStochasticCollisionModels.H

@@ -0,0 +1,47 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef makeReactingMultiphaseParcelStochasticCollisionModels_H
+#define makeReactingMultiphaseParcelStochasticCollisionModels_H
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#include "NoStochasticCollision.H"
+#include "SuppressionCollision.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#define makeReactingMultiphaseParcelStochasticCollisionModels(CloudType)      \
+                                                                              \
+    makeStochasticCollisionModel(CloudType);                                  \
+    makeStochasticCollisionModelType(NoStochasticCollision, CloudType);       \
+    makeStochasticCollisionModelType(SuppressionCollision, CloudType);
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/lagrangian/intermediate/submodels/Kinematic/StochasticCollision/NoStochasticCollision/NoStochasticCollision.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -25,6 +25,15 @@ License
 
 #include "NoStochasticCollision.H"
 
+// * * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * //
+
+template<class CloudType>
+void Foam::NoStochasticCollision<CloudType>::collide(const scalar)
+{
+    // do nothing
+}
+
+
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
 template<class CloudType>
@@ -64,37 +73,4 @@ bool Foam::NoStochasticCollision<CloudType>::active() const
 }
 
 
-template<class CloudType>
-bool Foam::NoStochasticCollision<CloudType>::update
-(
-    const scalar dt,
-    cachedRandom& rndGen,
-    vector& pos1,
-    scalar& m1,
-    scalar& d1,
-    scalar& N1,
-    vector& U,
-    scalar& rho1,
-    scalar& T1,
-    scalarField& Y1,
-    const scalar sigma1,
-    const label celli,
-    const scalar voli,
-    vector& pos2,
-    scalar& m2,
-    scalar& d2,
-    scalar& N2,
-    vector& U2,
-    scalar& rho2,
-    scalar& T2,
-    scalarField& Y2,
-    const scalar sigma2,
-    const label cellj,
-    const scalar volj
-) const
-{
-    return false;
-}
-
-
 // ************************************************************************* //

src/lagrangian/intermediate/submodels/Kinematic/StochasticCollision/NoStochasticCollision/NoStochasticCollision.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -39,7 +39,7 @@ Description
 namespace Foam
 {
 /*---------------------------------------------------------------------------*\
-                       Class NoStochasticCollision Declaration
+                    Class NoStochasticCollision Declaration
 \*---------------------------------------------------------------------------*/
 
 template<class CloudType>
@@ -47,6 +47,14 @@ class NoStochasticCollision
 :
     public StochasticCollisionModel<CloudType>
 {
+protected:
+
+    // Protected Member Functions
+
+        //- Update the model
+        virtual void collide(const scalar dt);
+
+
 public:
 
     //- Runtime type information
@@ -79,34 +87,6 @@ public:
 
         //- Flag to indicate whether model activates collision model
         virtual bool active() const;
-
-        virtual bool update
-        (
-            const scalar dt,
-            cachedRandom& rndGen,
-            vector& pos1,
-            scalar& m1,
-            scalar& d1,
-            scalar& N1,
-            vector& U,
-            scalar& rho1,
-            scalar& T1,
-            scalarField& Y1,
-            const scalar sigma1,
-            const label celli,
-            const scalar voli,
-            vector& pos2,
-            scalar& m2,
-            scalar& d2,
-            scalar& N2,
-            vector& U2,
-            scalar& rho2,
-            scalar& T2,
-            scalarField& Y2,
-            const scalar sigma2,
-            const label cellj,
-            const scalar volj
-        ) const;
 };
 
 

src/lagrangian/intermediate/submodels/Kinematic/StochasticCollision/StochasticCollisionModel/StochasticCollisionModel.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -25,6 +25,18 @@ License
 
 #include "StochasticCollisionModel.H"
 
+// * * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * //
+
+template<class CloudType>
+void Foam::StochasticCollisionModel<CloudType>::collide(const scalar dt)
+{
+    notImplemented
+    (
+        "void Foam::NoStochasticCollision<CloudType>::collide(const scalar)"
+    );
+}
+
+
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
 template<class CloudType>
@@ -69,66 +81,12 @@ Foam::StochasticCollisionModel<CloudType>::~StochasticCollisionModel()
 // * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
 
 template<class CloudType>
-bool Foam::StochasticCollisionModel<CloudType>::update
-(
-    const scalar dt,
-    cachedRandom& rndGen,
-    vector& pos1,
-    scalar& m1,
-    scalar& d1,
-    scalar& N1,
-    vector& U1,
-    scalar& rho1,
-    scalar& T1,
-    scalarField& Y1,
-    const scalar sigma1,
-    const label celli,
-    const scalar voli,
-    vector& pos2,
-    scalar& m2,
-    scalar& d2,
-    scalar& N2,
-    vector& U2,
-    scalar& rho2,
-    scalar& T2,
-    scalarField& Y2,
-    const scalar sigma2,
-    const label cellj,
-    const scalar volj
-) const
+void Foam::StochasticCollisionModel<CloudType>::update(const scalar dt)
 {
-    notImplemented
-    (
-        "bool Foam::StochasticCollisionModel<CloudType>::update"
-        "("
-            "const scalar, "
-            "cachedRandom&, "
-            "vector&, "
-            "scalar&, "
-            "scalar&, "
-            "scalar&, "
-            "vector&, "
-            "scalar&, "
-            "scalar&, "
-            "scalarField&, "
-            "const scalar, "
-            "const label, "
-            "const scalar, "
-            "vector&, "
-            "scalar&, "
-            "scalar&, "
-            "scalar&, "
-            "vector&, "
-            "scalar&, "
-            "scalar&, "
-            "scalarField&, "
-            "const scalar, "
-            "const label, "
-            "const scalar"
-        ") const"
-    );
-
-    return false;
+    if (this->active())
+    {
+        this->collide(dt);
+    }
 }
 
 
@@ -137,4 +95,3 @@ bool Foam::StochasticCollisionModel<CloudType>::update
 #include "StochasticCollisionModelNew.C"
 
 // ************************************************************************* //
-

src/lagrangian/intermediate/submodels/Kinematic/StochasticCollision/StochasticCollisionModel/StochasticCollisionModel.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -55,6 +55,12 @@ class StochasticCollisionModel
 :
     public SubModelBase<CloudType>
 {
+protected:
+
+    //- Main collision routine
+    virtual void collide(const scalar dt);
+
+
 public:
 
     //- Runtime type information
@@ -114,33 +120,8 @@ public:
 
     // Member Functions
 
-        virtual bool update
-        (
-            const scalar dt,
-            cachedRandom& rndGen,
-            vector& pos1,
-            scalar& m1,
-            scalar& d1,
-            scalar& N1,
-            vector& U1,
-            scalar& rho1,
-            scalar& T1,
-            scalarField& Y1,
-            const scalar sigma1,
-            const label celli,
-            const scalar voli,
-            vector& pos2,
-            scalar& m2,
-            scalar& d2,
-            scalar& N2,
-            vector& U2,
-            scalar& rho2,
-            scalar& T2,
-            scalarField& Y2,
-            const scalar sigma2,
-            const label cellj,
-            const scalar volj
-        ) const;
+        //- Update the model
+        void update(const scalar dt);
 };
 
 
@@ -152,27 +133,27 @@ public:
 
 #define makeStochasticCollisionModel(CloudType)                                         \
                                                                               \
-    typedef CloudType::sprayCloudType sprayCloudType;                         \
+    typedef CloudType::kinematicCloudType kinematicCloudType;                 \
     defineNamedTemplateTypeNameAndDebug                                       \
     (                                                                         \
-        StochasticCollisionModel<sprayCloudType>,                             \
+        StochasticCollisionModel<kinematicCloudType>,                         \
         0                                                                     \
     );                                                                        \
     defineTemplateRunTimeSelectionTable                                       \
     (                                                                         \
-        StochasticCollisionModel<sprayCloudType>,                             \
+        StochasticCollisionModel<kinematicCloudType>,                         \
         dictionary                                                            \
     );
 
 
 #define makeStochasticCollisionModelType(SS, CloudType)                       \
                                                                               \
-    typedef CloudType::sprayCloudType sprayCloudType;                         \
-    defineNamedTemplateTypeNameAndDebug(SS<sprayCloudType>, 0);               \
+    typedef CloudType::kinematicCloudType kinematicCloudType;                 \
+    defineNamedTemplateTypeNameAndDebug(SS<kinematicCloudType>, 0);           \
                                                                               \
-    StochasticCollisionModel<sprayCloudType>::                                \
-        adddictionaryConstructorToTable<SS<sprayCloudType> >                  \
-            add##SS##CloudType##sprayCloudType##ConstructorToTable_;
+    StochasticCollisionModel<kinematicCloudType>::                            \
+        adddictionaryConstructorToTable<SS<kinematicCloudType> >              \
+            add##SS##CloudType##kinematicCloudType##ConstructorToTable_;
 
 
 

src/lagrangian/intermediate/submodels/Kinematic/StochasticCollision/StochasticCollisionModel/StochasticCollisionModelNew.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -37,7 +37,7 @@ Foam::StochasticCollisionModel<CloudType>::New
 {
     word modelType(dict.lookup("stochasticCollisionModel"));
 
-    Info<< "Selecting StochasticCollisionModel " << modelType << endl;
+    Info<< "Selecting stochastic collision model " << modelType << endl;
 
     typename dictionaryConstructorTable::iterator cstrIter =
         dictionaryConstructorTablePtr_->find(modelType);
@@ -51,9 +51,9 @@ Foam::StochasticCollisionModel<CloudType>::New
                 "const dictionary&, "
                 "CloudType&"
             ")"
-        )   << "Unknown StochasticCollisionModelType type "
+        )   << "Unknown model type type "
             << modelType << ", constructor not in hash table" << nl << nl
-            << "    Valid StochasticCollisionModel types are:" << nl
+            << "    Valid model types are:" << nl
             << dictionaryConstructorTablePtr_->sortedToc() << exit(FatalError);
     }
 

src/lagrangian/intermediate/submodels/ReactingMultiphase/DevolatilisationModel/ConstantRateDevolatilisation/ConstantRateDevolatilisation.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -109,7 +109,7 @@ void Foam::ConstantRateDevolatilisation<CloudType>::calculate
     const scalarField& YGasEff,
     const scalarField& YLiquidEff,
     const scalarField& YSolidEff,
-    bool& canCombust,
+    label& canCombust,
     scalarField& dMassDV
 ) const
 {
@@ -130,7 +130,10 @@ void Foam::ConstantRateDevolatilisation<CloudType>::calculate
         dMassDV[id] = min(dt*A0*massVolatile0, massVolatile);
     }
 
-    canCombust = done;
+    if (done && canCombust != -1)
+    {
+        canCombust = 1;
+    }
 }
 
 

src/lagrangian/intermediate/submodels/ReactingMultiphase/DevolatilisationModel/ConstantRateDevolatilisation/ConstantRateDevolatilisation.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -111,7 +111,7 @@ public:
             const scalarField& YGasEff,
             const scalarField& YLiquidEff,
             const scalarField& YSolidEff,
-            bool& canCombust,
+            label& canCombust,
             scalarField& dMassDV
         ) const;
 };

src/lagrangian/intermediate/submodels/ReactingMultiphase/DevolatilisationModel/DevolatilisationModel/DevolatilisationModel.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -82,7 +82,7 @@ void Foam::DevolatilisationModel<CloudType>::calculate
     const scalarField&,
     const scalarField&,
     const scalarField&,
-    bool&,
+    label&,
     scalarField&
 ) const
 {
@@ -98,7 +98,7 @@ void Foam::DevolatilisationModel<CloudType>::calculate
             "const scalarField&, "
             "const scalarField&, "
             "const scalarField&, "
-            "bool&, "
+            "label&, "
             "scalarField&"
         ") const"
     );

src/lagrangian/intermediate/submodels/ReactingMultiphase/DevolatilisationModel/DevolatilisationModel/DevolatilisationModel.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -133,7 +133,7 @@ public:
             const scalarField& YGasEff,
             const scalarField& YLiquidEff,
             const scalarField& YSolidEff,
-            bool& canCombust,
+            label& canCombust,
             scalarField& dMassDV
         ) const;
 

src/lagrangian/intermediate/submodels/ReactingMultiphase/DevolatilisationModel/SingleKineticRateDevolatilisation/SingleKineticRateDevolatilisation.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -112,7 +112,7 @@ void Foam::SingleKineticRateDevolatilisation<CloudType>::calculate
     const scalarField& YGasEff,
     const scalarField& YLiquidEff,
     const scalarField& YSolidEff,
-    bool& canCombust,
+    label& canCombust,
     scalarField& dMassDV
 ) const
 {
@@ -137,7 +137,10 @@ void Foam::SingleKineticRateDevolatilisation<CloudType>::calculate
         dMassDV[id] = min(dt*kappa*massVolatile, massVolatile);
     }
 
-    canCombust = done;
+    if (done && canCombust != -1)
+    {
+        canCombust = 1;
+    }
 }
 
 

src/lagrangian/intermediate/submodels/ReactingMultiphase/DevolatilisationModel/SingleKineticRateDevolatilisation/SingleKineticRateDevolatilisation.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -236,7 +236,7 @@ public:
             const scalarField& YGasEff,
             const scalarField& YLiquidEff,
             const scalarField& YSolidEff,
-            bool& canCombust,
+            label& canCombust,
             scalarField& dMassDV
         ) const;
 };

src/lagrangian/intermediate/submodels/ReactingMultiphase/StochasticCollision/SuppressionCollision/SuppressionCollision.C

@@ -0,0 +1,96 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+\*---------------------------------------------------------------------------*/
+
+#include "SuppressionCollision.H"
+#include "kinematicCloud.H"
+
+// * * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * //
+
+template<class CloudType>
+void Foam::SuppressionCollision<CloudType>::collide(const scalar dt)
+{
+    const kinematicCloud& sc =
+        this->owner().mesh().template
+        lookupObject<kinematicCloud>(suppressionCloud_);
+
+    volScalarField vDotSweep(sc.vDotSweep());
+
+    dimensionedScalar Dt("dt", dimTime, dt);
+    volScalarField P(type() + ":p", 1.0 - exp(-vDotSweep*Dt));
+
+    forAllIter(typename CloudType, this->owner(), iter)
+    {
+        typename CloudType::parcelType& p = iter();
+        label cellI = p.cell();
+
+        scalar xx = this->owner().rndGen().template sample01<scalar>();
+
+        if (xx < P[cellI])
+        {
+            p.canCombust() = -1;
+            p.typeId() = max(p.typeId(), suppressedParcelType_);
+        }
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+template<class CloudType>
+Foam::SuppressionCollision<CloudType>::SuppressionCollision
+(
+    const dictionary& dict,
+    CloudType& owner
+)
+:
+    StochasticCollisionModel<CloudType>(dict, owner, typeName),
+    suppressionCloud_(this->coeffDict().lookup("suppressionCloud")),
+    suppressedParcelType_
+    (
+        this->coeffDict().lookupOrDefault("suppressedParcelType", -1)
+    )
+{}
+
+
+template<class CloudType>
+Foam::SuppressionCollision<CloudType>::SuppressionCollision
+(
+    const SuppressionCollision<CloudType>& cm
+)
+:
+    StochasticCollisionModel<CloudType>(cm),
+    suppressionCloud_(cm.suppressionCloud_),
+    suppressedParcelType_(cm.suppressedParcelType_)
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+template<class CloudType>
+Foam::SuppressionCollision<CloudType>::~SuppressionCollision()
+{}
+
+
+// ************************************************************************* //

src/lagrangian/intermediate/submodels/ReactingMultiphase/StochasticCollision/SuppressionCollision/SuppressionCollision.H

@@ -0,0 +1,111 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2013 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::SuppressionCollision
+
+Description
+    Inter-cloud collision model, whereby the \c canReact flag can be used
+    to inhibit devolatilisation and surface reactions
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef SuppressionCollision_H
+#define SuppressionCollision_H
+
+#include "StochasticCollisionModel.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+/*---------------------------------------------------------------------------*\
+                    Class SuppressionCollision Declaration
+\*---------------------------------------------------------------------------*/
+
+template<class CloudType>
+class SuppressionCollision
+:
+    public StochasticCollisionModel<CloudType>
+{
+protected:
+
+    // Protected data
+
+        //- Name of cloud used for suppression
+        const word suppressionCloud_;
+
+        //- Suppressed parcel type - optional
+        const label suppressedParcelType_;
+
+
+   // Protected Member Functions
+
+        //- Update the model
+        virtual void collide(const scalar dt);
+
+
+public:
+
+    //- Runtime type information
+    TypeName("suppressionCollision");
+
+
+    // Constructors
+
+        //- Construct from dictionary
+        SuppressionCollision(const dictionary& dict, CloudType& owner);
+
+        //- Construct copy
+        SuppressionCollision(const SuppressionCollision<CloudType>& cm);
+
+        //- Construct and return a clone
+        virtual autoPtr<StochasticCollisionModel<CloudType> > clone() const
+        {
+            return autoPtr<StochasticCollisionModel<CloudType> >
+            (
+                new SuppressionCollision<CloudType>(*this)
+            );
+        }
+
+
+    //- Destructor
+    virtual ~SuppressionCollision();
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#ifdef NoRepository
+#   include "SuppressionCollision.C"
+#endif
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

src/lagrangian/spray/clouds/Templates/SprayCloud/SprayCloud.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -26,7 +26,6 @@ License
 #include "SprayCloud.H"
 #include "AtomizationModel.H"
 #include "BreakupModel.H"
-#include "StochasticCollisionModel.H"
 
 // * * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * //
 
@@ -50,15 +49,6 @@ void Foam::SprayCloud<CloudType>::setModels()
             *this
         ).ptr()
     );
-
-    stochasticCollisionModel_.reset
-    (
-        StochasticCollisionModel<SprayCloud<CloudType> >::New
-        (
-            this->subModelProperties(),
-            *this
-        ).ptr()
-    );
 }
 
 
@@ -72,7 +62,6 @@ void Foam::SprayCloud<CloudType>::cloudReset
 
     atomizationModel_.reset(c.atomizationModel_.ptr());
     breakupModel_.reset(c.breakupModel_.ptr());
-    stochasticCollisionModel_.reset(c.stochasticCollisionModel_.ptr());
 }
 
 
@@ -94,8 +83,7 @@ Foam::SprayCloud<CloudType>::SprayCloud
     cloudCopyPtr_(NULL),
     averageParcelMass_(0.0),
     atomizationModel_(NULL),
-    breakupModel_(NULL),
-    stochasticCollisionModel_(NULL)
+    breakupModel_(NULL)
 {
     if (this->solution().active())
     {
@@ -130,8 +118,7 @@ Foam::SprayCloud<CloudType>::SprayCloud
     cloudCopyPtr_(NULL),
     averageParcelMass_(c.averageParcelMass_),
     atomizationModel_(c.atomizationModel_->clone()),
-    breakupModel_(c.breakupModel_->clone()),
-    stochasticCollisionModel_(c.stochasticCollisionModel_->clone())
+    breakupModel_(c.breakupModel_->clone())
 {}
 
 
@@ -148,8 +135,7 @@ Foam::SprayCloud<CloudType>::SprayCloud
     cloudCopyPtr_(NULL),
     averageParcelMass_(0.0),
     atomizationModel_(NULL),
-    breakupModel_(NULL),
-    stochasticCollisionModel_(NULL)
+    breakupModel_(NULL)
 {}
 
 
@@ -179,6 +165,8 @@ void Foam::SprayCloud<CloudType>::setParcelThermoProperties
     // override rho and Cp from constantProperties
     parcel.Cp() = liqMix.Cp(parcel.pc(), parcel.T(), X);
     parcel.rho() = liqMix.rho(parcel.pc(), parcel.T(), X);
+    parcel.sigma() = liqMix.sigma(parcel.pc(), parcel.T(), X);
+    parcel.mu() = liqMix.mu(parcel.pc(), parcel.T(), X);
 }
 
 
@@ -237,128 +225,6 @@ void Foam::SprayCloud<CloudType>::evolve()
 }
 
 
-template<class CloudType>
-template<class TrackData>
-void Foam::SprayCloud<CloudType>::motion(TrackData& td)
-{
-    const scalar dt = this->solution().trackTime();
-
-    td.part() = TrackData::tpLinearTrack;
-    CloudType::move(td, dt);
-
-    this->updateCellOccupancy();
-
-    if (stochasticCollision().active())
-    {
-        const liquidMixtureProperties& liqMix = this->composition().liquids();
-
-        label i = 0;
-        forAllIter(typename SprayCloud<CloudType>, *this, iter)
-        {
-            label j = 0;
-            forAllIter(typename SprayCloud<CloudType>, *this, jter)
-            {
-                if (j > i)
-                {
-                    parcelType& p = iter();
-                    scalar Vi = this->mesh().V()[p.cell()];
-                    scalarField X1(liqMix.X(p.Y()));
-                    scalar sigma1 = liqMix.sigma(p.pc(), p.T(), X1);
-                    scalar mp = p.mass()*p.nParticle();
-
-                    parcelType& q = jter();
-                    scalar Vj = this->mesh().V()[q.cell()];
-                    scalarField X2(liqMix.X(q.Y()));
-                    scalar sigma2 = liqMix.sigma(q.pc(), q.T(), X2);
-                    scalar mq = q.mass()*q.nParticle();
-
-                    bool updateProperties = stochasticCollision().update
-                    (
-                        dt,
-                        this->rndGen(),
-                        p.position(),
-                        mp,
-                        p.d(),
-                        p.nParticle(),
-                        p.U(),
-                        p.rho(),
-                        p.T(),
-                        p.Y(),
-                        sigma1,
-                        p.cell(),
-                        Vi,
-                        q.position(),
-                        mq,
-                        q.d(),
-                        q.nParticle(),
-                        q.U(),
-                        q.rho(),
-                        q.T(),
-                        q.Y(),
-                        sigma2,
-                        q.cell(),
-                        Vj
-                    );
-
-                    // for coalescence we need to update the density and
-                    // the diameter cause of the temp/conc/mass-change
-                    if (updateProperties)
-                    {
-                        if (mp > VSMALL)
-                        {
-                            scalarField Xp(liqMix.X(p.Y()));
-                            p.rho() = liqMix.rho(p.pc(), p.T(), Xp);
-                            p.Cp() = liqMix.Cp(p.pc(), p.T(), Xp);
-                            p.d() =
-                                cbrt
-                                (
-                                    6.0*mp
-                                   /(
-                                        p.nParticle()
-                                       *p.rho()
-                                       *constant::mathematical::pi
-                                    )
-                                );
-                        }
-
-                        if (mq > VSMALL)
-                        {
-                            scalarField Xq(liqMix.X(q.Y()));
-                            q.rho() = liqMix.rho(q.pc(), q.T(), Xq);
-                            q.Cp() = liqMix.Cp(q.pc(), q.T(), Xq);
-                            q.d() =
-                                cbrt
-                                (
-                                    6.0*mq
-                                   /(
-                                        q.nParticle()
-                                       *q.rho()
-                                       *constant::mathematical::pi
-                                    )
-                                );
-                        }
-                    }
-                }
-                j++;
-            }
-            i++;
-        }
-
-        // remove coalesced parcels that fall below minimum mass threshold
-        forAllIter(typename SprayCloud<CloudType>, *this, iter)
-        {
-            parcelType& p = iter();
-            scalar mass = p.nParticle()*p.mass();
-
-            if (mass < td.cloud().constProps().minParticleMass())
-            {
-                this->deleteParticle(p);
-            }
-        }
-    }
-}
-
-
 template<class CloudType>
 void Foam::SprayCloud<CloudType>::info()
 {

src/lagrangian/spray/clouds/Templates/SprayCloud/SprayCloud.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -27,6 +27,10 @@ Class
 Description
     Templated base class for spray cloud
 
+    - sub-models:
+      - atomization model
+      - break-up model
+
 \*---------------------------------------------------------------------------*/
 
 #ifndef SprayCloud_H
@@ -46,9 +50,6 @@ class AtomizationModel;
 template<class CloudType>
 class BreakupModel;
 
-template<class CloudType>
-class StochasticCollisionModel;
-
 /*---------------------------------------------------------------------------*\
                       Class SprayCloud Declaration
 \*---------------------------------------------------------------------------*/
@@ -106,10 +107,6 @@ protected:
             //- Break-up model
             autoPtr<BreakupModel<SprayCloud<CloudType> > > breakupModel_;
 
-            //- Collision model
-            autoPtr<StochasticCollisionModel<SprayCloud<CloudType> > >
-                stochasticCollisionModel_;
-
 
     // Protected Member Functions
 
@@ -202,14 +199,6 @@ public:
                 //- Return reference to the breakup model
                 inline BreakupModel<SprayCloud<CloudType> >& breakup();
 
-                //- Return const-access to the breakup model
-                inline const StochasticCollisionModel<SprayCloud<CloudType> >&
-                    stochasticCollision() const;
-
-                //- Return reference to the breakup model
-                inline StochasticCollisionModel<SprayCloud<CloudType> >&
-                    stochasticCollision();
-
 
         // Cloud evolution functions
 
@@ -236,10 +225,6 @@ public:
 
             //- Evolve the spray (inject, move)
             void evolve();
-            //- Particle motion
-
-            template<class TrackData>
-            void motion(TrackData& td);
 
 
         // I-O
@@ -249,7 +234,6 @@ public:
 };
 
 
-
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 } // End namespace Foam

src/lagrangian/spray/clouds/Templates/SprayCloud/SprayCloudI.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -65,22 +65,6 @@ Foam::SprayCloud<CloudType>::breakup()
 }
 
 
-template<class CloudType>
-inline const Foam::StochasticCollisionModel<Foam::SprayCloud<CloudType> >&
-Foam::SprayCloud<CloudType>::stochasticCollision() const
-{
-    return stochasticCollisionModel_;
-}
-
-
-template<class CloudType>
-inline Foam::StochasticCollisionModel<Foam::SprayCloud<CloudType> >&
-Foam::SprayCloud<CloudType>::stochasticCollision()
-{
-    return stochasticCollisionModel_();
-}
-
-
 template<class CloudType>
 inline Foam::scalar Foam::SprayCloud<CloudType>::averageParcelMass() const
 {

src/lagrangian/spray/parcels/Templates/SprayParcel/SprayParcel.C

@@ -82,6 +82,7 @@ void Foam::SprayParcel<ParcelType>::calc
 
     scalar T0 = this->T();
     this->Cp() = td.cloud().composition().liquids().Cp(this->pc_, T0, X);
+    sigma_ = td.cloud().composition().liquids().sigma(this->pc_, T0, X);
     scalar rho0 = td.cloud().composition().liquids().rho(this->pc_, T0, X);
     this->rho() = rho0;
 
@@ -89,13 +90,14 @@ void Foam::SprayParcel<ParcelType>::calc
 
     if (td.keepParticle)
     {
-        // update Cp, diameter and density due to change in temperature
+        // update Cp, sigma, diameter and density due to change in temperature
         // and/or composition
         scalar T1 = this->T();
         const scalarField& Y1(this->Y());
         scalarField X1(td.cloud().composition().liquids().X(Y1));
 
         this->Cp() = td.cloud().composition().liquids().Cp(this->pc_, T1, X1);
+        sigma_ = td.cloud().composition().liquids().sigma(this->pc_, T1, X);
 
         scalar rho1 = td.cloud().composition().liquids().rho(this->pc_, T1, X1);
         this->rho() = rho1;
@@ -139,15 +141,6 @@ void Foam::SprayParcel<ParcelType>::calcAtomization
     const AtomizationModel<sprayCloudType>& atomization =
         td.cloud().atomization();
 
-
-    // cell state info is updated in ReactingParcel calc
-    const scalarField& Y(this->Y());
-    scalarField X(composition.liquids().X(Y));
-
-    scalar rho = composition.liquids().rho(this->pc(), this->T(), X);
-    scalar mu = composition.liquids().mu(this->pc(), this->T(), X);
-    scalar sigma = composition.liquids().sigma(this->pc(), this->T(), X);
-
     // Average molecular weight of carrier mix - assumes perfect gas
     scalar Wc = this->rhoc_*specie::RR*this->Tc()/this->pc();
     scalar R = specie::RR/Wc;
@@ -174,7 +167,7 @@ void Foam::SprayParcel<ParcelType>::calcAtomization
     scalar chi = 0.0;
     if (atomization.calcChi())
     {
-        chi = this->chi(td, X);
+        chi = this->chi(td, composition.liquids().X(this->Y()));
     }
 
     atomization.update
@@ -183,9 +176,9 @@ void Foam::SprayParcel<ParcelType>::calcAtomization
         this->d(),
         this->liquidCore(),
         this->tc(),
-        rho,
-        mu,
-        sigma,
+        this->rho(),
+        mu_,
+        sigma_,
         volFlowRate,
         rhoAv,
         Urel,
@@ -207,10 +200,6 @@ void Foam::SprayParcel<ParcelType>::calcBreakup
     const label cellI
 )
 {
-    typedef typename TrackData::cloudType::reactingCloudType reactingCloudType;
-    const CompositionModel<reactingCloudType>& composition =
-        td.cloud().composition();
-
     typedef typename TrackData::cloudType cloudType;
     typedef typename cloudType::parcelType parcelType;
     typedef typename cloudType::forceType forceType;
@@ -223,14 +212,6 @@ void Foam::SprayParcel<ParcelType>::calcBreakup
         solveTABEq(td, dt);
     }
 
-    // cell state info is updated in ReactingParcel calc
-    const scalarField& Y(this->Y());
-    scalarField X(composition.liquids().X(Y));
-
-    scalar rho = composition.liquids().rho(this->pc(), this->T(), X);
-    scalar mu = composition.liquids().mu(this->pc(), this->T(), X);
-    scalar sigma = composition.liquids().sigma(this->pc(), this->T(), X);
-
     // Average molecular weight of carrier mix - assumes perfect gas
     scalar Wc = this->rhoc()*specie::RR*this->Tc()/this->pc();
     scalar R = specie::RR/Wc;
@@ -266,9 +247,9 @@ void Foam::SprayParcel<ParcelType>::calcBreakup
             this->y(),
             this->yDot(),
             this->d0(),
-            rho,
-            mu,
-            sigma,
+            this->rho(),
+            mu_,
+            sigma_,
             this->U(),
             rhoAv,
             muAv,
@@ -287,7 +268,7 @@ void Foam::SprayParcel<ParcelType>::calcBreakup
         SprayParcel<ParcelType>* child = new SprayParcel<ParcelType>(*this);
         child->mass0() = massChild;
         child->d() = dChild;
-        child->nParticle() = massChild/rho*this->volume(dChild);
+        child->nParticle() = massChild/this->rho()*this->volume(dChild);
 
         const forceSuSp Fcp =
             forces.calcCoupled(*child, dt, massChild, Re, muAv);
@@ -447,6 +428,8 @@ Foam::SprayParcel<ParcelType>::SprayParcel(const SprayParcel<ParcelType>& p)
     ParcelType(p),
     d0_(p.d0_),
     position0_(p.position0_),
+    sigma_(p.sigma_),
+    mu_(p.mu_),
     liquidCore_(p.liquidCore_),
     KHindex_(p.KHindex_),
     y_(p.y_),
@@ -469,6 +452,8 @@ Foam::SprayParcel<ParcelType>::SprayParcel
     ParcelType(p, mesh),
     d0_(p.d0_),
     position0_(p.position0_),
+    sigma_(p.sigma_),
+    mu_(p.mu_),
     liquidCore_(p.liquidCore_),
     KHindex_(p.KHindex_),
     y_(p.y_),

src/lagrangian/spray/parcels/Templates/SprayParcel/SprayParcel.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -59,6 +59,74 @@ class SprayParcel
     public ParcelType
 {
 
+public:
+
+    //- Class to hold reacting particle constant properties
+    class constantProperties
+    :
+        public ParcelType::constantProperties
+    {
+        // Private data
+
+            //- Particle initial surface tension [N/m]
+            scalar sigma0_;
+
+            //- Particle initial dynamic viscosity [Pa.s]
+            scalar mu0_;
+
+
+    public:
+
+        // Constructors
+
+            //- Null constructor
+            constantProperties();
+
+            //- Copy constructor
+            constantProperties(const constantProperties& cp);
+
+            //- Constructor from dictionary
+            constantProperties
+            (
+                const dictionary& parentDict,
+                const bool readFields = true
+            );
+
+            //- Construct from components
+            constantProperties
+            (
+                const label parcelTypeId,
+                const scalar rhoMin,
+                const scalar rho0,
+                const scalar minParticleMass,
+                const scalar youngsModulus,
+                const scalar poissonsRatio,
+                const scalar T0,
+                const scalar TMin,
+                const scalar TMax,
+                const scalar Cp0,
+                const scalar epsilon0,
+                const scalar f0,
+                const scalar Pr,
+                const scalar pMin,
+                const Switch& constantVolume,
+                const scalar Tvap,
+                const scalar Tbp,
+                const scalar sigma0,
+                const scalar mu0
+            );
+
+
+        // Access
+
+            //- Return const access to the initial surface tension
+            inline scalar sigma0() const;
+
+            //- Return const access to the initial dynamic viscosity
+            inline scalar mu0() const;
+    };
+
+
 protected:
 
     // Protected data
@@ -71,6 +139,12 @@ protected:
             //- Injection position
             vector position0_;
 
+            //- Liquid surface tension [N/m]
+            scalar sigma_;
+
+            //- Liquid dynamic viscosity [Pa.s]
+            scalar mu_;
+
             //- Part of liquid core ( >0.5=liquid, <0.5=droplet )
             scalar liquidCore_;
 
@@ -219,6 +293,12 @@ public:
             //- Return const access to initial droplet position
             inline const vector& position0() const;
 
+            //- Return const access to the liquid surface tension
+            inline scalar sigma() const;
+
+            //- Return const access to the liquid dynamic viscosity
+            inline scalar mu() const;
+
             //- Return const access to liquid core
             inline scalar liquidCore() const;
 
@@ -255,6 +335,12 @@ public:
             //- Return access to initial droplet position
             inline vector& position0();
 
+            //- Return access to the liquid surface tension
+            inline scalar& sigma();
+
+            //- Return access to the liquid dynamic viscosity
+            inline scalar& mu();
+
             //- Return access to liquid core
             inline scalar& liquidCore();
 

src/lagrangian/spray/parcels/Templates/SprayParcel/SprayParcelI.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -25,6 +25,94 @@ License
 
 // * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
 
+template<class ParcelType>
+inline Foam::SprayParcel<ParcelType>::constantProperties::constantProperties()
+:
+    ParcelType::constantProperties(),
+    sigma0_(0.0),
+    mu0_(0.0)
+{}
+
+
+template<class ParcelType>
+inline Foam::SprayParcel<ParcelType>::constantProperties::constantProperties
+(
+    const constantProperties& cp
+)
+:
+    ParcelType::constantProperties(cp),
+    sigma0_(cp.sigma0_),
+    mu0_(cp.mu0_)
+{}
+
+
+template<class ParcelType>
+inline Foam::SprayParcel<ParcelType>::constantProperties::constantProperties
+(
+    const dictionary& parentDict,
+    const bool readFields
+)
+:
+    ParcelType::constantProperties(parentDict, readFields),
+    sigma0_(0.0),
+    mu0_(0.0)
+{
+    if (readFields)
+    {
+        this->dict().lookup("sigma0") >> sigma0_;
+    }
+}
+
+
+template<class ParcelType>
+inline Foam::SprayParcel<ParcelType>::constantProperties::constantProperties
+(
+    const label parcelTypeId,
+    const scalar rhoMin,
+    const scalar rho0,
+    const scalar minParticleMass,
+    const scalar youngsModulus,
+    const scalar poissonsRatio,
+    const scalar T0,
+    const scalar TMin,
+    const scalar TMax,
+    const scalar Cp0,
+    const scalar epsilon0,
+    const scalar f0,
+    const scalar Pr,
+    const scalar pMin,
+    const Switch& constantVolume,
+    const scalar Tvap,
+    const scalar Tbp,
+    const scalar sigma0,
+    const scalar mu0
+)
+:
+    ParcelType::constantProperties
+    (
+        parcelTypeId,
+        rhoMin,
+        rho0,
+        minParticleMass,
+        youngsModulus,
+        poissonsRatio,
+        T0,
+        TMin,
+        TMax,
+        Cp0,
+        epsilon0,
+        f0,
+        Pr,
+        pMin,
+        constantVolume,
+        Tvap,
+        Tbp
+    ),
+    sigma0_(sigma0),
+    mu0_(mu0)
+{}
+
+
 template<class ParcelType>
 inline Foam::SprayParcel<ParcelType>::SprayParcel
 (
@@ -38,6 +126,8 @@ inline Foam::SprayParcel<ParcelType>::SprayParcel
     ParcelType(mesh, position, cellI, tetFaceI, tetPtI),
     d0_(this->d()),
     position0_(position),
+    sigma_(0.0),
+    mu_(0.0),
     liquidCore_(0.0),
     KHindex_(0.0),
     y_(0.0),
@@ -99,6 +189,8 @@ inline Foam::SprayParcel<ParcelType>::SprayParcel
     ),
     d0_(d0),
     position0_(position),
+    sigma_(constProps.sigma0()),
+    mu_(constProps.mu0()),
     liquidCore_(liquidCore),
     KHindex_(KHindex),
     y_(y),
@@ -127,6 +219,20 @@ inline const Foam::vector& Foam::SprayParcel<ParcelType>::position0() const
 }
 
 
+template<class ParcelType>
+inline Foam::scalar Foam::SprayParcel<ParcelType>::sigma() const
+{
+    return sigma_;
+}
+
+
+template<class ParcelType>
+inline Foam::scalar Foam::SprayParcel<ParcelType>::mu() const
+{
+    return mu_;
+}
+
+
 template<class ParcelType>
 inline Foam::scalar Foam::SprayParcel<ParcelType>::liquidCore() const
 {
@@ -204,6 +310,20 @@ inline Foam::vector& Foam::SprayParcel<ParcelType>::position0()
 }
 
 
+template<class ParcelType>
+inline Foam::scalar& Foam::SprayParcel<ParcelType>::sigma()
+{
+    return sigma_;
+}
+
+
+template<class ParcelType>
+inline Foam::scalar& Foam::SprayParcel<ParcelType>::mu()
+{
+    return mu_;
+}
+
+
 template<class ParcelType>
 inline Foam::scalar& Foam::SprayParcel<ParcelType>::liquidCore()
 {

src/lagrangian/spray/parcels/Templates/SprayParcel/SprayParcelIO.C

@@ -33,6 +33,8 @@ Foam::string Foam::SprayParcel<ParcelType>::propHeader =
     ParcelType::propHeader
   + " d0"
   + " position0"
+  + " sigma"
+  + " mu"
   + " liquidCore"
   + " KHindex"
   + " y"
@@ -57,6 +59,8 @@ Foam::SprayParcel<ParcelType>::SprayParcel
     ParcelType(mesh, is, readFields),
     d0_(0.0),
     position0_(vector::zero),
+    sigma_(0.0),
+    mu_(0.0),
     liquidCore_(0.0),
     KHindex_(0.0),
     y_(0.0),
@@ -74,6 +78,8 @@ Foam::SprayParcel<ParcelType>::SprayParcel
         {
             d0_ = readScalar(is);
             is >> position0_;
+            sigma_ = readScalar(is);
+            mu_ = readScalar(is);
             liquidCore_ = readScalar(is);
             KHindex_ = readScalar(is);
             y_ = readScalar(is);
@@ -91,6 +97,8 @@ Foam::SprayParcel<ParcelType>::SprayParcel
                 reinterpret_cast<char*>(&d0_),
                 sizeof(d0_)
               + sizeof(position0_)
+              + sizeof(sigma_)
+              + sizeof(mu_)
               + sizeof(liquidCore_)
               + sizeof(KHindex_)
               + sizeof(y_)
@@ -154,6 +162,12 @@ void Foam::SprayParcel<ParcelType>::readFields
     );
     c.checkFieldIOobject(c, position0);
 
+    IOField<scalar> sigma(c.fieldIOobject("sigma", IOobject::MUST_READ));
+    c.checkFieldIOobject(c, sigma);
+
+    IOField<scalar> mu(c.fieldIOobject("mu", IOobject::MUST_READ));
+    c.checkFieldIOobject(c, mu);
+
     IOField<scalar> liquidCore(c.fieldIOobject
     (
         "liquidCore", IOobject::MUST_READ)
@@ -190,6 +204,8 @@ void Foam::SprayParcel<ParcelType>::readFields
         SprayParcel<ParcelType>& p = iter();
         p.d0_ = d0[i];
         p.position0_ = position0[i];
+        p.sigma_ = sigma[i];
+        p.mu_ = mu[i];
         p.liquidCore_ = liquidCore[i];
         p.KHindex_ = KHindex[i];
         p.y_ = y[i];
@@ -230,6 +246,8 @@ void Foam::SprayParcel<ParcelType>::writeFields
         c.fieldIOobject("position0", IOobject::NO_READ),
         np
     );
+    IOField<scalar> sigma(c.fieldIOobject("sigma", IOobject::NO_READ), np);
+    IOField<scalar> mu(c.fieldIOobject("mu", IOobject::NO_READ), np);
     IOField<scalar> liquidCore
     (
         c.fieldIOobject("liquidCore", IOobject::NO_READ),
@@ -254,6 +272,8 @@ void Foam::SprayParcel<ParcelType>::writeFields
         const SprayParcel<ParcelType>& p = iter();
         d0[i] = p.d0_;
         position0[i] = p.position0_;
+        sigma[i] = p.sigma_;
+        mu[i] = p.mu_;
         liquidCore[i] = p.liquidCore_;
         KHindex[i] = p.KHindex_;
         y[i] = p.y_;
@@ -268,6 +288,8 @@ void Foam::SprayParcel<ParcelType>::writeFields
 
     d0.write();
     position0.write();
+    sigma.write();
+    mu.write();
     liquidCore.write();
     KHindex.write();
     y.write();
@@ -294,6 +316,8 @@ Foam::Ostream& Foam::operator<<
         os  << static_cast<const ParcelType&>(p)
         << token::SPACE << p.d0()
         << token::SPACE << p.position0()
+        << token::SPACE << p.sigma()
+        << token::SPACE << p.mu()
         << token::SPACE << p.liquidCore()
         << token::SPACE << p.KHindex()
         << token::SPACE << p.y()
@@ -312,6 +336,8 @@ Foam::Ostream& Foam::operator<<
             reinterpret_cast<const char*>(&p.d0_),
             sizeof(p.d0())
           + sizeof(p.position0())
+          + sizeof(p.sigma())
+          + sizeof(p.mu())
           + sizeof(p.liquidCore())
           + sizeof(p.KHindex())
           + sizeof(p.y())

src/lagrangian/spray/parcels/derived/basicSprayParcel/makeBasicSprayParcelSubmodels.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -32,6 +32,7 @@ License
 #include "makeParcelDispersionModels.H"
 #include "makeSprayParcelInjectionModels.H" // Spray variant
 #include "makeParcelPatchInteractionModels.H"
+#include "makeSprayParcelStochasticCollisionModels.H" // Spray variant
 
 // Thermodynamic
 #include "makeParcelHeatTransferModels.H"
@@ -44,7 +45,6 @@ License
 // Spray
 #include "makeSprayParcelAtomizationModels.H"
 #include "makeSprayParcelBreakupModels.H"
-#include "makeSprayParcelCollisionModels.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -57,6 +57,7 @@ namespace Foam
     makeParcelDispersionModels(basicSprayCloud);
     makeSprayParcelInjectionModels(basicSprayCloud);
     makeParcelPatchInteractionModels(basicSprayCloud);
+    makeSprayParcelStochasticCollisionModels(basicSprayCloud);
 
     // Thermo sub-models
     makeParcelHeatTransferModels(basicSprayCloud);
@@ -69,7 +70,6 @@ namespace Foam
     // Spray sub-models
     makeSprayParcelAtomizationModels(basicSprayCloud);
     makeSprayParcelBreakupModels(basicSprayCloud);
-    makeSprayParcelCollisionModels(basicSprayCloud);
 };
 
 

src/lagrangian/spray/parcels/include/makeSprayParcelStochasticCollisionModels.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -23,8 +23,8 @@ License
 
 \*---------------------------------------------------------------------------*/
 
-#ifndef makeSprayParcelCollisionModels_H
-#define makeSprayParcelCollisionModels_H
+#ifndef makeSprayParcelStochasticCollisionModels_H
+#define makeSprayParcelStochasticCollisionModels_H
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
@@ -34,7 +34,7 @@ License
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
-#define makeSprayParcelCollisionModels(CloudType)                             \
+#define makeSprayParcelStochasticCollisionModels(CloudType)                   \
                                                                               \
     makeStochasticCollisionModel(CloudType);                                  \
     makeStochasticCollisionModelType(NoStochasticCollision, CloudType);       \

src/lagrangian/spray/submodels/StochasticCollision/ORourkeCollision/ORourkeCollision.C

@@ -24,150 +24,120 @@ License
 \*---------------------------------------------------------------------------*/
 
 #include "ORourkeCollision.H"
+#include "mathematicalConstants.H"
+#include "SLGThermo.H"
 
-// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+using namespace Foam::constant::mathematical;
+
+// * * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * //
 
 template<class CloudType>
-Foam::ORourkeCollision<CloudType>::ORourkeCollision
-(
-    const dictionary& dict,
-    CloudType& owner
-)
-:
-    StochasticCollisionModel<CloudType>(dict, owner, typeName),
-    coalescence_(this->coeffDict().lookup("coalescence"))
-{}
+void Foam::ORourkeCollision<CloudType>::collide(const scalar dt)
+{
+    label i = 0;
+    forAllIter(typename CloudType, this->owner(), iter1)
+    {
+        label j = 0;
+        forAllIter(typename CloudType, this->owner(), iter2)
+        {
+            if (j > i)
+            {
+                parcelType& p1 = iter1();
+                parcelType& p2 = iter2();
+
+                scalar m1 = p1.nParticle()*p1.mass();
+                scalar m2 = p2.nParticle()*p2.mass();
+
+                bool massChanged = collideParcels(dt, p1, p2, m1, m2);
+
+                if (massChanged)
+                {
+                    if (m1 > ROOTVSMALL)
+                    {
+                        const scalarField X(liquids_.X(p1.Y()));
+                        p1.rho() = liquids_.rho(p1.pc(), p1.T(), X);
+                        p1.Cp() = liquids_.Cp(p1.pc(), p1.T(), X);
+                        p1.sigma() = liquids_.sigma(p1.pc(), p1.T(), X);
+                        p1.mu() = liquids_.mu(p1.pc(), p1.T(), X);
+                        p1.d() = cbrt(6.0*m1/(p1.nParticle()*p1.rho()*pi));
+                    }
+
+                    if (m2 > ROOTVSMALL)
+                    {
+                        const scalarField X(liquids_.X(p2.Y()));
+                        p2.rho() = liquids_.rho(p2.pc(), p2.T(), X);
+                        p2.Cp() = liquids_.Cp(p2.pc(), p2.T(), X);
+                        p2.sigma() = liquids_.sigma(p2.pc(), p2.T(), X);
+                        p2.mu() = liquids_.mu(p2.pc(), p2.T(), X);
+                        p2.d() = cbrt(6.0*m2/(p2.nParticle()*p2.rho()*pi));
+                    }
+                }
+            }
+            j++;
+        }
+        i++;
+    }
+
+    // remove coalesced parcels that fall below minimum mass threshold
+    forAllIter(typename CloudType, this->owner(), iter)
+    {
+        parcelType& p = iter();
+        scalar mass = p.nParticle()*p.mass();
+
+        if (mass < this->owner().constProps().minParticleMass())
+        {
+            this->owner().deleteParticle(p);
+        }
+    }
+}
 
 
 template<class CloudType>
-Foam::ORourkeCollision<CloudType>::ORourkeCollision
-(
-    const ORourkeCollision<CloudType>& cm
-)
-:
-    StochasticCollisionModel<CloudType>(cm),
-    coalescence_(cm.coalescence_)
-{}
-
-
-// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
-
-template<class CloudType>
-Foam::ORourkeCollision<CloudType>::~ORourkeCollision()
-{}
-
-
-// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
-
-template<class CloudType>
-bool Foam::ORourkeCollision<CloudType>::update
+bool Foam::ORourkeCollision<CloudType>::collideParcels
 (
     const scalar dt,
-    cachedRandom& rndGen,
-    vector& pos1,
+    parcelType& p1,
+    parcelType& p2,
     scalar& m1,
-    scalar& d1,
-    scalar& N1,
-    vector& U1,
-    scalar& rho1,
-    scalar& T1,
-    scalarField& Y1,
-    const scalar sigma1,
-    const label celli,
-    const scalar voli,
-    vector& pos2,
-    scalar& m2,
-    scalar& d2,
-    scalar& N2,
-    vector& U2,
-    scalar& rho2,
-    scalar& T2,
-    scalarField& Y2,
-    const scalar sigma2,
-    const label cellj,
-    const scalar volj
-) const
+    scalar& m2
+)
 {
+    const label cell1 = p1.cell();
+    const label cell2 = p2.cell();
+
     // check if parcels belong to same cell
-    if ((celli != cellj) || (m1 < VSMALL) || (m2 < VSMALL))
+    if ((cell1 != cell2) || (m1 < ROOTVSMALL) || (m2 < ROOTVSMALL))
     {
         return false;
     }
 
     bool coalescence = false;
 
-    scalar magVrel = mag(U1-U2);
+    const scalar Vc = this->owner().mesh().V()[cell1];
+    const scalar d1 = p1.d();
+    const scalar d2 = p2.d();
+
+    scalar magUrel = mag(p1.U() - p2.U());
     scalar sumD = d1 + d2;
-    scalar nu0 = 0.25*constant::mathematical::pi*sumD*sumD*magVrel*dt/volj;
-    scalar nMin = min(N1, N2);
+    scalar nu0 = 0.25*constant::mathematical::pi*sqr(sumD)*magUrel*dt/Vc;
+    scalar nMin = min(p1.nParticle(), p2.nParticle());
     scalar nu = nMin*nu0;
     scalar collProb = exp(-nu);
-    scalar xx = rndGen.sample01<scalar>();
+    scalar xx = this->owner().rndGen().template sample01<scalar>();
 
     // collision occurs
     if (xx > collProb)
     {
         if (d1 > d2)
         {
-            coalescence = collideSorted
-            (
-                dt,
-                rndGen,
-                pos1,
-                m1,
-                d1,
-                N1,
-                U1,
-                rho1,
-                T1,
-                Y1,
-                sigma1,
-                celli,
-                voli,
-                pos2,
-                m2,
-                d2,
-                N2,
-                U2,
-                rho2,
-                T2,
-                Y2,
-                sigma2,
-                cellj,
-                volj
-            );
+            coalescence = collideSorted(dt, p1, p2, m1, m2);
         }
         else
         {
-            coalescence = collideSorted
-            (
-                dt,
-                rndGen,
-                pos2,
-                m2,
-                d2,
-                N2,
-                U2,
-                rho2,
-                T2,
-                Y2,
-                sigma2,
-                cellj,
-                volj,
-                pos1,
-                m1,
-                d1,
-                N1,
-                U1,
-                rho1,
-                T1,
-                Y1,
-                sigma1,
-                celli,
-                voli
-            );
+            coalescence = collideSorted(dt, p2, p1, m2, m1);
         }
     }
+
     return coalescence;
 }
 
@@ -176,85 +146,81 @@ template<class CloudType>
 bool Foam::ORourkeCollision<CloudType>::collideSorted
 (
     const scalar dt,
-    cachedRandom& rndGen,
-    vector& pos1,
+    parcelType& p1,
+    parcelType& p2,
     scalar& m1,
-    scalar& d1,
-    scalar& N1,
-    vector& U1,
-    scalar& rho1,
-    scalar& T1,
-    scalarField& Y1,
-    const scalar sigma1,
-    const label celli,
-    const scalar voli,
-    vector& pos2,
-    scalar& m2,
-    scalar& d2,
-    scalar& N2,
-    vector& U2,
-    scalar& rho2,
-    scalar& T2,
-    scalarField& Y2,
-    const scalar sigma2,
-    const label cellj,
-    const scalar volj
-) const
+    scalar& m2
+)
 {
     bool coalescence = false;
 
-    vector vRel = U1 - U2;
-    scalar magVRel = mag(vRel);
+    const scalar sigma1 = p1.sigma();
+    const scalar sigma2 = p2.sigma();
 
-    scalar mdMin = m2/N2;
+    const scalar d1 = p1.d();
+    const scalar d2 = p2.d();
+
+    const scalar T1 = p1.T();
+    const scalar T2 = p2.T();
+
+    const scalar rho1 = p1.rho();
+    const scalar rho2 = p2.rho();
+
+    const vector& U1 = p1.U();
+    const vector& U2 = p2.U();
+
+    const label& nP1 = p1.nParticle();
+    const label& nP2 = p2.nParticle();
+
+
+    vector URel = U1 - U2;
+    scalar magURel = mag(URel);
 
     scalar mTot = m1 + m2;
 
-    scalar gamma = d1/max(d2, 1.0e-12);
-    scalar f = gamma*gamma*gamma + 2.7*gamma - 2.4*gamma*gamma;
+    scalar gamma = d1/max(ROOTVSMALL, d2);
+    scalar f = pow3(gamma) + 2.7*gamma - 2.4*sqr(gamma);
 
-    vector momMax = m1*U1;
-    vector momMin = m2*U2;
+    // mass-averaged temperature
+    scalar Tave = (T1*m1 + T2*m2)/mTot;
 
-    // use mass-averaged temperature to calculate We number
-    scalar Tm = (T1*m1 + T2*m2)/mTot;
+    // interpolate to find average surface tension
+    scalar sigmaAve = sigma1 + (sigma2 - sigma1)*(Tave - T1)/(T2 - T1);
 
-    // interpolate the averaged surface tension
-    scalar sigma = sigma1 + (sigma2 - sigma1)*(Tm - T1)/(T2 - T1);
-
-    sigma = max(1.0e-6, sigma);
     scalar Vtot = m1/rho1 + m2/rho2;
-    scalar rho = mTot/Vtot;
+    scalar rhoAve = mTot/Vtot;
 
-    scalar dMean = sqrt(d1*d2);
-    scalar WeColl = max(1.0e-12, 0.5*rho*magVRel*magVRel*dMean/sigma);
+    scalar dAve = sqrt(d1*d2);
+    scalar WeColl = 0.5*rhoAve*sqr(magURel)*dAve/max(ROOTVSMALL, sigmaAve);
 
-    scalar coalesceProb = min(1.0, 2.4*f/WeColl);
+    scalar coalesceProb = min(1.0, 2.4*f/max(ROOTVSMALL, WeColl));
 
-    scalar prob = rndGen.sample01<scalar>();
+    scalar prob = this->owner().rndGen().template sample01<scalar>();
 
     // Coalescence
     if (prob < coalesceProb && coalescence_)
     {
         coalescence = true;
-        // How 'many' of the droplets coalesce
-        scalar nProb = prob*N2/N1;
 
-        // Conservation of mass, momentum and energy
-        scalar m2Org = m2;
-        scalar dm = N1*nProb*mdMin;
-        m2 -= dm;
-        scalar V2 = constant::mathematical::pi*pow3(d2)/6.0;
-        N2 = m2/(rho2*V2);
+        // number of the droplets that coalesce
+        scalar nProb = prob*nP2/nP1;
 
+        // conservation of mass, momentum and energy
         scalar m1Org = m1;
+        scalar m2Org = m2;
+
+        scalar dm = nP1*nProb*m2/scalar(nP2);
+
         m1 += dm;
-        T1 = (Tm*mTot - m2*T2)/m1;
+        m2 -= dm;
 
-        U1 =(momMax + (1.0 - m2/m2Org)*momMin)/m1;
+        p1.T() = (Tave*mTot - m2*T2)/m1;
 
-        // update the liquid mass fractions
-        Y1 = (m1Org*Y1 + dm*Y2)/m1;
+        p1.U() = (m1*U1 + (1.0 - m2/m2Org)*m2*U2)/m1;
+
+        p1.Y() = (m1Org*p1.Y() + dm*p2.Y())/m1;
+
+        p2.nParticle() = m2/(rho2*p2.volume());
     }
     // Grazing collision (no coalescence)
     else
@@ -271,28 +237,65 @@ bool Foam::ORourkeCollision<CloudType>::collideSorted
         // and these parcels should have coalesced
         gf = max(0.0, gf);
 
-        // gf -> 1 => v1p -> p1().U() ...
-        // gf -> 0 => v1p -> momentum/(m1+m2)
+        // gf -> 1 => v1p -> U1 ...
+        // gf -> 0 => v1p -> momentum/mTot
 
         vector mr = m1*U1 + m2*U2;
-        vector v1p = (mr + m2*gf*vRel)/(m1+m2);
-        vector v2p = (mr - m1*gf*vRel)/(m1+m2);
+        vector v1p = (mr + m2*gf*URel)/mTot;
+        vector v2p = (mr - m1*gf*URel)/mTot;
 
-        if (N1 < N2)
+        if (nP1 < nP2)
         {
-            U1 = v1p;
-            U2 = (N1*v2p + (N2-N1)*U2)/N2;
+            p1.U() = v1p;
+            p2.U() = (nP1*v2p + (nP2 - nP1)*U2)/nP2;
         }
         else
         {
-            U1 = (N2*v1p + (N1-N2)*U1)/N1;
-            U2 = v2p;
+            p1.U() = (nP2*v1p + (nP1 - nP2)*U1)/nP1;
+            p2.U() = v2p;
         }
-
     }
 
     return coalescence;
 }
 
 
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+template<class CloudType>
+Foam::ORourkeCollision<CloudType>::ORourkeCollision
+(
+    const dictionary& dict,
+    CloudType& owner,
+    const word& modelName
+)
+:
+    StochasticCollisionModel<CloudType>(dict, owner, modelName),
+    liquids_
+    (
+        owner.db().template lookupObject<SLGThermo>("SLGThermo").liquids()
+    ),
+    coalescence_(this->coeffDict().lookup("coalescence"))
+{}
+
+
+template<class CloudType>
+Foam::ORourkeCollision<CloudType>::ORourkeCollision
+(
+    const ORourkeCollision<CloudType>& cm
+)
+:
+    StochasticCollisionModel<CloudType>(cm),
+    liquids_(cm.liquids_),
+    coalescence_(cm.coalescence_)
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+template<class CloudType>
+Foam::ORourkeCollision<CloudType>::~ORourkeCollision()
+{}
+
+
 // ************************************************************************* //

src/lagrangian/spray/submodels/StochasticCollision/ORourkeCollision/ORourkeCollision.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -34,13 +34,14 @@ Description
 #define ORourkeCollision_H
 
 #include "StochasticCollisionModel.H"
+#include "liquidMixtureProperties.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 namespace Foam
 {
 /*---------------------------------------------------------------------------*\
-                       Class ORourkeCollision Declaration
+                      Class ORourkeCollision Declaration
 \*---------------------------------------------------------------------------*/
 
 template<class CloudType>
@@ -48,10 +49,44 @@ class ORourkeCollision
 :
     public StochasticCollisionModel<CloudType>
 {
-private:
+protected:
+
+    // Protected Data
+
+        //- Convenience typedef to the cloud's parcel type
+        typedef typename CloudType::parcelType parcelType;
+
+        const liquidMixtureProperties& liquids_;
+
+        //- Coalescence activation switch
+        Switch coalescence_;
+
+
+    // Protected Member Functions
+
+        //- Main collision routine
+        virtual void collide(const scalar dt);
+
+        //- Collide parcels and return true if mass has changed
+        virtual bool collideParcels
+        (
+            const scalar dt,
+            parcelType& p1,
+            parcelType& p2,
+            scalar& m1,
+            scalar& m2
+        );
+
+        // 1 is the larger drop and 2 is the smaller
+        virtual bool collideSorted
+        (
+            const scalar dt,
+            parcelType& p1,
+            parcelType& p2,
+            scalar& m1,
+            scalar& m2
+        );
 
-    dictionary coeffsDict_;
-    Switch coalescence_;
 
 public:
 
@@ -62,7 +97,12 @@ public:
     // Constructors
 
         //- Construct from dictionary
-        ORourkeCollision(const dictionary& dict, CloudType& cloud);
+        ORourkeCollision
+        (
+            const dictionary& dict,
+            CloudType& cloud,
+            const word& modelName = typeName
+        );
 
         //- Construct copy
         ORourkeCollision(const ORourkeCollision<CloudType>& cm);
@@ -79,67 +119,6 @@ public:
 
     //- Destructor
     virtual ~ORourkeCollision();
-
-
-    // Member Functions
-
-        virtual bool update
-        (
-            const scalar dt,
-            cachedRandom& rndGen,
-            vector& pos1,
-            scalar& m1,
-            scalar& d1,
-            scalar& N1,
-            vector& U,
-            scalar& rho1,
-            scalar& T1,
-            scalarField& Y1,
-            const scalar sigma1,
-            const label celli,
-            const scalar voli,
-            vector& pos2,
-            scalar& m2,
-            scalar& d2,
-            scalar& N2,
-            vector& U2,
-            scalar& rho2,
-            scalar& T2,
-            scalarField& Y2,
-            const scalar sigma2,
-            const label cellj,
-            const scalar volj
-        ) const;
-
-
-        // 1 is the larger drop and 2 is the smaller
-        bool collideSorted
-        (
-            const scalar dt,
-            cachedRandom& rndGen,
-            vector& pos1,
-            scalar& m1,
-            scalar& d1,
-            scalar& N1,
-            vector& U,
-            scalar& rho1,
-            scalar& T1,
-            scalarField& Y1,
-            const scalar sigma1,
-            const label celli,
-            const scalar voli,
-            vector& pos2,
-            scalar& m2,
-            scalar& d2,
-            scalar& N2,
-            vector& U2,
-            scalar& rho2,
-            scalar& T2,
-            scalarField& Y2,
-            const scalar sigma2,
-            const label cellj,
-            const scalar volj
-        ) const;
 };
 
 

src/lagrangian/spray/submodels/StochasticCollision/TrajectoryCollision/TrajectoryCollision.C

@@ -25,187 +25,96 @@ License
 
 #include "TrajectoryCollision.H"
 
-// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+// * * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * //
 
 template<class CloudType>
-Foam::TrajectoryCollision<CloudType>::TrajectoryCollision
-(
-    const dictionary& dict,
-    CloudType& owner
-)
-:
-    StochasticCollisionModel<CloudType>(dict, owner, typeName),
-    cSpace_(readScalar(this->coeffDict().lookup("cSpace"))),
-    cTime_(readScalar(this->coeffDict().lookup("cTime"))),
-    coalescence_(this->coeffDict().lookup("coalescence"))
-{}
+void Foam::TrajectoryCollision<CloudType>::collide(const scalar dt)
+{
+    ORourkeCollision<CloudType>::collide(dt);
+}
 
 
 template<class CloudType>
-Foam::TrajectoryCollision<CloudType>::TrajectoryCollision
-(
-    const TrajectoryCollision<CloudType>& cm
-)
-:
-    StochasticCollisionModel<CloudType>(cm),
-    cSpace_(cm.cSpace_),
-    cTime_(cm.cTime_),
-    coalescence_(cm.coalescence_)
-{}
-
-
-// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
-
-template<class CloudType>
-Foam::TrajectoryCollision<CloudType>::~TrajectoryCollision()
-{}
-
-
-// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
-
-template<class CloudType>
-bool Foam::TrajectoryCollision<CloudType>::update
+bool Foam::TrajectoryCollision<CloudType>::collideParcels
 (
     const scalar dt,
-    cachedRandom& rndGen,
-    vector& pos1,
+    parcelType& p1,
+    parcelType& p2,
     scalar& m1,
-    scalar& d1,
-    scalar& N1,
-    vector& U1,
-    scalar& rho1,
-    scalar& T1,
-    scalarField& Y1,
-    const scalar sigma1,
-    const label celli,
-    const scalar voli,
-    vector& pos2,
-    scalar& m2,
-    scalar& d2,
-    scalar& N2,
-    vector& U2,
-    scalar& rho2,
-    scalar& T2,
-    scalarField& Y2,
-    const scalar sigma2,
-    const label cellj,
-    const scalar volj
-) const
+    scalar& m2
+)
 {
     bool coalescence = false;
 
-    vector vRel = U1 - U2;
+    const vector& pos1 = p1.position();
+    const vector& pos2 = p2.position();
 
-    vector p = pos2 - pos1;
-    scalar dist = mag(p);
+    const vector& U1 = p1.U();
+    const vector& U2 = p2.U();
 
-    scalar vAlign = vRel & (p/(dist + SMALL));
+    vector URel = U1 - U2;
+
+    vector d = pos2 - pos1;
+    scalar magd = mag(d);
+
+    scalar vAlign = URel & (d/(magd + ROOTVSMALL));
 
     if (vAlign > 0)
     {
+        const scalar d1 = p1.d();
+        const scalar d2 = p2.d();
+
         scalar sumD = d1 + d2;
 
-        if (vAlign*dt > dist - 0.5*sumD)
+        if (vAlign*dt > magd - 0.5*sumD)
         {
-            scalar v1Mag = mag(U1);
-            scalar v2Mag = mag(U2);
-            vector nv1 = U1/v1Mag;
-            vector nv2 = U2/v2Mag;
+            scalar magU1 = mag(U1) + ROOTVSMALL;
+            scalar magU2 = mag(U2) + ROOTVSMALL;
+            vector n1 = U1/magU1;
+            vector n2 = U2/magU2;
 
-            scalar v1v2 = nv1 & nv2;
-            scalar v1p = nv1 & p;
-            scalar v2p = nv2 & p;
+            scalar n1n2 = n1 & n2;
+            scalar n1d = n1 & d;
+            scalar n2d = n2 & d;
 
-            scalar det = 1.0 - v1v2*v1v2;
+            scalar det = 1.0 - sqr(n1n2);
 
-            scalar alpha = 1.0e+20;
-            scalar beta = 1.0e+20;
+            scalar alpha = GREAT;
+            scalar beta = GREAT;
 
             if (mag(det) > 1.0e-4)
             {
-                beta = -(v2p - v1v2*v1p)/det;
-                alpha = v1p + v1v2*beta;
+                beta = -(n2d - n1n2*n1d)/det;
+                alpha = n1d + n1n2*beta;
             }
 
-            alpha /= v1Mag*dt;
-            beta /= v2Mag*dt;
+            alpha /= magU1*dt;
+            beta /= magU2*dt;
 
             // is collision possible within this timestep
-            if ((alpha>0) && (alpha<1.0) && (beta>0) && (beta<1.0))
+            if ((alpha > 0) && (alpha < 1.0) && (beta > 0) && (beta < 1.0))
             {
                 vector p1c = pos1 + alpha*U1*dt;
                 vector p2c = pos2 + beta*U2*dt;
 
-                scalar closestDist = mag(p1c-p2c);
+                scalar closestDist = mag(p1c - p2c);
 
                 scalar collProb =
                     pow(0.5*sumD/max(0.5*sumD, closestDist), cSpace_)
-                  * exp(-cTime_*mag(alpha-beta));
+                   *exp(-cTime_*mag(alpha - beta));
 
-                scalar xx = rndGen.sample01<scalar>();
+                scalar xx = this->owner().rndGen().template sample01<scalar>();
 
-                // collision occur
-                if ((xx < collProb) && (m1 > VSMALL) && (m2 > VSMALL))
+                // collision occurs
+                if (xx > collProb)
                 {
                     if (d1 > d2)
                     {
-                        coalescence = collideSorted
-                        (
-                            dt,
-                            rndGen,
-                            pos1,
-                            m1,
-                            d1,
-                            N1,
-                            U1,
-                            rho1,
-                            T1,
-                            Y1,
-                            sigma1,
-                            celli,
-                            voli,
-                            pos2,
-                            m2,
-                            d2,
-                            N2,
-                            U2,
-                            rho2,
-                            T2,
-                            Y2,
-                            sigma2,
-                            cellj,
-                            volj
-                        );
+                        coalescence = this->collideSorted(dt, p1, p2, m1, m2);
                     }
                     else
                     {
-                        coalescence = collideSorted
-                        (
-                            dt,
-                            rndGen,
-                            pos2,
-                            m2,
-                            d2,
-                            N2,
-                            U2,
-                            rho2,
-                            T2,
-                            Y2,
-                            sigma2,
-                            cellj,
-                            volj,
-                            pos1,
-                            m1,
-                            d1,
-                            N1,
-                            U1,
-                            rho1,
-                            T1,
-                            Y1,
-                            sigma1,
-                            celli,
-                            voli
-                        );
+                        coalescence = this->collideSorted(dt, p2, p1, m2, m1);
                     }
                 }
             }
@@ -216,128 +125,38 @@ bool Foam::TrajectoryCollision<CloudType>::update
 }
 
 
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
 template<class CloudType>
-bool Foam::TrajectoryCollision<CloudType>::collideSorted
+Foam::TrajectoryCollision<CloudType>::TrajectoryCollision
 (
-    const scalar dt,
-    cachedRandom& rndGen,
-    vector& pos1,
-    scalar& m1,
-    scalar& d1,
-    scalar& N1,
-    vector& U1,
-    scalar& rho1,
-    scalar& T1,
-    scalarField& Y1,
-    const scalar sigma1,
-    const label celli,
-    const scalar voli,
-    vector& pos2,
-    scalar& m2,
-    scalar& d2,
-    scalar& N2,
-    vector& U2,
-    scalar& rho2,
-    scalar& T2,
-    scalarField& Y2,
-    const scalar sigma2,
-    const label cellj,
-    const scalar volj
-) const
-{
-    bool coalescence = false;
+    const dictionary& dict,
+    CloudType& owner
+)
+:
+    ORourkeCollision<CloudType>(dict, owner, typeName),
+    cSpace_(readScalar(this->coeffDict().lookup("cSpace"))),
+    cTime_(readScalar(this->coeffDict().lookup("cTime")))
+{}
 
-    vector vRel = U1 - U2;
 
-    scalar mdMin = m2/N2;
+template<class CloudType>
+Foam::TrajectoryCollision<CloudType>::TrajectoryCollision
+(
+    const TrajectoryCollision<CloudType>& cm
+)
+:
+    ORourkeCollision<CloudType>(cm),
+    cSpace_(cm.cSpace_),
+    cTime_(cm.cTime_)
+{}
 
-    scalar mTot = m1 + m2;
 
-    scalar gamma = d1/max(d2, 1.0e-12);
-    scalar f = gamma*gamma*gamma + 2.7*gamma - 2.4*gamma*gamma;
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
 
-    vector momMax = m1*U1;
-    vector momMin = m2*U2;
-
-    // use mass-averaged temperature to calculate We number
-    scalar Tm = (T1*m1 + T2*m2)/mTot;
-
-    // and mass averaged fractions ...
-    //scalarField Yav((m1*Y1 + m2*Y2)/mTot;
-
-    // interpolate the averaged surface tension
-    scalar sigma = sigma1 + (sigma2 - sigma1)*(Tm - T1)/(T2 - T1);
-
-    sigma = max(1.0e-6, sigma);
-    scalar Vtot = m1/rho1 + m2/rho2;
-    scalar rho = mTot/Vtot;
-
-    scalar dMean = sqrt(d1*d2);
-    scalar WeColl = max(1.0e-12, 0.5*rho*magSqr(vRel)*dMean/sigma);
-
-    scalar coalesceProb = min(1.0, 2.4*f/WeColl);
-
-    scalar prob = rndGen.sample01<scalar>();
-
-    // Coalescence
-    if ( prob < coalesceProb && coalescence_)
-    {
-        coalescence = true;
-        // How 'many' of the droplets coalesce
-        scalar nProb = prob*N2/N1;
-
-        // Conservation of mass, momentum and energy
-        scalar m2Org = m2;
-        scalar dm = N1*nProb*mdMin;
-        m2 -= dm;
-        scalar V2 = constant::mathematical::pi*pow3(d2)/6.0;
-        N2 = m2/(rho2*V2);
-
-        scalar m1Org = m1;
-        m1 += dm;
-        T1 = (Tm*mTot - m2*T2)/m1;
-
-        U1 =(momMax + (1.0 - m2/m2Org)*momMin)/m1;
-
-        // update the liquid mass fractions
-        Y1 = (m1Org*Y1 + dm*Y2)/m1;
-    }
-    // Grazing collision (no coalescence)
-    else
-    {
-        scalar gf = sqrt(prob) - sqrt(coalesceProb);
-        scalar denom = 1.0 - sqrt(coalesceProb);
-        if (denom < 1.0e-5)
-        {
-            denom = 1.0;
-        }
-        gf /= denom;
-
-        // if gf negative, this means that coalescence is turned off
-        // and these parcels should have coalesced
-        gf = max(0.0, gf);
-
-        // gf -> 1 => v1p -> p1().U() ...
-        // gf -> 0 => v1p -> momentum/(m1 + m2)
-
-        vector mr = m1*U1 + m2*U2;
-        vector v1p = (mr + m2*gf*vRel)/(m1 + m2);
-        vector v2p = (mr - m1*gf*vRel)/(m1 + m2);
-
-        if (N1 < N2)
-        {
-            U1 = v1p;
-            U2 = (N1*v2p + (N2 - N1)*U2)/N2;
-        }
-        else
-        {
-            U1 = (N2*v1p + (N1 - N2)*U1)/N1;
-            U2 = v2p;
-        }
-    }
-
-    return coalescence;
-}
+template<class CloudType>
+Foam::TrajectoryCollision<CloudType>::~TrajectoryCollision()
+{}
 
 
 // ************************************************************************* //

src/lagrangian/spray/submodels/StochasticCollision/TrajectoryCollision/TrajectoryCollision.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -25,35 +25,57 @@ Class
     Foam::TrajectoryCollision
 
 Description
-    Trajectory collision model by N. Nordin.
+    Trajectory collision model by N. Nordin, based on O'Rourke's collision
+    model
 
 \*---------------------------------------------------------------------------*/
 
 #ifndef TrajectoryCollision_H
 #define TrajectoryCollision_H
 
-#include "StochasticCollisionModel.H"
+#include "ORourkeCollision.H"
 
 // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
 
 namespace Foam
 {
 /*---------------------------------------------------------------------------*\
-                       Class TrajectoryCollision Declaration
+                     Class TrajectoryCollision Declaration
 \*---------------------------------------------------------------------------*/
 
 template<class CloudType>
 class TrajectoryCollision
 :
-    public StochasticCollisionModel<CloudType>
+    public ORourkeCollision<CloudType>
 {
-private:
+protected:
 
-    // Private data
+    // Protected Data
 
+        //- Convenience typedef to the cloud's parcel type
+        typedef typename CloudType::parcelType parcelType;
+
+        //- Space coefficient
         scalar cSpace_;
+
+        //- Time coefficient
         scalar cTime_;
-        Switch coalescence_;
+
+
+    // Protected Member Functions
+
+        //- Main collision routine
+        virtual void collide(const scalar dt);
+
+        //- Collide parcels and return true if mass has changed
+        virtual bool collideParcels
+        (
+            const scalar dt,
+            parcelType& p1,
+            parcelType& p2,
+            scalar& m1,
+            scalar& m2
+        );
 
 
 public:
@@ -82,66 +104,6 @@ public:
 
     //- Destructor
     virtual ~TrajectoryCollision();
-
-
-    // Member Functions
-
-        virtual bool update
-        (
-            const scalar dt,
-            cachedRandom& rndGen,
-            vector& pos1,
-            scalar& m1,
-            scalar& d1,
-            scalar& N1,
-            vector& U,
-            scalar& rho1,
-            scalar& T1,
-            scalarField& Y1,
-            const scalar sigma1,
-            const label celli,
-            const scalar voli,
-            vector& pos2,
-            scalar& m2,
-            scalar& d2,
-            scalar& N2,
-            vector& U2,
-            scalar& rho2,
-            scalar& T2,
-            scalarField& Y2,
-            const scalar sigma2,
-            const label cellj,
-            const scalar volj
-        ) const;
-
-        // 1 is the larger drop and 2 is the smaller
-        bool collideSorted
-        (
-            const scalar dt,
-            cachedRandom& rndGen,
-            vector& pos1,
-            scalar& m1,
-            scalar& d1,
-            scalar& N1,
-            vector& U,
-            scalar& rho1,
-            scalar& T1,
-            scalarField& Y1,
-            const scalar sigma1,
-            const label celli,
-            const scalar voli,
-            vector& pos2,
-            scalar& m2,
-            scalar& d2,
-            scalar& N2,
-            vector& U2,
-            scalar& rho2,
-            scalar& T2,
-            scalarField& Y2,
-            const scalar sigma2,
-            const label cellj,
-            const scalar volj
-        ) const;
 };
 
 

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

@@ -918,7 +918,7 @@ Foam::vectorField Foam::autoSnapDriver::calcNearestSurface
                     << " coordinate:" << localPoints[pointI]
                     << " did not find any surface within:"
                     << minSnapDist[pointI]
-                    << " meter." << endl;
+                    << " metre." << endl;
             }
         }
 

src/mesh/autoMesh/autoHexMesh/refinementFeatures/refinementFeatures.C

@@ -133,7 +133,7 @@ void Foam::refinementFeatures::read
         {
             Info<< "    level " << levels_[featI][j]
                 << " for all cells within " << distances_[featI][j]
-                << " meter." << endl;
+                << " metre." << endl;
         }
     }
 }

src/mesh/autoMesh/autoHexMesh/shellSurfaces/shellSurfaces.C

@@ -119,7 +119,7 @@ void Foam::shellSurfaces::setAndCheckLevels
         {
             Info<< "    level " << levels_[shellI][j]
                 << " for all cells within " << distances_[shellI][j]
-                << " meter." << endl;
+                << " metre." << endl;
         }
     }
     else

src/mesh/blockMesh/blockMesh/blockMesh.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -69,7 +69,7 @@ class blockMesh
         //- The list of curved edges
         curvedEdgeList edges_;
 
-        //- The scaling factor to convert to meters
+        //- The scaling factor to convert to metres
         scalar scaleFactor_;
 
         //- The blocks themselves (the topology) as a polyMesh
@@ -171,7 +171,7 @@ public:
                 return edges_;
             }
 
-            //- The scaling factor used to convert to meters
+            //- The scaling factor used to convert to metres
             scalar scaleFactor() const;
 
             //- The points for the entire mesh

src/meshTools/AMIInterpolation/AMIInterpolation/AMIInterpolation.C

@@ -190,12 +190,13 @@ void Foam::AMIInterpolation<SourcePatch, TargetPatch>::normaliseWeights
     wghtSum.setSize(wght.size());
     forAll(wght, faceI)
     {
-        scalar s = sum(wght[faceI]);
+        scalarList& w = wght[faceI];
+        scalar s = sum(w);
         scalar t = s/patchAreas[faceI];
 
-        forAll(addr[faceI], i)
+        forAll(w, i)
         {
-            wght[faceI][i] /= s;
+            w[i] /= s;
         }
 
         wghtSum[faceI] = t;

src/meshTools/AMIInterpolation/AMIInterpolation/AMIMethod/AMIMethod/AMIMethod.C

@@ -268,7 +268,7 @@ void Foam::AMIMethod<SourcePatch, TargetPatch>::appendNbrFaces
 ) const
 {
     const labelList& nbrFaces = patch.faceFaces()[faceI];
-    const pointField& tgtPoints = patch.points();
+    const pointField& points = patch.points();
 
     // filter out faces already visited from src face neighbours
     forAll(nbrFaces, i)
@@ -298,14 +298,13 @@ void Foam::AMIMethod<SourcePatch, TargetPatch>::appendNbrFaces
 
         if (valid)
         {
-            const face& myn = patch[faceI];
-            const face& nbrn = patch[nbrFaceI];
-            const vector& nbrNormal = nbrn.normal(tgtPoints);
-            const vector& mynNormal = myn.normal(tgtPoints);
+            const face& f = patch[faceI];
+            const face& nbrF = patch[nbrFaceI];
+            const vector& n = f.normal(points);
+            const vector& nbrN = nbrF.normal(points);
+            scalar cosI = mag(nbrN & n);
 
-            scalar cosI = nbrNormal & mynNormal;
-
-            if (cosI > Foam::cos(degToRad(89.0)))
+            if (cosI < Foam::cos(degToRad(89.0)))
             {
                 faceIDs.append(nbrFaceI);
             }

src/meshTools/AMIInterpolation/AMIInterpolation/AMIMethod/faceAreaWeightAMI/faceAreaWeightAMI.C

@@ -67,7 +67,7 @@ bool Foam::faceAreaWeightAMI<SourcePatch, TargetPatch>::processSourceFace
         visitedFaces.append(tgtFaceI);
         scalar area = interArea(srcFaceI, tgtFaceI);
 
-        // store when intersection area > 0
+        // store when intersection fractional area > tolerance
         if (area/this->srcMagSf_[srcFaceI] > faceAreaIntersect::tolerance())
         {
             srcAddr[srcFaceI].append(tgtFaceI);
@@ -227,12 +227,9 @@ Foam::scalar Foam::faceAreaWeightAMI<SourcePatch, TargetPatch>::interArea
     const face& tgt = this->tgtPatch_[tgtFaceI];
 
     // quick reject if either face has zero area
-    // Note: do not used stored face areas for target patch
+    // Note: do not use stored face areas for target patch
     const scalar tgtMag = tgt.mag(tgtPoints);
-    if
-    (
-        (this->srcMagSf_[srcFaceI] < ROOTVSMALL) || (tgtMag < ROOTVSMALL)
-    )
+    if ((this->srcMagSf_[srcFaceI] < ROOTVSMALL) || (tgtMag < ROOTVSMALL))
     {
         return 0.0;
     }

src/meshTools/searchableSurface/searchableSurfaceWithGaps.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -65,7 +65,7 @@ private:
 
     // Private Member Data
 
-        //- gap size in meter
+        //- gap size in metre
         const scalar gap_;
 
         //- Underlying geometry (size 1)

src/meshTools/sets/topoSets/topoSet.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011-2012 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -269,7 +269,7 @@ void Foam::topoSet::writeDebug
     boundBox bb(pointField(coords, toc()), true);
 
     os  << "Set bounding box: min = "
-        << bb.min() << "    max = " << bb.max() << " meters. " << endl << endl;
+        << bb.min() << "    max = " << bb.max() << " metres. " << endl << endl;
 
     label n = 0;
 

src/postProcessing/foamCalcFunctions/basic/addSubtract/addSubtract.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -297,4 +297,3 @@ void Foam::calcTypes::addSubtract::calc
 
 
 // ************************************************************************* //
-

src/postProcessing/foamCalcFunctions/basic/addSubtract/writeAddSubtractField.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -72,7 +72,9 @@ void Foam::calcTypes::addSubtract::writeAddSubtractField
                     mesh,
                     IOobject::NO_READ
                 ),
-                calcMode_ == ADD ? baseField + addField : baseField - addField
+                calcMode_ == ADD
+              ? (baseField + addField)()
+              : (baseField - addField)()
             );
             newField.write();
         }

src/sampling/meshToMeshInterpolation/meshToMeshNew/calcMethod/direct/directMethod.C

@@ -38,6 +38,16 @@ namespace Foam
 
 // * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
 
+bool Foam::directMethod::intersect
+(
+    const label srcCellI,
+    const label tgtCellI
+) const
+{
+    return tgt_.pointInCell(src_.cellCentres()[srcCellI], tgtCellI);
+}
+
+
 bool Foam::directMethod::findInitialSeeds
 (
     const labelList& srcCellIDs,

src/sampling/meshToMeshInterpolation/meshToMeshNew/calcMethod/direct/directMethod.H

@@ -56,9 +56,16 @@ protected:
 
     // Protected Member Functions
 
+        //- Return the true if cells intersect
+        virtual bool intersect
+        (
+            const label srcCellI,
+            const label tgtCellI
+        ) const;
+
         //- Find indices of overlapping cells in src and tgt meshes - returns
         //  true if found a matching pair
-        bool findInitialSeeds
+        virtual bool findInitialSeeds
         (
             const labelList& srcCellIDs,
             const boolList& mapFlag,
@@ -68,7 +75,7 @@ protected:
         ) const;
 
         //- Calculate the mesh-to-mesh addressing and weights
-        void calculateAddressing
+        virtual void calculateAddressing
         (
             labelListList& srcToTgtCellAddr,
             scalarListList& srcToTgtCellWght,
@@ -82,7 +89,7 @@ protected:
         );
 
         //- Append to list of src mesh seed indices
-        void appendToDirectSeeds
+        virtual void appendToDirectSeeds
         (
             boolList& mapFlag,
             labelList& srcTgtSeed,

src/sampling/meshToMeshInterpolation/meshToMeshNew/calcMethod/mapNearest/mapNearestMethod.H

@@ -58,7 +58,7 @@ protected:
 
         //- Find indices of overlapping cells in src and tgt meshes - returns
         //  true if found a matching pair
-        bool findInitialSeeds
+        virtual bool findInitialSeeds
         (
             const labelList& srcCellIDs,
             const boolList& mapFlag,
@@ -68,7 +68,7 @@ protected:
         ) const;
 
         //- Calculate the mesh-to-mesh addressing and weights
-        void calculateAddressing
+        virtual void calculateAddressing
         (
             labelListList& srcToTgtCellAddr,
             scalarListList& srcToTgtCellWght,
@@ -82,7 +82,7 @@ protected:
         );
 
         //- Find the nearest cell on mesh2 for cell1 on mesh1
-        void findNearestCell
+        virtual void findNearestCell
         (
             const polyMesh& mesh1,
             const polyMesh& mesh2,
@@ -91,7 +91,7 @@ protected:
         ) const;
 
         //- Set the next cells for the marching front algorithm
-        void setNextNearestCells
+        virtual void setNextNearestCells
         (
             label& startSeedI,
             label& srcCellI,
@@ -101,7 +101,7 @@ protected:
         ) const;
 
         //- Find a source cell mapped to target cell tgtCellI
-        label findMappedSrcCell
+        virtual label findMappedSrcCell
         (
             const label tgtCellI,
             const List<DynamicList<label> >& tgtToSrc

src/sampling/meshToMeshInterpolation/meshToMeshNew/calcMethod/meshToMeshMethod/meshToMeshMethod.H

@@ -72,13 +72,21 @@ protected:
         labelList maskCells() const;
 
         //- Return the true if cells intersect
-        bool intersect(const label srcCellI, const label tgtCellI) const;
+        virtual bool intersect
+        (
+            const label srcCellI,
+            const label tgtCellI
+        ) const;
 
         //- Return the intersection volume between two cells
-        scalar interVol(const label srcCellI, const label tgtCellI) const;
+        virtual scalar interVol
+        (
+            const label srcCellI,
+            const label tgtCellI
+        ) const;
 
         //- Append target cell neihgbour cells to cellIDs list
-        void appendNbrCells
+        virtual void appendNbrCells
         (
             const label tgtCellI,
             const polyMesh& mesh,
@@ -86,7 +94,7 @@ protected:
             DynamicList<label>& nbrTgtCellIDs
         ) const;
 
-        bool initialise
+        virtual bool initialise
         (
             labelListList& srcToTgtAddr,
             scalarListList& srcToTgtWght,

src/sampling/meshToMeshInterpolation/meshToMeshNew/meshToMeshNew.C

@@ -93,7 +93,6 @@ Foam::labelList Foam::meshToMeshNew::maskCells
 void Foam::meshToMeshNew::normaliseWeights
 (
     const word& descriptor,
-    const scalarField& cellVolumes,
     const labelListList& addr,
     scalarListList& wght
 ) const
@@ -102,27 +101,18 @@ void Foam::meshToMeshNew::normaliseWeights
 
     if (nCell > 0)
     {
-        scalar minW = GREAT;
-        scalar maxW = -GREAT;
-
         forAll(wght, cellI)
         {
             scalarList& w = wght[cellI];
             scalar s = sum(w);
-            scalar Vc = cellVolumes[cellI];
 
             forAll(w, i)
             {
-                w[i] /= Vc;
+                // note: normalise by s instead of cell volume since
+                // 1-to-1 methods duplicate contributions in parallel
+                w[i] /= s;
             }
-
-            minW = min(minW, s/Vc);
-            maxW = max(maxW, s/Vc);
         }
-
-        Info<< "    " << descriptor << " weights min/max = "
-            << returnReduce(minW, minOp<scalar>()) << ", "
-            << returnReduce(maxW, maxOp<scalar>()) << endl;
     }
 }
 
@@ -303,7 +293,6 @@ void Foam::meshToMeshNew::calculate()
         normaliseWeights
         (
             "source",
-            srcRegion_.cellVolumes(),
             srcToTgtCellAddr_,
             srcToTgtCellWght_
         );
@@ -311,7 +300,6 @@ void Foam::meshToMeshNew::calculate()
         normaliseWeights
         (
             "target",
-            tgtRegion_.cellVolumes(),
             tgtToSrcCellAddr_,
             tgtToSrcCellWght_
         );
@@ -337,7 +325,6 @@ void Foam::meshToMeshNew::calculate()
         normaliseWeights
         (
             "source",
-            srcRegion_.cellVolumes(),
             srcToTgtCellAddr_,
             srcToTgtCellWght_
         );
@@ -345,7 +332,6 @@ void Foam::meshToMeshNew::calculate()
         normaliseWeights
         (
             "target",
-            tgtRegion_.cellVolumes(),
             tgtToSrcCellAddr_,
             tgtToSrcCellWght_
         );
@@ -461,6 +447,7 @@ Foam::meshToMeshNew::meshToMeshNew
     srcPatchID_(),
     tgtPatchID_(),
     patchAMIs_(),
+    cuttingPatches_(),
     srcToTgtCellAddr_(),
     tgtToSrcCellAddr_(),
     srcToTgtCellWght_(),
@@ -476,34 +463,42 @@ Foam::meshToMeshNew::meshToMeshNew
         const polyBoundaryMesh& srcBM = src.boundaryMesh();
         const polyBoundaryMesh& tgtBM = tgt.boundaryMesh();
 
-        if (srcBM.size() != tgtBM.size())
-        {
-            FatalErrorIn
-            (
-                "Foam::meshToMeshNew::meshToMeshNew"
-                "("
-                    "const polyMesh&, "
-                    "const polyMesh&, "
-                    "const interpolationMethod&"
-                ")"
-            )   << "Source and target meshes are dissimiar:" << nl
-                << "    Source patches: " << srcBM.size() << nl
-                << "    Target patches: " << tgtBM.size() << exit(FatalError);
-        }
-
-        DynamicList<label> patchID(src.boundaryMesh().size());
-
+        DynamicList<label> srcPatchID(src.boundaryMesh().size());
+        DynamicList<label> tgtPatchID(tgt.boundaryMesh().size());
         forAll(srcBM, patchI)
         {
             const polyPatch& pp = srcBM[patchI];
             if (!polyPatch::constraintType(pp.type()))
             {
-                patchID.append(pp.index());
+                srcPatchID.append(pp.index());
+
+                label tgtPatchI = tgt.boundaryMesh().findPatchID(pp.name());
+
+                if (tgtPatchI != -1)
+                {
+                    tgtPatchID.append(tgtPatchI);
+                }
+                else
+                {
+                    FatalErrorIn
+                    (
+                        "Foam::meshToMeshNew::meshToMeshNew"
+                        "("
+                            "const polyMesh&, "
+                            "const polyMesh&, "
+                            "const interpolationMethod&, "
+                            "bool"
+                        ")"
+                    )   << "Source patch " << pp.name()
+                        << " not found in target mesh. "
+                        << "Available target patches are " << tgtBM.names()
+                        << exit(FatalError);
+                }
             }
         }
 
-        srcPatchID_.transfer(patchID);
-        tgtPatchID_ = srcPatchID_;
+        srcPatchID_.transfer(srcPatchID);
+        tgtPatchID_.transfer(tgtPatchID);
     }
 
     // calculate volume addressing and weights
@@ -519,7 +514,8 @@ Foam::meshToMeshNew::meshToMeshNew
     const polyMesh& src,
     const polyMesh& tgt,
     const interpolationMethod& method,
-    const HashTable<word>& patchMap
+    const HashTable<word>& patchMap,
+    const wordList& cuttingPatches
 )
 :
     srcRegion_(src),
@@ -527,6 +523,7 @@ Foam::meshToMeshNew::meshToMeshNew
     srcPatchID_(),
     tgtPatchID_(),
     patchAMIs_(),
+    cuttingPatches_(),
     srcToTgtCellAddr_(),
     tgtToSrcCellAddr_(),
     srcToTgtCellWght_(),
@@ -559,6 +556,14 @@ Foam::meshToMeshNew::meshToMeshNew
 
     // calculate patch addressing and weights
     (void)patchAMIs();
+
+    // set IDs of cutting patches on target mesh
+    cuttingPatches_.setSize(cuttingPatches.size());
+    forAll(cuttingPatches_, i)
+    {
+        const word& patchName = cuttingPatches[i];
+        cuttingPatches_[i] = tgt.boundaryMesh().findPatchID(patchName);
+    }
 }
 
 

src/sampling/meshToMeshInterpolation/meshToMeshNew/meshToMeshNew.H

@@ -94,6 +94,9 @@ private:
         //- List of AMIs between source and target patches
         mutable PtrList<AMIPatchToPatchInterpolation> patchAMIs_;
 
+        //- Cutting patches whose values are set using a zero-gradient condition
+        List<label> cuttingPatches_;
+
         //- Source to target cell addressing
         labelListList srcToTgtCellAddr_;
 
@@ -136,7 +139,6 @@ private:
         void normaliseWeights
         (
             const word& descriptor,
-            const scalarField& cellVolumes,
             const labelListList& addr,
             scalarListList& wght
         ) const;
@@ -242,7 +244,8 @@ public:
         const polyMesh& src,
         const polyMesh& tgt,
         const interpolationMethod& method,
-        const HashTable<word>& patchMap
+        const HashTable<word>& patchMap,
+        const wordList& cuttingPatches
     );
 
 

src/sampling/meshToMeshInterpolation/meshToMeshNew/meshToMeshNewTemplates.C

@@ -336,9 +336,6 @@ void Foam::meshToMeshNew::mapSrcToTgt
     GeometricField<Type, fvPatchField, volMesh>& result
 ) const
 {
-    // clear any previously stored values
-
-
     mapSrcToTgt(field, cop, result.internalField());
 
     const PtrList<AMIPatchToPatchInterpolation>& AMIList = patchAMIs();
@@ -360,6 +357,13 @@ void Foam::meshToMeshNew::mapSrcToTgt
             tgtField
         );
     }
+
+    forAll(cuttingPatches_, i)
+    {
+        label patchI = cuttingPatches_[i];
+        fvPatchField<Type>& pf = result.boundaryField()[patchI];
+        pf == pf.patchInternalField();
+    }
 }
 
 
@@ -466,6 +470,13 @@ void Foam::meshToMeshNew::mapTgtToSrc
             srcField
         );
     }
+
+    forAll(cuttingPatches_, i)
+    {
+        label patchI = cuttingPatches_[i];
+        fvPatchField<Type>& pf = result.boundaryField()[patchI];
+        pf == pf.patchInternalField();
+    }
 }
 
 

src/transportModels/incompressible/viscosityModels/BirdCarreau/BirdCarreau.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -52,7 +52,7 @@ Foam::viscosityModels::BirdCarreau::calcNu() const
     return
         nuInf_
       + (nu0_ - nuInf_)
-       *pow(scalar(1) + sqr(k_*strainRate()), (n_ - 1.0)/2.0);
+       *pow(scalar(1) + pow(k_*strainRate(), a_), (n_ - 1.0)/a_);
 }
 
 
@@ -72,6 +72,14 @@ Foam::viscosityModels::BirdCarreau::BirdCarreau
     nuInf_(BirdCarreauCoeffs_.lookup("nuInf")),
     k_(BirdCarreauCoeffs_.lookup("k")),
     n_(BirdCarreauCoeffs_.lookup("n")),
+    a_
+    (
+        BirdCarreauCoeffs_.lookupOrDefault
+        (
+            "a",
+            dimensionedScalar("a", dimless, 2)
+        )
+    ),
     nu_
     (
         IOobject
@@ -102,6 +110,11 @@ bool Foam::viscosityModels::BirdCarreau::read
     BirdCarreauCoeffs_.lookup("nuInf") >> nuInf_;
     BirdCarreauCoeffs_.lookup("k") >> k_;
     BirdCarreauCoeffs_.lookup("n") >> n_;
+    a_ = BirdCarreauCoeffs_.lookupOrDefault
+    (
+        "a",
+        dimensionedScalar("a", dimless, 2)
+    );
 
     return true;
 }

src/transportModels/incompressible/viscosityModels/BirdCarreau/BirdCarreau.H

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -27,6 +27,9 @@ Class
 Description
     An incompressible Bird-Carreau non-Newtonian viscosity model.
 
+    The Bird-Carreau-Yasuda form is also supported if the optional "a"
+    coefficient is specified.  "a" defaults to 2 for the Bird-Carreau model.
+
 SourceFiles
     BirdCarreau.C
 
@@ -62,6 +65,7 @@ class BirdCarreau
         dimensionedScalar nuInf_;
         dimensionedScalar k_;
         dimensionedScalar n_;
+        dimensionedScalar a_;
 
         volScalarField nu_;
 

src/transportModels/interfaceProperties/interfaceProperties.C

@@ -2,7 +2,7 @@
   =========                 |
   \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
    \\    /   O peration     |
-    \\  /    A nd           | Copyright (C) 2011 OpenFOAM Foundation
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
      \\/     M anipulation  |
 -------------------------------------------------------------------------------
 License
@@ -159,7 +159,7 @@ Foam::interfaceProperties::interfaceProperties
     (
         readScalar
         (
-            alpha1.mesh().solutionDict().subDict("PIMPLE").lookup("cAlpha")
+            alpha1.mesh().solverDict(alpha1.name()).lookup("cAlpha")
         )
     ),
     sigma_(dict.lookup("sigma")),