Merge pull request #55 from ParticulateFlow/feature/recurrenceLib_recurrenceTurbulence

Feature/recurrence lib recurrence turbulence

applications/solvers/testTwoFluidRecurrenceTurbulence/Allwclean

@@ -0,0 +1,9 @@
+#!/bin/sh
+cd ${0%/*} || exit 1    # Run from this directory
+set -x
+
+wclean libso recurrenceTurbulence
+
+wclean
+
+# ----------------------------------------------------------------- end-of-file

applications/solvers/testTwoFluidRecurrenceTurbulence/Allwmake

@@ -0,0 +1,9 @@
+#!/bin/sh
+cd ${0%/*} || exit 1    # Run from this directory
+set -x
+
+wmake libso recurrenceTurbulence
+
+wmake
+
+# ----------------------------------------------------------------- end-of-file

applications/solvers/testTwoFluidRecurrenceTurbulence/CEqn.H

@@ -0,0 +1,29 @@
+// build equation system
+/*
+    Note the use of the effective viscosity, which is provided by the turbulence model
+    The recurrence-based turbulence models are derived from the standard base classes 
+    of OpenFOAM, thus they behave as a normal turbulence model would.
+*/
+
+alphaRhoPhiCarrier = linearInterpolate(alpha2*rhoCarrier)*phi2;
+
+fvScalarMatrix CEqn
+(
+	fvm::ddt(alphaCarrier*rhoCarrier, C)
+  + fvm::div(alphaRhoPhiCarrier, C, "div(alphaRhoPhi,C)")
+  - fvm::Sp(fvc::div(alphaRhoPhiCarrier), C)
+
+  - fvm::laplacian
+	(
+		fvc::interpolate(alpha2)
+	   *fvc::interpolate(carrierPhase.turbulence().muEff()/Sc),
+		C
+	)
+	==
+	fvm::SuSp(alphaCarrier*(1.0 - alphaCarrier)*rhoCarrier*K, C)
+	+ fvOptions(alphaCarrier*rhoCarrier, C)
+);
+
+// solve equations
+fvOptions.constrain(CEqn);
+CEqn.solve();

applications/solvers/testTwoFluidRecurrenceTurbulence/Make/files

@@ -0,0 +1,3 @@
+testTwoFluidRecurrenceTurbulence.C
+
+EXE = $(FOAM_USER_APPBIN)/testTwoFluidRecurrenceTurbulence

applications/solvers/testTwoFluidRecurrenceTurbulence/Make/options

@@ -0,0 +1,31 @@
+EXE_INC = \
+    -I$(FOAM_SOLVERS)/multiphase/reactingEulerFoam/reactingTwoPhaseEulerFoam \
+    -I$(FOAM_SOLVERS)/multiphase/reactingEulerFoam/reactingTwoPhaseEulerFoam/twoPhaseSystem/lnInclude \
+    -I$(FOAM_SOLVERS)/multiphase/reactingEulerFoam/phaseSystems/lnInclude \
+    -I$(FOAM_SOLVERS)/multiphase/reactingEulerFoam/interfacialModels/lnInclude \
+    -I$(FOAM_SOLVERS)/multiphase/reactingEulerFoam/interfacialCompositionModels/lnInclude \
+    -I$(FOAM_SOLVERS)/multiphase/reactingEulerFoam/twoPhaseCompressibleTurbulenceModels/lnInclude \
+    -I$(LIB_SRC)/thermophysicalModels/basic/lnInclude \
+    -I$(LIB_SRC)/transportModels/compressible/lnInclude \
+    -I$(LIB_SRC)/TurbulenceModels/turbulenceModels/lnInclude \
+    -I$(LIB_SRC)/TurbulenceModels/compressible/lnInclude \
+    -I$(LIB_SRC)/TurbulenceModels/phaseCompressible/lnInclude \
+    -I$(LIB_SRC)/finiteVolume/lnInclude \
+    -I$(LIB_SRC)/meshTools/lnInclude \
+    -I$(LIB_SRC)/sampling/lnInclude \
+    -I../../../src/recurrence/lnInclude \
+    -IrecurrenceTurbulence/lnInclude
+
+EXE_LIBS = \
+    -lreactingPhaseSystem \
+    -lreactingTwoPhaseSystem \
+    -lreactingEulerianInterfacialModels \
+    -lreactingEulerianInterfacialCompositionModels \
+    -ltwoPhaseReactingTurbulenceModels \
+    -lfiniteVolume \
+    -lfvOptions \
+    -lmeshTools \
+    -lsampling \
+    -L$(FOAM_USER_LIBBIN) \
+    -lrecurrence \
+    -lrecurrenceTwoPhaseTurbulenceModels

applications/solvers/testTwoFluidRecurrenceTurbulence/checkTurbulenceModels.H

@@ -0,0 +1,70 @@
+//===============================
+// recurrence turbulence
+//===============================
+
+
+    // check both phases for turbulence models
+    forAllIter(PtrListDictionary<phaseModel>, fluid.phases(), iter)
+    {
+        phaseModel& phase = iter();
+        
+        Info << "Checking phase " << phase.name() << "'s turbulence model: "
+            << phase.turbulence().type() << endl;
+        
+        /*
+            Check for laminar turbulence. This works with OpenFOAM-4.0 and OpenFOAM-5.0,
+            as the laminar, multi-phase turbulence model is named "laminar" in OF-4.0
+            and "Stokes" in OF-5.0
+        */
+        if (phase.turbulence().type() == "laminar" || phase.turbulence().type() == "Stokes")
+        {
+            // do nothing
+        }
+        else if (isA<Foam::recurrenceTurbulenceModel>(phase.turbulence()))
+        {
+            /*
+                create a reference of the type recurrenceTurbulenceModel
+                register the recurrence model with the recurrenceTurbulenceModel
+            */
+            
+            // get const-reference to the turbulence model
+            const phaseCompressibleTurbulenceModel& turbConstRef = phase.turbulence();
+            
+            // cast away const-ness, the underlying turbulence model is not a const object, so this is bad but fine
+            phaseCompressibleTurbulenceModel& turbRef = const_cast<phaseCompressibleTurbulenceModel&>(turbConstRef);
+            
+            // cast away the wrapper class, to get a reference to the turbulence models' base class
+            PhaseCompressibleTurbulenceModel<phaseModel>& baseTurbRef
+            (
+                static_cast<PhaseCompressibleTurbulenceModel<phaseModel>&>(turbRef)
+            );
+            
+            // casting down the family tree
+            Foam::recurrenceTurbulenceModel& recTurbRef
+            (
+                dynamic_cast<Foam::recurrenceTurbulenceModel&>(baseTurbRef)
+            );
+            
+            
+            // set recurrenceBase pointer
+            recTurbRef.setRecurrenceBasePtr(&recurrenceBase);
+            
+            
+            // check model settings
+            turbRef.validate();
+        }
+        else
+        {
+            /*
+                In a recurrence run, we do not compute any turbulence as we do not solve the fluid flow
+                At this point, the phase is not laminar (i.e. not using turbulence) or 
+                    using recurrenceTurbulence (i.e. taking turbulent quantities from the data base).
+                Hence, abort!
+            */
+            FatalError
+                << "Wrong turbulence model type "
+                << phase.turbulence().type() << " for phase " << phase.name() << nl << nl
+                << "Valid turbulence model types are types derived from recurrenceTurbulenceModel or laminar" << endl
+                << exit(FatalError);
+        }
+    }

applications/solvers/testTwoFluidRecurrenceTurbulence/createTransportFields.H

@@ -0,0 +1,79 @@
+/* --------------------------------------------------------------------------------- */
+/* 								read flotation properties							 */
+/* --------------------------------------------------------------------------------- */
+
+Info<< "Reading scalarTransportProperties\n" << endl;
+IOdictionary scalarTransportProperties
+(
+    IOobject
+    (
+        "scalarTransportProperties",
+        runTime.constant(),
+        mesh,
+        IOobject::MUST_READ_IF_MODIFIED,
+        IOobject::NO_WRITE
+    )
+);
+
+
+const scalar Sc(scalarTransportProperties.lookupOrDefault<scalar>("Sc",scalar(1.0)));
+
+
+const word carrierPhaseName(scalarTransportProperties.lookup("carrierPhase"));
+
+if (carrierPhaseName != phase1.name() && carrierPhaseName != phase2.name())
+{
+	FatalError << "No valid carrier phase specified" << nl
+		<< "Valid phase names are: " << nl
+		<< phase1.name() << ",  " << phase2.name()
+		<< abort(FatalError);
+}
+
+phaseModel& carrierPhase = (carrierPhaseName == phase1.name()) ? phase1 : phase2;
+
+const word dispersePhaseName = (carrierPhaseName == phase1.name()) ? phase2.name() : phase1.name();
+
+
+volScalarField& rhoCarrier = carrierPhase.thermo().rho();
+volScalarField& alphaCarrier = carrierPhase;
+surfaceScalarField& alphaRhoPhiCarrier = carrierPhase.alphaRhoPhi();
+
+
+volScalarField contErrCarrier
+(
+    "contErrCarrier",
+    fvc::ddt(alphaCarrier, rhoCarrier)
+);
+
+
+
+Info<< "Reading field C\n" << endl;
+volScalarField C
+(
+    IOobject
+    (
+        "C",
+        runTime.timeName(),
+        mesh,
+        IOobject::MUST_READ,
+        IOobject::AUTO_WRITE
+    ),
+    mesh
+);
+
+volScalarField K
+(
+    IOobject
+    (
+        "K",
+        runTime.timeName(),
+        mesh,
+        IOobject::MUST_READ,
+        IOobject::NO_WRITE
+    ),
+    mesh
+);
+
+
+
+

applications/solvers/testTwoFluidRecurrenceTurbulence/readFields.H

@@ -0,0 +1,9 @@
+// update flow fields
+recurrenceBase.recM().exportVolScalarField("alpha."+carrierPhaseName,alpha2);
+recurrenceBase.recM().exportVolScalarField("alpha."+dispersePhaseName,alpha1);
+
+recurrenceBase.recM().exportVolVectorField("U."+carrierPhaseName,U2);
+
+// update turbulence models
+phase1.correctTurbulence();
+phase2.correctTurbulence();

applications/solvers/testTwoFluidRecurrenceTurbulence/recurrenceTurbulence/Allwclean

@@ -0,0 +1,7 @@
+#!/bin/sh
+cd ${0%/*} || exit 1    # Run from this directory
+
+
+wclean libso
+
+#------------------------------------------------------------------------------

applications/solvers/testTwoFluidRecurrenceTurbulence/recurrenceTurbulence/Allwmake

@@ -0,0 +1,9 @@
+#!/bin/sh
+cd ${0%/*} || exit 1    # Run from this directory
+
+# Parse arguments for library compilation
+. $WM_PROJECT_DIR/wmake/scripts/AllwmakeParseArguments
+
+wmake $targetType
+
+#------------------------------------------------------------------------------

applications/solvers/testTwoFluidRecurrenceTurbulence/recurrenceTurbulence/Make/files

@@ -0,0 +1,10 @@
+recurrenceTurbulenceModel/recurrenceTurbulenceModel.C
+
+
+recurrenceTurbulenceModels.C
+
+recurrenceKEpsilon/recurrenceKEpsilon.C
+recurrenceKOmega/recurrenceKOmega.C
+recurrenceSmagorinsky/recurrenceSmagorinsky.C
+
+LIB = $(FOAM_USER_LIBBIN)/librecurrenceTwoPhaseTurbulenceModels

applications/solvers/testTwoFluidRecurrenceTurbulence/recurrenceTurbulence/Make/options

@@ -0,0 +1,27 @@
+EXE_INC = \
+    -I$(FOAM_SOLVERS)/multiphase/reactingEulerFoam/reactingTwoPhaseEulerFoam/twoPhaseSystem/lnInclude \
+    -I$(FOAM_SOLVERS)/multiphase/reactingEulerFoam/phaseSystems/lnInclude \
+    -I$(FOAM_SOLVERS)/multiphase/reactingEulerFoam/interfacialModels/lnInclude\
+    -I$(FOAM_SOLVERS)/multiphase/reactingEulerFoam/interfacialCompositionModels/lnInclude \
+    -I$(LIB_SRC)/transportModels/compressible/lnInclude \
+    -I$(LIB_SRC)/thermophysicalModels/basic/lnInclude \
+    -I$(LIB_SRC)/transportModels/incompressible/transportModel \
+    -I$(LIB_SRC)/TurbulenceModels/compressible/lnInclude \
+    -I$(LIB_SRC)/TurbulenceModels/turbulenceModels/lnInclude \
+    -I$(LIB_SRC)/TurbulenceModels/phaseCompressible/lnInclude \
+    -I$(LIB_SRC)/finiteVolume/lnInclude \
+    -I$(LIB_SRC)/meshTools/lnInclude \
+    -I../recurrenceTurbulenceModel/lnInclude \
+    -I../../../../src/recurrence/lnInclude
+
+LIB_LIBS = \
+    -lreactingPhaseSystem \
+    -lreactingTwoPhaseSystem \
+    -lreactingEulerianInterfacialModels \
+    -lreactingEulerianInterfacialCompositionModels \
+    -lfiniteVolume \
+    -lfvOptions \
+    -lmeshTools \
+    -L$(FOAM_USER_LIBBIN) \
+    -lrecurrence \
+    -lreactingTwoPhaseSystem

applications/solvers/testTwoFluidRecurrenceTurbulence/recurrenceTurbulence/ReadMe.md

@@ -0,0 +1,107 @@
+# Recurrence-based, multi-phase turbulence modelling
+
+This model implements recurrence-based turbulence models, i.e. the fundamental 
+turbulent field quantities are read from the data base and are not solved for.
+All derived field quantities are computed just in the same way as the proper 
+turbulence models do. By deriving the recurrence-based turbulence models from 
+somewhere up the family tree of OpenFOAM's turbulence model class hierarchy, 
+the recurrence-based turbulence models are fully compatible with OpenFOAM's 
+generic treatment of turbulence modelling, i.e. solvers and libraries interact 
+with references to a generic base type of the actual turbulence model. Hence, 
+solvers and libraries may remain blissfully ignorant of the actual turbulence 
+model in use.
+
+For laminar phases no special treatment is necessary, as the *laminar* 
+turbulence model does not compute any fields.
+
+
+## Development notes
+
+The initial development covers only a small number of turbulence models.
+
+
+## Notes on usage
+
+The turbulence model in use for the recurrence run must be the recurrence-based 
+equivalent of the turbulence model used for generating the data base, i.e. if 
+the data base was computed using the *kEpsilon* model, then the recurrence solver 
+is to employ the *recurrenceKEpsilon* turbulence model. This model will read 
+the relevant model coefficients from the *turbulenceProperties* dictionary, and 
+make sure that the turbulent fields `k` and `epsilon` are contained in the data 
+base.
+
+Whenever, the solver or a library calls `turbulence->nut()` to access the 
+turbulent viscosity, the recurrence-based kEpsilon model will compute `nut` 
+according to kEpsilon's relations `nut = Cmu*sqr(k)/epsilon`, with the fields 
+`k` and `epsilon` being from the current snapshot provided by the recurrence model.
+
+Thus, the fundamental turbulent field quantities of the employed turbulence model 
+have to be added to the *volScalarFields* list in the `recProperties` dictionary 
+controlling the recurrence model. This will ensure that the turbulent field 
+quantities are read from the data base.
+
+
+## Notes on the implementation
+
+The base class implements the method `void setRecurrenceBasePtr(recBase*)`, which 
+is used to give the recurrence-based turbulence models a reference (technically 
+a pointer) to the recurrence model. Thus, after construction of the turbulence 
+models and the recurrence model, `setRecurrenceBasePtr()` needs to be called as 
+the pointer to the recurrence model is initialized by the constructor with `NULL`.
+Trying to access the recurrence model from within the recurrence-based turbulence 
+model prior to setting the pointer to the recurrence model with 
+`setRecurrenceBasePtr()` will result in a segmentation fault.
+In order to be able to call `setRecurrenceBasePtr()`, the generic reference to 
+the turbulence model needs to be converted into a reference of the base class' 
+type, i.e. `recurrenceTurbulenceModel`.
+This unfortunate deviation from good standards, i.e. making full use of C++'s 
+polymorphism, should be the only instance of having to use non-pretty hacks.
+However, apart from initialisation, i.e. setting the pointer to the recurrence 
+model, the recurrence-based turbulence models adhere to the generic interface of 
+OpenFOAM's turbulence models, and can be used as any other turbulence model.
+
+
+The concrete implementations, e.g. *recurrenceKEpsilon*, use the method 
+`validate()` to check whether the underlying turbulent quantities are specified 
+for use in the data base in the *volScalarFields* list in the `recProperties` 
+dictionary. This method is part of the signature of the class `Foam::turbulenceModel`, 
+which is the very base class of all turbulence models in OpenFOAM.
+In proper turbulence models, this method is used to check whether the internal 
+fields are properly initialized and to update all derived quantities.
+In the solver, `validate()` must not be called prior to `setRecurrenceBasePtr()`, 
+as validate accesses the recurrence model. The wrong order of function calls will 
+result in a segmentation fault, as the pointer to the recurrence model is 
+initialized by the constructor with `NULL`.
+
+
+The concrete implementations, e.g. *recurrenceKEpsilon*, use the method 
+`correct()` to update the turbulent field quantities from the data base, 
+and in turn update the derived quantities, such as `nut`.
+This method is part of the signature of the class `Foam::turbulenceModel`, 
+which is the very base class of all turbulence models in OpenFOAM.
+In proper turbulence models, this method is used to solve for the next time step.
+
+
+## Compilation
+
+Source OpenFOAM and simply compile with
+
+```bash
+./Allwclean
+./Allwmake
+```
+
+The script `Allwclean` will clear all previous builds. This step is not needed for
+first-time compilation. It is, however, recommended for subsequent compilations, as
+it completely clears the slate. The script `Allwmake` will run the compilation for
+the passive particle model.
+
+
+## Required software
+
+This model has been tested with the following versions of OpenFOAM:
+
+* OpenFOAM-4.0
+* OpenFOAM-5.0
+
+

applications/solvers/testTwoFluidRecurrenceTurbulence/recurrenceTurbulence/recurrenceKEpsilon/recurrenceKEpsilon.C

@@ -0,0 +1,193 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2016 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 "recurrenceKEpsilon.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
+
+
+void Foam::RASModels::recurrenceKEpsilon::correctNut()
+{
+    this->nut_ = Cmu_*sqr(k_)/epsilon_;
+    this->nut_.correctBoundaryConditions();
+}
+
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::RASModels::recurrenceKEpsilon::recurrenceKEpsilon
+(
+    const volScalarField& alpha,
+    const volScalarField& rho,
+    const volVectorField& U,
+    const surfaceScalarField& alphaRhoPhi,
+    const surfaceScalarField& phi,
+    const transportModel& phase,
+    const word& propertiesName,
+    const word& type
+
+)
+:
+    eddyViscosity<RASModel<EddyDiffusivity<phaseCompressibleTurbulenceModel>>>
+    (
+        type,
+        alpha,
+        rho,
+        U,
+        alphaRhoPhi,
+        phi,
+        phase,
+        propertiesName
+    ),
+    recurrenceTurbulenceModel(U.group()),
+    Cmu_
+    (
+        dimensioned<scalar>::lookupOrAddToDict
+        (
+            "Cmu",
+            this->coeffDict_,
+            0.09
+        )
+    ),
+    k_
+    (
+        IOobject
+        (
+            IOobject::groupName("k", U.group()),
+            this->runTime_.timeName(),
+            this->mesh_,
+            IOobject::NO_READ,
+            IOobject::AUTO_WRITE
+        ),
+        this->mesh_,
+        dimensionedScalar("k0", dimensionSet(0,2,-2,0,0), 0.0)
+    ),
+    epsilon_
+    (
+        IOobject
+        (
+            IOobject::groupName("epsilon", U.group()),
+            this->runTime_.timeName(),
+            this->mesh_,
+            IOobject::NO_READ,
+            IOobject::AUTO_WRITE
+        ),
+        this->mesh_,
+        dimensionedScalar("eps0", dimensionSet(0,2,-3,0,0), 0.0)
+    )
+{
+    if (type == typeName)
+    {
+        printCoeffs(type);
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+
+Foam::RASModels::recurrenceKEpsilon::~recurrenceKEpsilon()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+bool Foam::RASModels::recurrenceKEpsilon::read()
+{
+    if
+    (
+        eddyViscosity<RASModel<EddyDiffusivity<phaseCompressibleTurbulenceModel>>>::read()
+    )
+    {
+        Cmu_.readIfPresent(this->coeffDict());
+        
+        return true;
+    }
+    else
+    {
+        return false;
+    }
+}
+
+
+void Foam::RASModels::recurrenceKEpsilon::correct()
+{
+    // update turbulence fields
+    recurrenceBasePtr_->recM().exportVolScalarField("k."+group_, this->k_);
+    recurrenceBasePtr_->recM().exportVolScalarField("epsilon."+group_, this->epsilon_);
+    
+    // update nut
+    correctNut();
+}
+
+
+void Foam::RASModels::recurrenceKEpsilon::validate()
+{
+    /*
+        Check whether k and epsilon are included in the dataBase.
+        The check only makes sure that these fields are included in the
+            volScalarFields list of recProperties.
+        Whether the fields are actually contained in the dataBase is 
+            done by the recurrenceModel itself.
+    */
+    bool foundK(false);
+    bool foundEpsilon(false);
+    
+    wordList fieldNames(recurrenceBasePtr_->recM().volScalarFieldNames());
+    
+    forAll(fieldNames, i)
+    {
+        word curFieldName = fieldNames[i];
+        
+        if (curFieldName == k_.name())
+        {
+            foundK = true;
+        }
+        
+        if (curFieldName == epsilon_.name())
+        {
+            foundEpsilon = true;
+        }
+        
+        
+    }
+    
+    if (not (foundK and foundEpsilon))
+    {
+        FatalError
+            << "Fields " << k_.name() << " and " << epsilon_.name()
+            << " not specified in the volScalarFields list of recProperties!" << nl
+            << "volScalarFields : " << fieldNames << nl
+            << "Add these fields and make sure they are contained in the dataBase." << nl
+            << exit(FatalError);
+    }
+}
+
+
+// ************************************************************************* //

applications/solvers/testTwoFluidRecurrenceTurbulence/recurrenceTurbulence/recurrenceKEpsilon/recurrenceKEpsilon.H

@@ -0,0 +1,161 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2016 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::recurrenceKEpsilon
+
+Description
+    recurrence-based kEpsilon turbulence model
+
+    This model provides kEpslion's turbulence quantities that were computed 
+    elsewhere, i.e. taken from the recurrence dataBase.
+    To be used by recurrence solvers.
+
+SourceFiles
+    recurrenceKEpsilon.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef recurrenceKEpsilon_H
+#define recurrenceKEpsilon_H
+
+#include "RASModel.H"
+#include "eddyViscosity.H"
+#include "phaseCompressibleTurbulenceModel.H"
+#include "EddyDiffusivity.H"
+
+#include "recurrenceTurbulenceModel.H"
+
+#include "autoPtr.H"
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace RASModels
+{
+
+/*---------------------------------------------------------------------------*\
+                           Class recurrenceKEpsilon Declaration
+\*---------------------------------------------------------------------------*/
+
+class recurrenceKEpsilon
+:
+    public eddyViscosity<RASModel<EddyDiffusivity<phaseCompressibleTurbulenceModel>>>,
+    public recurrenceTurbulenceModel
+{
+    // Private data
+
+    // Private Member Functions
+
+
+        //- Disallow default bitwise copy construct
+        recurrenceKEpsilon(const recurrenceKEpsilon&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const recurrenceKEpsilon&);
+        
+
+protected:
+
+    // Protected data
+
+        // Model coefficients
+
+            dimensionedScalar Cmu_;
+
+        // Fields
+
+            volScalarField k_;
+            volScalarField epsilon_;
+    
+    // Protected Member Functions
+
+        virtual void correctNut();
+
+
+public:
+
+
+    //- Runtime type information
+    TypeName("recurrenceKEpsilon");
+
+
+    // Constructors
+
+        //- Construct from components
+        recurrenceKEpsilon
+        (
+            const volScalarField& alpha,
+            const volScalarField& rho,
+            const volVectorField& U,
+            const surfaceScalarField& alphaRhoPhi,
+            const surfaceScalarField& phi,
+            const phaseModel& transport,
+            const word& propertiesName = turbulenceModel::propertiesName,
+            const word& type = typeName
+        );
+
+
+
+    //- Destructor
+    virtual ~recurrenceKEpsilon();
+
+
+    // Member Functions
+
+        //- Re-read model coefficients if they have changed
+        virtual bool read();
+        
+        
+        //- Return the turbulence kinetic energy
+        virtual tmp<volScalarField> k() const
+        {
+            return k_;
+        }
+
+        //- Return the turbulence kinetic energy dissipation rate
+        virtual tmp<volScalarField> epsilon() const
+        {
+            return epsilon_;
+        }
+
+        //- Update the turbulent fields
+        virtual void correct();
+        
+        //- Check model settings
+        virtual void validate();
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace RASModels
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

applications/solvers/testTwoFluidRecurrenceTurbulence/recurrenceTurbulence/recurrenceKOmega/recurrenceKOmega.C

@@ -0,0 +1,193 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2016 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 "recurrenceKOmega.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
+
+
+void Foam::RASModels::recurrenceKOmega::correctNut()
+{
+    this->nut_ = k_/omega_;
+    this->nut_.correctBoundaryConditions();
+}
+
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::RASModels::recurrenceKOmega::recurrenceKOmega
+(
+    const volScalarField& alpha,
+    const volScalarField& rho,
+    const volVectorField& U,
+    const surfaceScalarField& alphaRhoPhi,
+    const surfaceScalarField& phi,
+    const transportModel& phase,
+    const word& propertiesName,
+    const word& type
+
+)
+:
+    eddyViscosity<RASModel<EddyDiffusivity<phaseCompressibleTurbulenceModel>>>
+    (
+        type,
+        alpha,
+        rho,
+        U,
+        alphaRhoPhi,
+        phi,
+        phase,
+        propertiesName
+    ),
+    recurrenceTurbulenceModel(U.group()),
+    Cmu_
+    (
+        dimensioned<scalar>::lookupOrAddToDict
+        (
+            "Cmu",
+            this->coeffDict_,
+            0.09
+        )
+    ),
+    k_
+    (
+        IOobject
+        (
+            IOobject::groupName("k", U.group()),
+            this->runTime_.timeName(),
+            this->mesh_,
+            IOobject::NO_READ,
+            IOobject::AUTO_WRITE
+        ),
+        this->mesh_,
+        dimensionedScalar("k0", dimensionSet(0,2,-2,0,0), 0.0)
+    ),
+    omega_
+    (
+        IOobject
+        (
+            IOobject::groupName("omega", U.group()),
+            this->runTime_.timeName(),
+            this->mesh_,
+            IOobject::NO_READ,
+            IOobject::AUTO_WRITE
+        ),
+        this->mesh_,
+        dimensionedScalar("om0", dimensionSet(0,0,-1,0,0), 0.0)
+    )
+{
+    if (type == typeName)
+    {
+        printCoeffs(type);
+    }
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+
+Foam::RASModels::recurrenceKOmega::~recurrenceKOmega()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+bool Foam::RASModels::recurrenceKOmega::read()
+{
+    if
+    (
+        eddyViscosity<RASModel<EddyDiffusivity<phaseCompressibleTurbulenceModel>>>::read()
+    )
+    {
+        Cmu_.readIfPresent(this->coeffDict());
+        
+        return true;
+    }
+    else
+    {
+        return false;
+    }
+}
+
+
+void Foam::RASModels::recurrenceKOmega::correct()
+{
+    // update turbulence fields
+    recurrenceBasePtr_->recM().exportVolScalarField("k."+group_, this->k_);
+    recurrenceBasePtr_->recM().exportVolScalarField("omega."+group_, this->omega_);
+    
+    // update nut
+    correctNut();
+}
+
+
+void Foam::RASModels::recurrenceKOmega::validate()
+{
+    /*
+        Check whether k and omega are included in the dataBase.
+        The check only makes sure that these fields are included in the
+            volScalarFields list of recProperties.
+        Whether the fields are actually contained in the dataBase is 
+            done by the recurrenceModel itself.
+    */
+    bool foundK(false);
+    bool foundOmega(false);
+    
+    wordList fieldNames(recurrenceBasePtr_->recM().volScalarFieldNames());
+    
+    forAll(fieldNames, i)
+    {
+        word curFieldName = fieldNames[i];
+        
+        if (curFieldName == k_.name())
+        {
+            Info << "Found " << k_.name()<< endl;
+            foundK = true;
+        }
+        
+        if (curFieldName == omega_.name())
+        {
+            Info << "Found " << omega_.name()<< endl;
+            foundOmega = true;
+        }
+    }
+    
+    if (not (foundK and foundOmega))
+    {
+        FatalError
+            << "Fields " << k_.name() << " and " << omega_.name()
+            << " not specified in the volScalarFields list of recProperties!" << nl
+            << "volScalarFields : " << fieldNames << nl
+            << "Add these fields and make sure they are contained in the dataBase." << nl
+            << exit(FatalError);
+    }
+}
+
+
+// ************************************************************************* //

applications/solvers/testTwoFluidRecurrenceTurbulence/recurrenceTurbulence/recurrenceKOmega/recurrenceKOmega.H

@@ -0,0 +1,188 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2016 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::recurrenceKOmega
+
+Description
+    recurrence-based kOmega turbulence model
+
+    This model provides kOmega's turbulence quantities that were computed 
+    elsewhere, i.e. taken from the recurrence dataBase
+    To be used by recurrence solvers
+
+SourceFiles
+    recurrenceKOmega.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef recurrenceKOmega_H
+#define recurrenceKOmega_H
+
+#include "RASModel.H"
+#include "eddyViscosity.H"
+#include "phaseCompressibleTurbulenceModel.H"
+#include "EddyDiffusivity.H"
+
+#include "recurrenceTurbulenceModel.H"
+
+#include "autoPtr.H"
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace RASModels
+{
+
+/*---------------------------------------------------------------------------*\
+                           Class recurrenceKOmega Declaration
+\*---------------------------------------------------------------------------*/
+
+class recurrenceKOmega
+:
+    public eddyViscosity<RASModel<EddyDiffusivity<phaseCompressibleTurbulenceModel>>>,
+    public recurrenceTurbulenceModel
+{
+    // Private data
+
+    // Private Member Functions
+
+
+        //- Disallow default bitwise copy construct
+        recurrenceKOmega(const recurrenceKOmega&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const recurrenceKOmega&);
+        
+
+protected:
+
+    // Protected data
+
+        // Model coefficients
+
+            dimensionedScalar Cmu_;
+
+        // Fields
+
+            volScalarField k_;
+            volScalarField omega_;
+    
+    // Protected Member Functions
+
+        virtual void correctNut();
+
+
+public:
+
+
+    //- Runtime type information
+    TypeName("recurrenceKOmega");
+
+
+    // Constructors
+
+        //- Construct from components
+        recurrenceKOmega
+        (
+            const volScalarField& alpha,
+            const volScalarField& rho,
+            const volVectorField& U,
+            const surfaceScalarField& alphaRhoPhi,
+            const surfaceScalarField& phi,
+            const phaseModel& transport,
+            const word& propertiesName = turbulenceModel::propertiesName,
+            const word& type = typeName
+        );
+
+
+
+    //- Destructor
+    virtual ~recurrenceKOmega();
+
+
+    // Member Functions
+
+        //- Re-read model coefficients if they have changed
+        virtual bool read();
+        
+        
+        //- Return the turbulence kinetic energy
+        virtual tmp<volScalarField> k() const
+        {
+            return k_;
+        }
+
+        //- Return the turbulence specific dissipation rate
+        virtual tmp<volScalarField> omega() const
+        {
+            return omega_;
+        }
+
+        //- Return the turbulence kinetic energy dissipation rate
+        virtual tmp<volScalarField> epsilon() const
+        {
+            return tmp<volScalarField>
+            (
+                new volScalarField
+                (
+                    IOobject
+                    (
+                        "epsilon",
+                        this->mesh_.time().timeName(),
+                        this->mesh_
+                    ),
+                    Cmu_*k_*omega_,
+                    omega_.boundaryField().types()
+                )
+            );
+        }
+
+        //- Update the turbulent fields
+        virtual void correct();
+        
+        //- Check model settings
+        virtual void validate();
+        
+        
+    // Setters
+        
+        void setRecurrenceBasePtr(recBase* recurrenceBasePtr)
+        {
+            recurrenceBasePtr_ = recurrenceBasePtr;
+        }
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace RASModels
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

applications/solvers/testTwoFluidRecurrenceTurbulence/recurrenceTurbulence/recurrenceSmagorinsky/recurrenceSmagorinsky.C

@@ -0,0 +1,158 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2015 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 "recurrenceSmagorinsky.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+// * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
+
+Foam::tmp<Foam::volScalarField> Foam::LESModels::recurrenceSmagorinsky::k
+(
+    const tmp<volTensorField>& gradU
+) const
+{
+    volSymmTensorField D(symm(gradU));
+
+    volScalarField a(this->Ce_/this->delta());
+    volScalarField b((2.0/3.0)*tr(D));
+    volScalarField c(2*Ck_*this->delta()*(dev(D) && D));
+
+    return tmp<volScalarField>
+    (
+        new volScalarField
+        (
+            IOobject
+            (
+                IOobject::groupName("k", this->U_.group()),
+                this->runTime_.timeName(),
+                this->mesh_
+            ),
+            sqr((-b + sqrt(sqr(b) + 4*a*c))/(2*a))
+        )
+    );
+}
+
+
+void Foam::LESModels::recurrenceSmagorinsky::correctNut()
+{
+    volScalarField k(this->k(fvc::grad(this->U_)));
+
+    this->nut_ = Ck_*this->delta()*sqrt(k);
+    this->nut_.correctBoundaryConditions();
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+Foam::LESModels::recurrenceSmagorinsky::recurrenceSmagorinsky
+(
+    const volScalarField& alpha,
+    const volScalarField& rho,
+    const volVectorField& U,
+    const surfaceScalarField& alphaRhoPhi,
+    const surfaceScalarField& phi,
+    const transportModel& phase,
+    const word& propertiesName,
+    const word& type
+)
+:
+    LESeddyViscosity<EddyDiffusivity<phaseCompressibleTurbulenceModel>>
+    (
+        type,
+        alpha,
+        rho,
+        U,
+        alphaRhoPhi,
+        phi,
+        phase,
+        propertiesName
+    ),
+    recurrenceTurbulenceModel(U.group()),
+    Ck_
+    (
+        dimensioned<scalar>::lookupOrAddToDict
+        (
+            "Ck",
+            this->coeffDict_,
+            0.094
+        )
+    )
+{
+    if (type == typeName)
+    {
+        this->printCoeffs(type);
+    }
+}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+bool Foam::LESModels::recurrenceSmagorinsky::read()
+{
+    if (LESeddyViscosity<EddyDiffusivity<phaseCompressibleTurbulenceModel>>::read())
+    {
+        Ck_.readIfPresent(this->coeffDict());
+
+        return true;
+    }
+    else
+    {
+        return false;
+    }
+}
+
+
+Foam::tmp<Foam::volScalarField> Foam::LESModels::recurrenceSmagorinsky::epsilon() const
+{
+    volScalarField k(this->k(fvc::grad(this->U_)));
+
+    return tmp<volScalarField>
+    (
+        new volScalarField
+        (
+            IOobject
+            (
+                IOobject::groupName("epsilon", this->U_.group()),
+                this->runTime_.timeName(),
+                this->mesh_
+            ),
+            this->Ce_*k*sqrt(k)/this->delta()
+        )
+    );
+}
+
+
+void Foam::LESModels::recurrenceSmagorinsky::correct()
+{
+    // update nut
+    correctNut();
+}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+
+// ************************************************************************* //

applications/solvers/testTwoFluidRecurrenceTurbulence/recurrenceTurbulence/recurrenceSmagorinsky/recurrenceSmagorinsky.H

@@ -0,0 +1,146 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2016 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::LESModels::recurrenceSmagorinsky
+
+Description
+    The recurrenceSmagorinsky SGS model.
+
+    This model provides Smagorinsky's turbulence quantities.
+    To be used by recurrence solvers.
+
+SourceFiles
+    recurrenceSmagorinsky.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef recurrenceSmagorinsky_H
+#define recurrenceSmagorinsky_H
+
+#include "LESModel.H"
+#include "LESeddyViscosity.H"
+#include "phaseCompressibleTurbulenceModel.H"
+#include "EddyDiffusivity.H"
+
+#include "recurrenceTurbulenceModel.H"
+
+#include "autoPtr.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace LESModels
+{
+
+/*---------------------------------------------------------------------------*\
+                           Class recurrenceSmagorinsky Declaration
+\*---------------------------------------------------------------------------*/
+
+class recurrenceSmagorinsky
+:
+    public LESeddyViscosity<EddyDiffusivity<phaseCompressibleTurbulenceModel>>,
+    public recurrenceTurbulenceModel
+{
+    // Private Member Functions
+
+        // Disallow default bitwise copy construct and assignment
+        recurrenceSmagorinsky(const recurrenceSmagorinsky&);
+        void operator=(const recurrenceSmagorinsky&);
+
+
+protected:
+
+    // Protected data
+
+        dimensionedScalar Ck_;
+
+
+    // Protected Member Functions
+
+        //- Return SGS kinetic energy
+        //  calculated from the given velocity gradient
+        tmp<volScalarField> k(const tmp<volTensorField>& gradU) const;
+
+        //- Update the SGS eddy viscosity
+        virtual void correctNut();
+
+
+public:
+
+
+    //- Runtime type information
+    TypeName("recurrenceSmagorinsky");
+
+
+    // Constructors
+
+        //- Construct from components
+        recurrenceSmagorinsky
+        (
+            const volScalarField& alpha,
+            const volScalarField& rho,
+            const volVectorField& U,
+            const surfaceScalarField& alphaRhoPhi,
+            const surfaceScalarField& phi,
+            const phaseModel& transport,
+            const word& propertiesName = turbulenceModel::propertiesName,
+            const word& type = typeName
+        );
+
+
+    //- Destructor
+    virtual ~recurrenceSmagorinsky()
+    {}
+
+
+    // Member Functions
+
+        //- Read model coefficients if they have changed
+        virtual bool read();
+
+        //- Return SGS kinetic energy
+        virtual tmp<volScalarField> k() const
+        {
+            return k(fvc::grad(this->U_));
+        }
+
+        //- Return sub-grid disipation rate
+        virtual tmp<volScalarField> epsilon() const;
+
+        //- Correct Eddy-Viscosity and related properties
+        virtual void correct();
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace LESModels
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

applications/solvers/testTwoFluidRecurrenceTurbulence/recurrenceTurbulence/recurrenceTurbulenceModel/recurrenceTurbulenceModel.C

@@ -0,0 +1,63 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2016 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 "recurrenceTurbulenceModel.H"
+
+
+namespace Foam
+{
+    defineTypeNameAndDebug(recurrenceTurbulenceModel, 0);
+}
+
+// * * * * * * * * * * * * Protected Member Functions  * * * * * * * * * * * //
+
+
+// * * * * * * * * * * * * * * * * Constructors  * * * * * * * * * * * * * * //
+
+
+Foam::recurrenceTurbulenceModel::recurrenceTurbulenceModel
+(
+    const word group
+)
+:
+    recurrenceBasePtr_(NULL),
+    group_(group)
+{
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor  * * * * * * * * * * * * * * * //
+
+Foam::recurrenceTurbulenceModel::~recurrenceTurbulenceModel()
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions  * * * * * * * * * * * * * //
+
+
+
+
+
+// ************************************************************************* //

applications/solvers/testTwoFluidRecurrenceTurbulence/recurrenceTurbulence/recurrenceTurbulenceModel/recurrenceTurbulenceModel.H

@@ -0,0 +1,124 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2016 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::recurrenceTurbulenceModel
+
+Description
+    recurrence-based turbulence model base class
+
+    This turbulence model class provides a framework for derived turbulence
+    models to provide turbulence quantities that were computed elsewhere, 
+    i.e. taken from the recurrence dataBase.
+    
+    A concrete recurrence-based turbulence model implementation, e.g. recurrenceKEpsilon, 
+    needs to be derived from the base class of the original turbulence model 
+    and this class. This class provides the link to the recurrence model. The original 
+    base class provides the proper turbulence modelling interfaces of OpenFOAM's 
+    turbulence modelling framework.
+    
+    To be used by recurrence solvers.
+
+SourceFiles
+    recurrenceTurbulenceModel.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef recurrenceTurbulenceModel_H
+#define recurrenceTurbulenceModel_H
+
+#include "recBase.H"
+#include "recModel.H"
+
+#include "autoPtr.H"
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+                           Class recurrenceTurbulenceModel Declaration
+\*---------------------------------------------------------------------------*/
+
+class recurrenceTurbulenceModel
+{
+    // Private Member Functions
+
+
+        //- Disallow default bitwise copy construct
+        recurrenceTurbulenceModel(const recurrenceTurbulenceModel&);
+
+        //- Disallow default bitwise assignment
+        void operator=(const recurrenceTurbulenceModel&);
+        
+
+protected:
+
+    // Protected data
+
+        recBase* recurrenceBasePtr_;
+        const word group_;
+        
+    
+    // Protected Member Functions
+
+
+public:
+
+    //- Runtime type information
+    TypeName("recurrenceTurbulenceModel");
+
+
+    // Constructors
+
+        //- Construct from components
+        recurrenceTurbulenceModel
+        (
+            const word group
+        );
+
+
+    //- Destructor
+    virtual ~recurrenceTurbulenceModel();
+
+
+    // Member Functions
+        
+        void setRecurrenceBasePtr(recBase* recurrenceBasePtr)
+        {
+            recurrenceBasePtr_ = recurrenceBasePtr;
+        }
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

applications/solvers/testTwoFluidRecurrenceTurbulence/recurrenceTurbulence/recurrenceTurbulenceModels.C

@@ -0,0 +1,89 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2014-2015 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 "phaseCompressibleTurbulenceModel.H"
+#include "addToRunTimeSelectionTable.H"
+#include "makeTurbulenceModel.H"
+
+#include "laminar.H"
+#include "RASModel.H"
+#include "LESModel.H"
+
+#include "recurrenceKEpsilon.H"
+#include "recurrenceKOmega.H"
+#include "recurrenceSmagorinsky.H"
+
+
+
+// Instructions for OpenFOAM-5.0 
+/*makeTurbulenceModelTypes
+(
+    volScalarField,
+    volScalarField,
+    compressibleTurbulenceModel,
+    PhaseCompressibleTurbulenceModel,
+    ThermalDiffusivity,
+    phaseModel
+);
+
+
+makeTurbulenceModel
+(phaseModelPhaseCompressibleTurbulenceModel, RAS, recurrenceKEpsilon);
+
+makeTurbulenceModel
+(phaseModelPhaseCompressibleTurbulenceModel, RAS, recurrenceKOmega);
+
+makeTurbulenceModel
+(phaseModelPhaseCompressibleTurbulenceModel, LES, recurrenceSmagorinsky);
+*/
+
+
+
+// Instructions for OpenFOAM-4.0 
+makeBaseTurbulenceModel
+(
+    volScalarField,
+    volScalarField,
+    compressibleTurbulenceModel,
+    PhaseCompressibleTurbulenceModel,
+    ThermalDiffusivity,
+    phaseModel
+);
+
+#define makeRASModel(Type)                                            \
+    makeTurbulenceModel                                               \
+    (phaseModelPhaseCompressibleTurbulenceModel, RAS, Type)
+
+#define makeLESModel(Type)                                            \
+    makeTurbulenceModel                                               \
+    (phaseModelPhaseCompressibleTurbulenceModel, LES, Type)
+
+makeRASModel(recurrenceKEpsilon);
+
+makeRASModel(recurrenceKOmega);
+
+makeLESModel(recurrenceSmagorinsky);
+
+// ************************************************************************* //

applications/solvers/testTwoFluidRecurrenceTurbulence/testTwoFluidRecurrenceTurbulence.C

@@ -0,0 +1,165 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2016 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/>.
+
+Application
+    testTwoFluidRecurrenceTurbulence
+
+Description
+    A modified variant of the two-fluid, recurrence model A solver
+    with the extension of recurrence-based, multi-phase turbulence modelling.
+    This application is used to test whether turbulent fields can be provided
+    by the recurrence-based turbulence models.
+    
+    Run this test application in a recurrence case, with turbulence enabled and 
+    the necessary turbulent field quantities present in the data base.
+    
+    Note the initialisation in checkTurbulenceModels.H
+    Updating the turbulence model is done by calling phaseX.correctTurbulence()
+    in the file readFields.H
+
+\*---------------------------------------------------------------------------*/
+
+#include "fvCFD.H"
+#include "twoPhaseSystem.H"
+#include "phaseCompressibleTurbulenceModel.H"
+#include "pimpleControl.H"
+#include "localEulerDdtScheme.H"
+#include "fvcSmooth.H"
+
+#include "recBase.H"
+#include "recModel.H"
+
+#include "recurrenceTurbulenceModel.H"
+
+/* // uncomment for OpenFOAM-5.0
+namespace Foam
+{
+    tmp<volScalarField> byDt(const volScalarField& vf)
+    {
+        if (fv::localEulerDdt::enabled(vf.mesh()))
+        {
+            return fv::localEulerDdt::localRDeltaT(vf.mesh())*vf;
+        }
+        else
+        {
+            return vf/vf.mesh().time().deltaT();
+        }
+    }
+
+    tmp<surfaceScalarField> byDt(const surfaceScalarField& sf)
+    {
+        if (fv::localEulerDdt::enabled(sf.mesh()))
+        {
+            return fv::localEulerDdt::localRDeltaTf(sf.mesh())*sf;
+        }
+        else
+        {
+            return sf/sf.mesh().time().deltaT();
+        }
+    }
+}
+*/
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+int main(int argc, char *argv[])
+{
+    #include "postProcess.H"
+
+    #include "setRootCase.H"
+    #include "createTime.H"
+    #include "createMesh.H"
+    #include "createControl.H"
+    #include "createTimeControls.H"
+    #include "createRDeltaT.H" // remove for OpenFOAM-5.0
+    #include "createFields.H"
+    #include "createFieldRefs.H"
+    
+    #include "createTransportFields.H"
+
+    if (!LTS)
+    {
+        #include "CourantNo.H"
+        #include "setInitialDeltaT.H"
+    }
+    
+    Switch faceMomentum
+    (
+        pimple.dict().lookupOrDefault<Switch>("faceMomentum", false)
+    );
+
+    
+    recBase recurrenceBase(mesh);
+    
+    #include "checkTurbulenceModels.H"
+
+    #include "pUf/createDDtU.H"
+
+    // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+    Info<< "\nStarting recurrence-based time loop\n" << endl;
+    
+    label recTimeIndex(0);
+    scalar recTimeStep_=recurrenceBase.recM().recTimeStep();
+
+    while (runTime.run())
+    {
+        #include "readTimeControls.H"
+
+        #include "CourantNos.H"
+        #include "setDeltaT.H"
+
+        runTime++;
+        Info<< "Time = " << runTime.timeName() << nl << endl;
+
+        
+        #include "CEqn.H"
+        
+        
+        if ( runTime.timeOutputValue() - (recTimeIndex+1)*recTimeStep_ + 1.0e-5 > 0.0 )
+        {
+	        Info << "Updating fields at run time " << runTime.timeOutputValue()
+	            << " corresponding to recurrence time " << (recTimeIndex+1)*recTimeStep_ << ".\n" << endl;
+	        
+            recurrenceBase.updateRecFields();
+	        #include "readFields.H"
+            recTimeIndex++;
+        }
+        
+
+        runTime.write();
+        
+        #include "writeCField.H"
+
+        Info<< "ExecutionTime = "
+            << runTime.elapsedCpuTime()
+            << " s\n\n" << endl;
+    }
+
+    Info<< "End\n" << endl;
+
+    return 0;
+}
+
+
+// ************************************************************************* //

applications/solvers/testTwoFluidRecurrenceTurbulence/writeCField.H

@@ -0,0 +1,12 @@
+/* ----------------------------------------------
+	Write averaged particle volume fraction
+---------------------------------------------- */
+
+// essential information
+Info << "Total mass :";
+Info << tab << sum(C*rhoCarrier*alphaCarrier*mesh.V());
+Info << endl;
+
+Info << "Total Carrier mass :";
+Info << tab << sum(rhoCarrier*alphaCarrier*mesh.V());
+Info << endl;

src/recurrence/recModel/recModel/recModel.H

@@ -219,6 +219,22 @@ public:
 
     void writeRecPath();
 
+
+    const wordList volScalarFieldNames()
+    {
+        return volScalarFieldNames_;
+    }
+
+    const wordList volVectorFieldNames()
+    {
+        return volVectorFieldNames_;
+    }
+
+    const wordList surfaceScalarFieldNames()
+    {
+        return surfaceScalarFieldNames_;
+    }
+
     void writeRecPathLastInterval();
 };
 

tutorials/testTwoFluidRecurrenceTurbulence/.gitignore

@@ -0,0 +1,8 @@
+rec_jump.dat
+recurrencePath
+recurrenceMatrix
+
+dataBase
+initFields
+
+polyMesh

tutorials/testTwoFluidRecurrenceTurbulence/testRecurrenceKEpsilon/init/0.org/T.air

@@ -0,0 +1,43 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  2.3.x                                 |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      binary;
+    class       volScalarField;
+    location    "0";
+    object      T.air;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+dimensions      [0 0 0 1 0 0 0];
+
+internalField   uniform 300;
+
+boundaryField
+{
+    inlet
+    {
+        type            fixedValue;
+        value           uniform 300;
+    }
+    outlet
+    {
+        type            inletOutlet;
+        phi             phi.air;
+        inletValue      uniform 300;
+        value           uniform 300;
+    }
+    walls
+    {
+        type            zeroGradient;
+    }
+}
+
+
+// ************************************************************************* //

tutorials/testTwoFluidRecurrenceTurbulence/testRecurrenceKEpsilon/init/0.org/T.water

@@ -0,0 +1,43 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  2.3.x                                 |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      binary;
+    class       volScalarField;
+    location    "0";
+    object      T.water;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+dimensions      [0 0 0 1 0 0 0];
+
+internalField   uniform 300;
+
+boundaryField
+{
+    inlet
+    {
+        type            fixedValue;
+        value           uniform 300;
+    }
+    outlet
+    {
+        type            inletOutlet;
+        phi             phi.water;
+        inletValue      uniform 300;
+        value           uniform 300;
+    }
+    walls
+    {
+        type            zeroGradient;
+    }
+}
+
+
+// ************************************************************************* //

tutorials/testTwoFluidRecurrenceTurbulence/testRecurrenceKEpsilon/init/0.org/U.air

@@ -0,0 +1,41 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  2.3.x                                 |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      binary;
+    class       volVectorField;
+    location    "0";
+    object      U.air;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+dimensions      [0 1 -1 0 0 0 0];
+
+internalField   uniform (0 0 0);
+
+boundaryField
+{
+    inlet
+    {
+        type            fixedValue;
+        value           uniform (0 0 0.25744);
+    }
+    outlet
+    {
+        type            zeroGradient;
+    }
+    walls
+    {
+        type            fixedValue;
+        value           uniform (0 0 0);
+    }
+}
+
+
+// ************************************************************************* //

tutorials/testTwoFluidRecurrenceTurbulence/testRecurrenceKEpsilon/init/0.org/U.water

@@ -0,0 +1,41 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  2.3.x                                 |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      binary;
+    class       volVectorField;
+    location    "0";
+    object      U.water;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+dimensions      [0 1 -1 0 0 0 0];
+
+internalField   uniform (0 0 0);
+
+boundaryField
+{
+    inlet
+    {
+        type            fixedValue;
+        value           uniform (0 0 0);
+    }
+    outlet
+    {
+        type            slip;
+    }
+    walls
+    {
+        type            fixedValue;
+        value           uniform (0 0 0);
+    }
+}
+
+
+// ************************************************************************* //

tutorials/testTwoFluidRecurrenceTurbulence/testRecurrenceKEpsilon/init/0.org/alpha.air

@@ -0,0 +1,43 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  2.3.x                                 |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      binary;
+    class       volScalarField;
+    location    "0";
+    object      alpha.air;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+dimensions      [0 0 0 0 0 0 0];
+
+internalField   uniform 0;
+
+boundaryField
+{
+    inlet
+    {
+        type            fixedValue;
+        value           uniform 0.6;
+    }
+    outlet
+    {
+        type            inletOutlet;
+        phi             phi.air;
+        inletValue      uniform 0;
+        value           uniform 0;
+    }
+    walls
+    {
+        type            zeroGradient;
+    }
+}
+
+
+// ************************************************************************* //

tutorials/testTwoFluidRecurrenceTurbulence/testRecurrenceKEpsilon/init/0.org/alphat.air

@@ -0,0 +1,48 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  4.0                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       volScalarField;
+    object      alphat.air;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+dimensions      [1 -1 -1 0 0 0 0];
+
+internalField   uniform 0;
+
+boundaryField
+{
+    inlet
+    {
+        type            calculated;
+        value           $internalField;
+    }
+
+    outlet
+    {
+        type            calculated;
+        value           $internalField;
+    }
+
+    walls
+    {
+        type            compressible::alphatWallFunction;
+        Prt             0.85;
+        value           $internalField;
+    }
+
+    defaultFaces
+    {
+        type            empty;
+    }
+}
+
+// ************************************************************************* //

tutorials/testTwoFluidRecurrenceTurbulence/testRecurrenceKEpsilon/init/0.org/alphat.water

@@ -0,0 +1,48 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  4.0                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       volScalarField;
+    object      alphat.water;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+dimensions      [1 -1 -1 0 0 0 0];
+
+internalField   uniform 0;
+
+boundaryField
+{
+    inlet
+    {
+        type            calculated;
+        value           $internalField;
+    }
+
+    outlet
+    {
+        type            calculated;
+        value           $internalField;
+    }
+
+    walls
+    {
+        type            compressible::alphatWallFunction;
+        Prt             0.85;
+        value           $internalField;
+    }
+
+    defaultFaces
+    {
+        type            empty;
+    }
+}
+
+// ************************************************************************* //

tutorials/testTwoFluidRecurrenceTurbulence/testRecurrenceKEpsilon/init/0.org/epsilon.air

@@ -0,0 +1,44 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  2.3.x                                 |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      binary;
+    class       volScalarField;
+    location    "0";
+    object      epsilon.air;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+dimensions      [0 2 -3 0 0 0 0];
+
+internalField   uniform 0.000248;
+
+boundaryField
+{
+    inlet
+    {
+        type            fixedValue;
+        value           uniform 0.000248;
+    }
+    outlet
+    {
+        type            inletOutlet;
+        phi             phi.air;
+        inletValue      uniform 0.000248;
+        value           uniform 0.000248;
+    }
+    walls
+    {
+        type            epsilonWallFunction;
+        value           uniform 0.000248;
+    }
+}
+
+
+// ************************************************************************* //

tutorials/testTwoFluidRecurrenceTurbulence/testRecurrenceKEpsilon/init/0.org/epsilon.water

@@ -0,0 +1,44 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  2.3.x                                 |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      binary;
+    class       volScalarField;
+    location    "0";
+    object      epsilon.water;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+dimensions      [0 2 -3 0 0 0 0];
+
+internalField   uniform 0.000248;
+
+boundaryField
+{
+    inlet
+    {
+        type            fixedValue;
+        value           uniform 0.000248;
+    }
+    outlet
+    {
+        type            inletOutlet;
+        phi             phi.water;
+        inletValue      uniform 0.000248;
+        value           uniform 0.000248;
+    }
+    walls
+    {
+        type            epsilonWallFunction;
+        value           uniform 0.000248;
+    }
+}
+
+
+// ************************************************************************* //

tutorials/testTwoFluidRecurrenceTurbulence/testRecurrenceKEpsilon/init/0.org/k.air

@@ -0,0 +1,44 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  2.3.x                                 |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      binary;
+    class       volScalarField;
+    location    "0";
+    object      k.air;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+dimensions      [0 2 -2 0 0 0 0];
+
+internalField   uniform 0.000216;
+
+boundaryField
+{
+    inlet
+    {
+        type            fixedValue;
+        value           uniform 0.000216;
+    }
+    outlet
+    {
+        type            inletOutlet;
+        phi             phi.air;
+        inletValue      uniform 0.000216;
+        value           uniform 0.000216;
+    }
+    walls
+    {
+        type            kqRWallFunction;
+        value           uniform 0.000216;
+    }
+}
+
+
+// ************************************************************************* //

tutorials/testTwoFluidRecurrenceTurbulence/testRecurrenceKEpsilon/init/0.org/k.water

@@ -0,0 +1,44 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  2.3.x                                 |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      binary;
+    class       volScalarField;
+    location    "0";
+    object      k.water;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+dimensions      [0 2 -2 0 0 0 0];
+
+internalField   uniform 0.000216;
+
+boundaryField
+{
+    inlet
+    {
+        type            fixedValue;
+        value           uniform 0.000216;
+    }
+    outlet
+    {
+        type            inletOutlet;
+        phi             phi.water;
+        inletValue      uniform 0.000216;
+        value           uniform 0.000216;
+    }
+    walls
+    {
+        type            kqRWallFunction;
+        value           uniform 0.000216;
+    }
+}
+
+
+// ************************************************************************* //

tutorials/testTwoFluidRecurrenceTurbulence/testRecurrenceKEpsilon/init/0.org/nut.air

@@ -0,0 +1,42 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  2.3.x                                 |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      binary;
+    class       volScalarField;
+    location    "0";
+    object      nut.air;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+dimensions      [0 2 -1 0 0 0 0];
+
+internalField   uniform 1e-08;
+
+boundaryField
+{
+    inlet
+    {
+        type            calculated;
+        value           uniform 1e-08;
+    }
+    outlet
+    {
+        type            calculated;
+        value           uniform 1e-08;
+    }
+    walls
+    {
+        type            nutkWallFunction;
+        value           uniform 1e-08;
+    }
+}
+
+
+// ************************************************************************* //

tutorials/testTwoFluidRecurrenceTurbulence/testRecurrenceKEpsilon/init/0.org/nut.water

@@ -0,0 +1,42 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  2.3.x                                 |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      binary;
+    class       volScalarField;
+    location    "0";
+    object      nut.water;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+dimensions      [0 2 -1 0 0 0 0];
+
+internalField   uniform 1e-08;
+
+boundaryField
+{
+    inlet
+    {
+        type            calculated;
+        value           uniform 1e-08;
+    }
+    outlet
+    {
+        type            calculated;
+        value           uniform 1e-08;
+    }
+    walls
+    {
+        type            nutkWallFunction;
+        value           uniform 1e-08;
+    }
+}
+
+
+// ************************************************************************* //

tutorials/testTwoFluidRecurrenceTurbulence/testRecurrenceKEpsilon/init/0.org/omega.water

@@ -0,0 +1,44 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  2.3.x                                 |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      binary;
+    class       volScalarField;
+    location    "0";
+    object      omega.water;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+dimensions      [0 0 -1 0 0 0 0];
+
+internalField   uniform 0.0001;
+
+boundaryField
+{
+    inlet
+    {
+        type            fixedValue;
+        value           uniform 0.0001;
+    }
+    outlet
+    {
+        type            inletOutlet;
+        phi             phi.water;
+        inletValue      uniform 0.0001;
+        value           uniform 0.0001;
+    }
+    walls
+    {
+        type            omegaWallFunction;
+        value           uniform 0.0001;
+    }
+}
+
+
+// ************************************************************************* //

tutorials/testTwoFluidRecurrenceTurbulence/testRecurrenceKEpsilon/init/0.org/p

@@ -0,0 +1,44 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  2.3.x                                 |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      binary;
+    class       volScalarField;
+    location    "0";
+    object      p;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+dimensions      [1 -1 -2 0 0 0 0];
+
+internalField   uniform 100000;
+
+boundaryField
+{
+    inlet
+    {
+        type            fixedFluxPressure;
+        gradient        uniform 0;
+        value           uniform 100000;
+    }
+    outlet
+    {
+        type            fixedValue;
+        value           uniform 100000;
+    }
+    walls
+    {
+        type            fixedFluxPressure;
+        gradient        uniform 0;
+        value           uniform 100000;
+    }
+}
+
+
+// ************************************************************************* //

tutorials/testTwoFluidRecurrenceTurbulence/testRecurrenceKEpsilon/init/0.org/p_rgh

@@ -0,0 +1,41 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  4.0                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       volScalarField;
+    object      p_rgh;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+dimensions          [1 -1 -2 0 0 0 0];
+
+internalField       uniform 1e5;
+
+boundaryField
+{
+    inlet
+    {
+        type            fixedFluxPressure;
+        value           $internalField;
+    }
+    outlet
+    {
+        type            prghPressure;
+        p               $internalField;
+        value           $internalField;
+    }
+    walls
+    {
+        type            fixedFluxPressure;
+        value           $internalField;
+    }
+}
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

tutorials/testTwoFluidRecurrenceTurbulence/testRecurrenceKEpsilon/init/Allclean

@@ -0,0 +1,13 @@
+#!/bin/sh
+cd ${0%/*} || exit 1    # Run from this directory
+
+# Source tutorial clean functions
+. $WM_PROJECT_DIR/bin/tools/CleanFunctions
+
+cleanCase
+
+rm -rf 0
+
+rm -rf initFields
+
+#------------------------------------------------------------------------------

tutorials/testTwoFluidRecurrenceTurbulence/testRecurrenceKEpsilon/init/Allrun

@@ -0,0 +1,27 @@
+#!/bin/sh
+cd ${0%/*} || exit 1    # Run from this directory
+
+# Source tutorial run functions
+. $WM_PROJECT_DIR/bin/tools/RunFunctions
+
+# Set application name
+application=`getApplication`
+
+
+rm -rf 0
+
+runApplication blockMesh
+
+runApplication renumberMesh -overwrite
+
+cp -r 0.org 0
+
+tar -xf  ../../initFields.tar.xz
+
+cp initFields/* 0/
+
+runApplication $application
+
+./createDataBase
+
+#------------------------------------------------------------------------------

tutorials/testTwoFluidRecurrenceTurbulence/testRecurrenceKEpsilon/init/constant/g

@@ -0,0 +1,22 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  2.3.x                                 |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       uniformDimensionedVectorField;
+    location    "constant";
+    object      g;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+dimensions      [0 1 -2 0 0 0 0];
+value           (0 0 -9.81);
+
+
+// ************************************************************************* //

tutorials/testTwoFluidRecurrenceTurbulence/testRecurrenceKEpsilon/init/constant/phaseProperties

@@ -0,0 +1,173 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  4.0                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    location    "constant";
+    object      phaseProperties;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+type    heatAndMomentumTransferTwoPhaseSystem;
+
+phases (air water);
+
+air
+{
+    type            purePhaseModel;
+    diameterModel   isothermal;
+    isothermalCoeffs
+    {
+        d0              3e-3;
+        p0              1e5;
+    }
+
+    residualAlpha   1e-6;
+}
+
+water
+{
+    type            purePhaseModel;
+    diameterModel   constant;
+    constantCoeffs
+    {
+        d               1e-4;
+    }
+
+    residualAlpha   1e-6;
+}
+
+blending
+{
+    default
+    {
+        type            linear;
+        minFullyContinuousAlpha.air 0.7;
+        minPartlyContinuousAlpha.air 0.5;
+        minFullyContinuousAlpha.water 0.7;
+        minPartlyContinuousAlpha.water 0.5;
+    }
+}
+
+surfaceTension
+(
+    (air and water)
+    {
+        type            constant;
+        sigma           0.07;
+    }
+);
+
+aspectRatio
+(
+    (air in water)
+    {
+        type            constant;
+        E0              1.0;
+    }
+
+    (water in air)
+    {
+        type            constant;
+        E0              1.0;
+    }
+);
+
+drag
+(
+    (air in water)
+    {
+        type            TomiyamaCorrelated;
+        A               24.0;
+        
+        residualRe      1e-3;
+        swarmCorrection
+        {
+            type        none;
+        }
+    }
+
+    (water in air)
+    {
+        type            SchillerNaumann;
+        residualRe      1e-3;
+        swarmCorrection
+        {
+            type        none;
+        }
+    }
+
+    (air and water)
+    {
+        type            segregated;
+        m               0.5;
+        n               8;
+        swarmCorrection
+        {
+            type        none;
+        }
+    }
+);
+
+virtualMass
+(
+    (air in water)
+    {
+        type            constantCoefficient;
+        Cvm             0.5;
+    }
+
+    (water in air)
+    {
+        type            constantCoefficient;
+        Cvm             0.5;
+    }
+);
+
+heatTransfer
+(
+    (air in water)
+    {
+        type            RanzMarshall;
+        residualAlpha   1e-4;
+    }
+
+    (water in air)
+    {
+        type            RanzMarshall;
+        residualAlpha   1e-4;
+    }
+);
+
+lift
+(
+    (air in water)
+	{
+		type			Tomiyama;
+		residualAlpha   1e-6;
+        residualRe      1e-3;
+		residualEo		1e-6;
+        residualEE      1e-6;
+	}
+);
+
+wallLubrication
+(
+);
+
+turbulentDispersion
+(
+);
+
+// Minimum allowable pressure
+pMin            10000;
+
+
+// ************************************************************************* //

tutorials/testTwoFluidRecurrenceTurbulence/testRecurrenceKEpsilon/init/constant/recProperties

@@ -0,0 +1,85 @@
+/*---------------------------------------------------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  1.4                                   |
+|   \\  /    A nd           | Web:      http://www.openfoam.org               |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+
+
+FoamFile
+{
+    version         2.0;
+    format          ascii;
+
+    root            "";
+    case            "";
+    instance        "";
+    local           "";
+
+    class           dictionary;
+    object          recProperties;
+}
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+//===========================================================================//
+// sub-models & settings
+
+
+recModel standardRecModel;
+
+verbose false;
+
+recNorm sqrDiffNorm;
+
+recPath simpleRandomPath;
+
+//recStatAnalysis off;//standardRecStatAnalysis;
+
+volScalarFields
+(
+    alpha.air
+);
+
+volVectorFields
+(
+    U.water
+);
+
+surfaceScalarFields
+(
+);
+
+//verbose;
+
+
+
+//===========================================================================//
+// sub-model properties
+
+standardRecModelProps
+{
+    dataBase    ".";
+    
+    skipZero    on;
+}
+
+sqrDiffNormProps
+{
+  normConstant -1.0;
+  fieldType "volScalarField";
+  fieldName "alpha.air";
+  
+  //verbose   false;
+}
+
+simpleRandomPathProps
+{
+}
+
+noRecStatAnalysis
+{
+}
+
+// ************************************************************************* //

tutorials/testTwoFluidRecurrenceTurbulence/testRecurrenceKEpsilon/init/constant/thermophysicalProperties.air

@@ -0,0 +1,49 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  2.3.x                                 |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    location    "constant";
+    object      thermophysicalProperties.air;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+thermoType
+{
+    type            heRhoThermo;
+    mixture         pureMixture;
+    transport       const;
+    thermo          hConst;
+    equationOfState perfectGas;
+    specie          specie;
+    energy          sensibleInternalEnergy;
+}
+
+mixture
+{
+    specie
+    {
+        nMoles      1;
+        molWeight   28.9;
+    }
+    thermodynamics
+    {
+        Cp          1007;
+        Hf          0;
+    }
+    transport
+    {
+        mu          1.84e-05;
+        Pr          0.7;
+    }
+}
+
+
+// ************************************************************************* //

tutorials/testTwoFluidRecurrenceTurbulence/testRecurrenceKEpsilon/init/constant/thermophysicalProperties.water

@@ -0,0 +1,54 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  2.3.x                                 |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    location    "constant";
+    object      thermophysicalProperties.water;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+thermoType
+{
+    type            heRhoThermo;
+    mixture         pureMixture;
+    transport       const;
+    thermo          hConst;
+    equationOfState perfectFluid;
+    specie          specie;
+    energy          sensibleInternalEnergy;
+}
+
+mixture
+{
+    specie
+    {
+        nMoles      1;
+        molWeight   18;
+    }
+    equationOfState
+    {
+        R           3000;
+        rho0        1027;
+    }
+    thermodynamics
+    {
+        Cp          4195;
+        Hf          0;
+    }
+    transport
+    {
+        mu          3.645e-4;
+        Pr          2.289;
+    }
+}
+
+
+// ************************************************************************* //

tutorials/testTwoFluidRecurrenceTurbulence/testRecurrenceKEpsilon/init/constant/turbulenceProperties.air

@@ -0,0 +1,29 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  2.3.x                                 |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    location    "constant";
+    object      turbulenceProperties.air;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+simulationType  laminar;
+//simulationType  RAS;
+
+RAS
+{
+    RASModel mixtureKEpsilon;
+
+    turbulence      on;
+    printCoeffs     on;
+}
+
+// ************************************************************************* //

tutorials/testTwoFluidRecurrenceTurbulence/testRecurrenceKEpsilon/init/constant/turbulenceProperties.water

@@ -0,0 +1,29 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  2.3.x                                 |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    location    "constant";
+    object      turbulenceProperties.water;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+//simulationType  LES;
+simulationType  RAS;
+
+
+RAS
+{
+    RASModel kEpsilon;
+
+    turbulence      on;
+    printCoeffs     on;
+}
+// ************************************************************************* //

tutorials/testTwoFluidRecurrenceTurbulence/testRecurrenceKEpsilon/init/createDataBase

@@ -0,0 +1,38 @@
+#!/bin/bash
+cd ${0%/*} || exit 1    # Run from this directory
+
+
+echo ""
+
+if [ -e ../dataBase ];
+then
+    echo "dataBase exists"
+else
+    echo "no local dataBase found"
+    echo "   ... creating dataBase"
+    mkdir ../dataBase
+    
+    # copy system directory to dataBase
+    cp -r system ../dataBase/
+    
+    # copy mesh from init to dataBase
+    mkdir ../dataBase/constant
+    cp -r constant/polyMesh ../dataBase/constant/
+    
+    # fill dataBase from init case
+    # adjust copy commands when changing init case endTime
+    cp -r [2-9][0-9]* ../dataBase/
+    
+    # rename folders and delete 'uniform' directories
+    cd ../dataBase
+    rename 's/(\d+)/($1-28)/e' *
+    find . -type d -name uniform | xargs rm -rf
+    
+    echo "   ... dataBase created"
+    
+    cd ../init
+fi
+
+echo ""
+
+#------------------------------------------------------------------------------

tutorials/testTwoFluidRecurrenceTurbulence/testRecurrenceKEpsilon/init/system/blockMeshDict

@@ -0,0 +1,286 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  2.1.x                                 |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    object      blockMeshDict;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+convertToMeters 1;
+
+// # this blockMeshDict was generated by m4
+ // # enter heights (z coordinates)
+
+
+
+ // # enter x coordinates
+
+
+
+ // # enter y coordinates
+
+
+
+ // # enter discretization length
+ // # note: 	the mesh size is calculated using this values
+ // # 		due to truncation errors the final discretization length may differ
+
+// # relDiff: ($1 - $2) / $3   # decimal places truncated (done by format %.0f)
+
+
+
+
+
+// # calculate the mesh size
+
+
+
+
+
+
+
+
+
+
+
+
+// # vertex coordinates were generated using pre-defined symbols
+vertices
+(
+    // first row - 17
+    (0  0 0)	// 0
+    (0.085 0 0)	// 1
+    (0.115 0 0)	// 2
+    (0.20 0 0)	// 3
+    
+    (0  0.02 0)	// 4
+    (0.085 0.02 0)	// 5
+    (0.115 0.02 0)	// 6
+    (0.20 0.02 0)	// 7
+    
+    (0  0.03 0)	// 8
+    (0.085 0.03 0)	// 9
+    (0.115 0.03 0)	// 10
+    (0.20 0.03 0)	// 11
+    
+    (0  0.05 0)	// 12
+    (0.085 0.05 0)	// 13
+    (0.115 0.05 0)	// 14
+    (0.20 0.05 0)	// 15
+    
+    // second row
+    (0  0 0.10)	// 16
+    (0.085 0 0.10)	// 17
+    (0.115 0 0.10)	// 18
+    (0.20 0 0.10)	// 19
+    
+    (0  0.02 0.10)	// 20
+    (0.085 0.02 0.10)	// 21
+    (0.115 0.02 0.10)	// 22
+    (0.20 0.02 0.10)	// 23
+    
+    (0  0.03 0.10)	// 24
+    (0.085 0.03 0.10)	// 25
+    (0.115 0.03 0.10)	// 26
+    (0.20 0.03 0.10)	// 27
+    
+    (0  0.05 0.10)	// 28
+    (0.085 0.05 0.10)	// 29
+    (0.115 0.05 0.10)	// 30
+    (0.20 0.05 0.10)	// 31
+    
+    // third row
+    (0  0 0.30)	// 32
+    (0.085 0 0.30)	// 33
+    (0.115 0 0.30)	// 34
+    (0.20 0 0.30)	// 35
+    
+    (0  0.02 0.30)	// 36
+    (0.085 0.02 0.30)	// 37
+    (0.115 0.02 0.30)	// 38
+    (0.20 0.02 0.30)	// 39
+    
+    (0  0.03 0.30)	// 40
+    (0.085 0.03 0.30)	// 41
+    (0.115 0.03 0.30)	// 42
+    (0.20 0.03 0.30)	// 43
+    
+    (0  0.05 0.30)	// 44
+    (0.085 0.05 0.30)	// 45
+    (0.115 0.05 0.30)	// 46
+    (0.20 0.05 0.30)	// 47
+    
+    // forth row
+    (0  0 0.45)	// 48
+    (0.085 0 0.45)	// 49
+    (0.115 0 0.45)	// 50
+    (0.20 0 0.45)	// 51
+    
+    (0  0.02 0.45)	// 52
+    (0.085 0.02 0.45)	// 53
+    (0.115 0.02 0.45)	// 54
+    (0.20 0.02 0.45)	// 55
+    
+    (0  0.03 0.45)	// 56
+    (0.085 0.03 0.45)	// 57
+    (0.115 0.03 0.45)	// 58
+    (0.20 0.03 0.45)	// 59
+    
+    (0  0.05 0.45)	// 60
+    (0.085 0.05 0.45)	// 61
+    (0.115 0.05 0.45)	// 62
+    (0.20 0.05 0.45)	// 63
+    
+);
+
+// # mesh size was calculated
+blocks
+(
+    // first row
+    hex (0 1 5 4 16 17 21 20) (17 4 20) simpleGrading (1 1 1)	// 1
+    hex (1 2 6 5 17 18 22 21) (6 4 20) simpleGrading (1 1 1)	// 2
+    hex (2 3 7 6 18 19 23 22) (17 4 20) simpleGrading (1 1 1)	// 3
+    hex (4 5 9 8 20 21 25 24) (17 2 20) simpleGrading (1 1 1)	// 4
+    hex (5 6 10 9 21 22 26 25) (6 2 20) simpleGrading (1 1 1)	// 5
+    hex (6 7 11 10 22 23 27 26) (17 2 20) simpleGrading (1 1 1)	// 6
+    hex (8 9 13 12 24 25 29 28) (17 4 20) simpleGrading (1 1 1)	// 7
+    hex (9 10 14 13 25 26 30 29) (6 4 20) simpleGrading (1 1 1)	// 8
+    hex (10 11 15 14 26 27 31 30) (17 4 20) simpleGrading (1 1 1)	// 9
+    
+    // second row
+    hex (16 17 21 20 32 33 37 36) (17 4 40) simpleGrading (1 1 1)	// 10
+    hex (17 18 22 21 33 34 38 37) (6 4 40) simpleGrading (1 1 1)	// 11
+    hex (18 19 23 22 34 35 39 38) (17 4 40) simpleGrading (1 1 1)	// 12
+    hex (20 21 25 24 36 37 41 40) (17 2 40) simpleGrading (1 1 1)	// 13
+    hex (21 22 26 25 37 38 42 41) (6 2 40) simpleGrading (1 1 1)	// 14
+    hex (22 23 27 26 38 39 43 42) (17 2 40) simpleGrading (1 1 1)	// 15
+    hex (24 25 29 28 40 41 45 44) (17 4 40) simpleGrading (1 1 1)	// 16
+    hex (25 26 30 29 41 42 46 45) (6 4 40) simpleGrading (1 1 1)	// 17
+    hex (26 27 31 30 42 43 47 46) (17 4 40) simpleGrading (1 1 1)	// 18
+    
+    // third row
+    hex (32 33 37 36 48 49 53 52) (17 4 30) simpleGrading (1 1 1)	// 19
+    hex (33 34 38 37 49 50 54 53) (6 4 30) simpleGrading (1 1 1)	// 20
+    hex (34 35 39 38 50 51 55 54) (17 4 30) simpleGrading (1 1 1)	// 21
+    hex (36 37 41 40 52 53 57 56) (17 2 30) simpleGrading (1 1 1)	// 22
+    hex (37 38 42 41 53 54 58 57) (6 2 30) simpleGrading (1 1 1)	// 23
+    hex (38 39 43 42 54 55 59 58) (17 2 30) simpleGrading (1 1 1)	// 24
+    hex (40 41 45 44 56 57 61 60) (17 4 30) simpleGrading (1 1 1)	// 25
+    hex (41 42 46 45 57 58 62 61) (6 4 30) simpleGrading (1 1 1)	// 26
+    hex (42 43 47 46 58 59 63 62) (17 4 30) simpleGrading (1 1 1)	// 27
+    
+);
+
+edges
+(
+);
+
+boundary
+(
+    inlet
+    {
+        type patch;
+        faces
+        (
+            (9 10 6 5)
+        );
+    }
+    outlet
+    {
+        type patch;
+        faces
+        (
+            (48 49 53 52)
+            (49 50 54 53)
+            (50 51 55 54)
+            (52 53 57 56)
+            (53 54 58 57)
+            (54 55 59 58)
+            (56 57 61 60)
+            (57 58 62 61)
+            (58 59 63 62)
+        );
+    }
+    walls
+    {
+        type wall;
+        faces
+        (
+            // bottom
+            (4 5 1 0)
+            (5 6 2 1)
+            (6 7 3 2)
+            (8 9 5 4)
+            
+            (10 11 7 6)
+            (12 13 9 8)
+            (13 14 10 9)
+            (14 15 11 10)
+            
+            // walls - first row
+            (0 1 17 16)
+            (1 2 18 17)
+            (2 3 19 18)
+            //
+            (3 7 23 19)
+            (7 11 27 23)
+            (11 15 31 27)
+            //
+            (15 14 30 31)
+            (14 13 29 30)
+            (13 12 28 29)
+            //
+            (12 8 24 28)
+            (8 4 20 24)
+            (4 0 16 20)
+            
+            // walls - second row
+            (16 17 33 32)
+            (17 18 34 33)
+            (18 19 35 34)
+            //
+            (19 23 39 35)
+            (23 27 43 39)
+            (27 31 47 43)
+            //
+            (31 30 46 47)
+            (30 29 45 46)
+            (29 28 44 45)
+            //
+            (28 24 40 44)
+            (24 20 36 40)
+            (20 16 32 36)
+            
+            // walls - third row
+            (32 33 49 48)
+            (33 34 50 49)
+            (34 35 51 50)
+            //
+            (35 39 55 51)
+            (39 43 59 55)
+            (43 47 63 59)
+            //
+            (47 46 62 63)
+            (46 45 61 62)
+            (45 44 60 61)
+            //
+            (44 40 56 60)
+            (40 36 52 56)
+            (36 32 48 52)
+        );
+    }
+);
+
+mergePatchPairs
+(
+);
+
+// ************************************************************************* //

tutorials/testTwoFluidRecurrenceTurbulence/testRecurrenceKEpsilon/init/system/controlDict

@@ -0,0 +1,64 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  2.3.x                                 |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    location    "system";
+    object      controlDict;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+application     reactingTwoPhaseEulerFoam;
+
+//startFrom       startTime;
+startFrom       latestTime;
+
+startTime       0;
+
+//stopAt          writeNow;
+stopAt          endTime;
+
+// adjust copy commands in script createDataBase when changing this setting
+endTime         30;
+
+deltaT          0.0001;
+
+// writeControl    runTime;
+writeControl    adjustableRunTime;
+//writeControl    timeStep;
+
+writeInterval   0.1;
+
+purgeWrite      20;
+
+writeFormat     binary;
+
+writePrecision  6;
+
+writeCompression uncompressed;
+
+timeFormat      general;
+
+timePrecision   6;
+
+runTimeModifiable yes;
+
+adjustTimeStep  yes;
+
+maxCo           0.35;
+
+maxDeltaT       1;
+
+
+functions
+{
+}
+
+// ************************************************************************* //

tutorials/testTwoFluidRecurrenceTurbulence/testRecurrenceKEpsilon/init/system/fvSchemes

@@ -0,0 +1,80 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  2.3.x                                 |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    location    "system";
+    object      fvSchemes;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+ddtSchemes
+{
+    default         Euler;
+}
+
+gradSchemes
+{
+    default         Gauss linear;
+}
+
+divSchemes
+{
+    default                         none;
+
+    div(phi,alpha.air)              Gauss vanLeer01;
+    div(phir,alpha.air)             Gauss vanLeer01;
+
+    "div\((alphaRhoPhi|alphaPhi|phi).*,U.*\)"      Gauss limitedLinearV 1;
+
+    "div\((alphaRhoPhi|alphaPhi).*,(h|e).*\)"  	Gauss limitedLinear 1;
+    "div\((alphaRhoPhi|alphaPhi).*,K.*\)"      	Gauss limitedLinear 1;
+    "div\(alphaPhi.*,p\)"           			Gauss limitedLinear 1;
+
+    "div\(phim,(k|epsilon)m\)"      				Gauss limitedLinear 1;
+    "div\((alphaRhoPhi|alphaPhi).*,(k|epsilon|omega).*\)"	Gauss limitedLinear 1;
+    
+    div(((alpha.air*nuEff)*dev2(T(grad(U.air)))))			Gauss linear;
+    div(((alpha.air*nuEff.air)*dev2(T(grad(U.air)))))		Gauss linear;
+    div(((alpha.water*nuEff.water)*dev2(T(grad(U.water)))))	Gauss linear;
+    div(alphaPhi.air,thermo:rho.air)						Gauss linear;
+    div(alphaPhi.water,thermo:rho.water)					Gauss linear;
+
+    "div\(\(\(\(alpha.**thermo:rho.*\)*nuEff.*\)*dev2\(T\(grad\(U.*\)\)\)\)\)" Gauss linear;
+}
+
+laplacianSchemes
+{
+    default         Gauss linear uncorrected;
+}
+
+interpolationSchemes
+{
+    default         linear;
+}
+
+snGradSchemes
+{
+    default         uncorrected;
+}
+
+fluxRequired
+{
+    default         no;
+    p               ;
+}
+
+wallDist
+{
+    method          meshWave;
+}
+
+
+// ************************************************************************* //

tutorials/testTwoFluidRecurrenceTurbulence/testRecurrenceKEpsilon/init/system/fvSolution

@@ -0,0 +1,93 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  2.3.x                                 |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    location    "system";
+    object      fvSolution;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+solvers
+{
+    alpha.air
+    {
+        nAlphaCorr      1;
+        nAlphaSubCycles 2;
+    }
+
+    p_rgh
+    {
+        solver          GAMG;
+        smoother        DIC;
+        nPreSweeps      0;
+        nPostSweeps     2;
+        nFinestSweeps   2;
+        cacheAgglomeration true;
+        nCellsInCoarsestLevel 330;
+        agglomerator    faceAreaPair;
+        mergeLevels     1;
+        tolerance       1e-8;
+        relTol          0.01;
+    }
+
+    p_rghFinal
+    {
+        $p_rgh;
+        relTol          0;
+    }
+
+    "U.*"
+    {
+        solver          smoothSolver;
+        smoother        symGaussSeidel;
+        tolerance       1e-7;
+        relTol          0;
+        minIter         1;
+    }
+
+    "e.*"
+    {
+        solver          PBiCG;
+        preconditioner  DILU;
+        tolerance       1e-8;
+        relTol          0;
+        minIter         1;
+    }
+
+    "(k|epsilon|omega|Theta).*"
+    {
+        solver          PBiCG;
+        preconditioner  DILU;
+        tolerance       1e-8;
+        relTol          0;
+        minIter         1;
+    }
+}
+
+PIMPLE
+{
+    nOuterCorrectors 3;
+    nCorrectors      1;
+    nNonOrthogonalCorrectors 0;
+    
+    faceMomentum    true;
+}
+
+relaxationFactors
+{
+    equations
+    {
+        ".*"            1;
+    }
+}
+
+
+// ************************************************************************* //

tutorials/testTwoFluidRecurrenceTurbulence/testRecurrenceKEpsilon/recRun/0.org/C

@@ -0,0 +1,39 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  4.0                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       volScalarField;
+    location    "0";
+    object      C;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+dimensions      [0 0 0 0 0 0 0];
+
+internalField   uniform 0.5;
+
+boundaryField
+{
+    inlet
+    {
+        type            zeroGradient;
+    }
+    outlet
+    {
+        type            zeroGradient;
+    }
+    walls
+    {
+        type            zeroGradient;
+    }
+}
+
+
+// ************************************************************************* //

tutorials/testTwoFluidRecurrenceTurbulence/testRecurrenceKEpsilon/recRun/0.org/K

@@ -0,0 +1,39 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  4.0                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      binary;
+    class       volScalarField;
+    location    "0";
+    object      K;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+dimensions      [0 0 -1 0 0 0 0];
+
+internalField   uniform -1.0;
+
+boundaryField
+{
+    inlet
+    {
+        type            zeroGradient;
+    }
+    outlet
+    {
+        type            zeroGradient;
+    }
+    walls
+    {
+        type            zeroGradient;
+    }
+}
+
+
+// ************************************************************************* //

tutorials/testTwoFluidRecurrenceTurbulence/testRecurrenceKEpsilon/recRun/0.org/T.air

@@ -0,0 +1,43 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  2.3.x                                 |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      binary;
+    class       volScalarField;
+    location    "0";
+    object      T.air;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+dimensions      [0 0 0 1 0 0 0];
+
+internalField   uniform 300;
+
+boundaryField
+{
+    inlet
+    {
+        type            fixedValue;
+        value           uniform 300;
+    }
+    outlet
+    {
+        type            inletOutlet;
+        phi             phi.air;
+        inletValue      uniform 300;
+        value           uniform 300;
+    }
+    walls
+    {
+        type            zeroGradient;
+    }
+}
+
+
+// ************************************************************************* //

tutorials/testTwoFluidRecurrenceTurbulence/testRecurrenceKEpsilon/recRun/0.org/T.water

@@ -0,0 +1,43 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  2.3.x                                 |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      binary;
+    class       volScalarField;
+    location    "0";
+    object      T.water;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+dimensions      [0 0 0 1 0 0 0];
+
+internalField   uniform 300;
+
+boundaryField
+{
+    inlet
+    {
+        type            fixedValue;
+        value           uniform 300;
+    }
+    outlet
+    {
+        type            inletOutlet;
+        phi             phi.water;
+        inletValue      uniform 300;
+        value           uniform 300;
+    }
+    walls
+    {
+        type            zeroGradient;
+    }
+}
+
+
+// ************************************************************************* //

tutorials/testTwoFluidRecurrenceTurbulence/testRecurrenceKEpsilon/recRun/0.org/U.air

@@ -0,0 +1,41 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  2.3.x                                 |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      binary;
+    class       volVectorField;
+    location    "0";
+    object      U.air;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+dimensions      [0 1 -1 0 0 0 0];
+
+internalField   uniform (0 0 0);
+
+boundaryField
+{
+    inlet
+    {
+        type            fixedValue;
+        value           uniform (0 0 0.25744);
+    }
+    outlet
+    {
+        type            zeroGradient;
+    }
+    walls
+    {
+        type            fixedValue;
+        value           uniform (0 0 0);
+    }
+}
+
+
+// ************************************************************************* //

tutorials/testTwoFluidRecurrenceTurbulence/testRecurrenceKEpsilon/recRun/0.org/U.water

@@ -0,0 +1,41 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  2.3.x                                 |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      binary;
+    class       volVectorField;
+    location    "0";
+    object      U.water;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+dimensions      [0 1 -1 0 0 0 0];
+
+internalField   uniform (0 0 0);
+
+boundaryField
+{
+    inlet
+    {
+        type            fixedValue;
+        value           uniform (0 0 0);
+    }
+    outlet
+    {
+        type            slip;
+    }
+    walls
+    {
+        type            fixedValue;
+        value           uniform (0 0 0);
+    }
+}
+
+
+// ************************************************************************* //

tutorials/testTwoFluidRecurrenceTurbulence/testRecurrenceKEpsilon/recRun/0.org/alpha.air

@@ -0,0 +1,43 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  2.3.x                                 |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      binary;
+    class       volScalarField;
+    location    "0";
+    object      alpha.air;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+dimensions      [0 0 0 0 0 0 0];
+
+internalField   uniform 0;
+
+boundaryField
+{
+    inlet
+    {
+        type            fixedValue;
+        value           uniform 0.6;
+    }
+    outlet
+    {
+        type            inletOutlet;
+        phi             phi.air;
+        inletValue      uniform 0;
+        value           uniform 0;
+    }
+    walls
+    {
+        type            zeroGradient;
+    }
+}
+
+
+// ************************************************************************* //

tutorials/testTwoFluidRecurrenceTurbulence/testRecurrenceKEpsilon/recRun/0.org/alphat.air

@@ -0,0 +1,48 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  4.0                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       volScalarField;
+    object      alphat.air;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+dimensions      [1 -1 -1 0 0 0 0];
+
+internalField   uniform 0;
+
+boundaryField
+{
+    inlet
+    {
+        type            calculated;
+        value           $internalField;
+    }
+
+    outlet
+    {
+        type            calculated;
+        value           $internalField;
+    }
+
+    walls
+    {
+        type            compressible::alphatWallFunction;
+        Prt             0.85;
+        value           $internalField;
+    }
+
+    defaultFaces
+    {
+        type            empty;
+    }
+}
+
+// ************************************************************************* //

tutorials/testTwoFluidRecurrenceTurbulence/testRecurrenceKEpsilon/recRun/0.org/alphat.water

@@ -0,0 +1,48 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  4.0                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       volScalarField;
+    object      alphat.water;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+dimensions      [1 -1 -1 0 0 0 0];
+
+internalField   uniform 0;
+
+boundaryField
+{
+    inlet
+    {
+        type            calculated;
+        value           $internalField;
+    }
+
+    outlet
+    {
+        type            calculated;
+        value           $internalField;
+    }
+
+    walls
+    {
+        type            compressible::alphatWallFunction;
+        Prt             0.85;
+        value           $internalField;
+    }
+
+    defaultFaces
+    {
+        type            empty;
+    }
+}
+
+// ************************************************************************* //

tutorials/testTwoFluidRecurrenceTurbulence/testRecurrenceKEpsilon/recRun/0.org/epsilon.air

@@ -0,0 +1,44 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  2.3.x                                 |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      binary;
+    class       volScalarField;
+    location    "0";
+    object      epsilon.air;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+dimensions      [0 2 -3 0 0 0 0];
+
+internalField   uniform 0.000248;
+
+boundaryField
+{
+    inlet
+    {
+        type            fixedValue;
+        value           uniform 0.000248;
+    }
+    outlet
+    {
+        type            inletOutlet;
+        phi             phi.air;
+        inletValue      uniform 0.000248;
+        value           uniform 0.000248;
+    }
+    walls
+    {
+        type            epsilonWallFunction;
+        value           uniform 0.000248;
+    }
+}
+
+
+// ************************************************************************* //

tutorials/testTwoFluidRecurrenceTurbulence/testRecurrenceKEpsilon/recRun/0.org/epsilon.water

@@ -0,0 +1,44 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  2.3.x                                 |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      binary;
+    class       volScalarField;
+    location    "0";
+    object      epsilon.water;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+dimensions      [0 2 -3 0 0 0 0];
+
+internalField   uniform 0.000248;
+
+boundaryField
+{
+    inlet
+    {
+        type            fixedValue;
+        value           uniform 0.000248;
+    }
+    outlet
+    {
+        type            inletOutlet;
+        phi             phi.water;
+        inletValue      uniform 0.000248;
+        value           uniform 0.000248;
+    }
+    walls
+    {
+        type            epsilonWallFunction;
+        value           uniform 0.000248;
+    }
+}
+
+
+// ************************************************************************* //

tutorials/testTwoFluidRecurrenceTurbulence/testRecurrenceKEpsilon/recRun/0.org/k.air

@@ -0,0 +1,44 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  2.3.x                                 |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      binary;
+    class       volScalarField;
+    location    "0";
+    object      k.air;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+dimensions      [0 2 -2 0 0 0 0];
+
+internalField   uniform 0.000216;
+
+boundaryField
+{
+    inlet
+    {
+        type            fixedValue;
+        value           uniform 0.000216;
+    }
+    outlet
+    {
+        type            inletOutlet;
+        phi             phi.air;
+        inletValue      uniform 0.000216;
+        value           uniform 0.000216;
+    }
+    walls
+    {
+        type            kqRWallFunction;
+        value           uniform 0.000216;
+    }
+}
+
+
+// ************************************************************************* //

tutorials/testTwoFluidRecurrenceTurbulence/testRecurrenceKEpsilon/recRun/0.org/k.water

@@ -0,0 +1,44 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  2.3.x                                 |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      binary;
+    class       volScalarField;
+    location    "0";
+    object      k.water;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+dimensions      [0 2 -2 0 0 0 0];
+
+internalField   uniform 0.000216;
+
+boundaryField
+{
+    inlet
+    {
+        type            fixedValue;
+        value           uniform 0.000216;
+    }
+    outlet
+    {
+        type            inletOutlet;
+        phi             phi.water;
+        inletValue      uniform 0.000216;
+        value           uniform 0.000216;
+    }
+    walls
+    {
+        type            kqRWallFunction;
+        value           uniform 0.000216;
+    }
+}
+
+
+// ************************************************************************* //

tutorials/testTwoFluidRecurrenceTurbulence/testRecurrenceKEpsilon/recRun/0.org/nut.air

@@ -0,0 +1,42 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  2.3.x                                 |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      binary;
+    class       volScalarField;
+    location    "0";
+    object      nut.air;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+dimensions      [0 2 -1 0 0 0 0];
+
+internalField   uniform 1e-08;
+
+boundaryField
+{
+    inlet
+    {
+        type            calculated;
+        value           uniform 1e-08;
+    }
+    outlet
+    {
+        type            calculated;
+        value           uniform 1e-08;
+    }
+    walls
+    {
+        type            nutkWallFunction;
+        value           uniform 1e-08;
+    }
+}
+
+
+// ************************************************************************* //

tutorials/testTwoFluidRecurrenceTurbulence/testRecurrenceKEpsilon/recRun/0.org/nut.water

@@ -0,0 +1,42 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  2.3.x                                 |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      binary;
+    class       volScalarField;
+    location    "0";
+    object      nut.water;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+dimensions      [0 2 -1 0 0 0 0];
+
+internalField   uniform 1e-08;
+
+boundaryField
+{
+    inlet
+    {
+        type            calculated;
+        value           uniform 1e-08;
+    }
+    outlet
+    {
+        type            calculated;
+        value           uniform 1e-08;
+    }
+    walls
+    {
+        type            nutkWallFunction;
+        value           uniform 1e-08;
+    }
+}
+
+
+// ************************************************************************* //

tutorials/testTwoFluidRecurrenceTurbulence/testRecurrenceKEpsilon/recRun/0.org/p

@@ -0,0 +1,44 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  2.3.x                                 |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      binary;
+    class       volScalarField;
+    location    "0";
+    object      p;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+dimensions      [1 -1 -2 0 0 0 0];
+
+internalField   uniform 100000;
+
+boundaryField
+{
+    inlet
+    {
+        type            fixedFluxPressure;
+        gradient        uniform 0;
+        value           uniform 100000;
+    }
+    outlet
+    {
+        type            fixedValue;
+        value           uniform 100000;
+    }
+    walls
+    {
+        type            fixedFluxPressure;
+        gradient        uniform 0;
+        value           uniform 100000;
+    }
+}
+
+
+// ************************************************************************* //

tutorials/testTwoFluidRecurrenceTurbulence/testRecurrenceKEpsilon/recRun/0.org/p_rgh

@@ -0,0 +1,41 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  4.0                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       volScalarField;
+    object      p_rgh;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+dimensions          [1 -1 -2 0 0 0 0];
+
+internalField       uniform 1e5;
+
+boundaryField
+{
+    inlet
+    {
+        type            fixedFluxPressure;
+        value           $internalField;
+    }
+    outlet
+    {
+        type            prghPressure;
+        p               $internalField;
+        value           $internalField;
+    }
+    walls
+    {
+        type            fixedFluxPressure;
+        value           $internalField;
+    }
+}
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //

tutorials/testTwoFluidRecurrenceTurbulence/testRecurrenceKEpsilon/recRun/Allclean

@@ -0,0 +1,13 @@
+#!/bin/sh
+cd ${0%/*} || exit 1    # Run from this directory
+
+# Source tutorial clean functions
+. $WM_PROJECT_DIR/bin/tools/CleanFunctions
+
+cleanCase
+
+rm -rf 0
+
+rm dataBase
+
+#------------------------------------------------------------------------------

tutorials/testTwoFluidRecurrenceTurbulence/testRecurrenceKEpsilon/recRun/Allrun

@@ -0,0 +1,21 @@
+#!/bin/sh
+cd ${0%/*} || exit 1    # Run from this directory
+
+# Source tutorial run functions
+. $WM_PROJECT_DIR/bin/tools/RunFunctions
+
+# Set application name
+application=`getApplication`
+
+
+rm -rf 0
+cp -r 0.org 0
+
+./checkOrCreateMesh
+
+./checkOrCreateDataBase
+
+runApplication $application
+
+
+#------------------------------------------------------------------------------

tutorials/testTwoFluidRecurrenceTurbulence/testRecurrenceKEpsilon/recRun/checkOrCreateDataBase

@@ -0,0 +1,51 @@
+#!/bin/bash
+cd ${0%/*} || exit 1    # Run from this directory
+
+
+echo ""
+
+if [[ -L dataBase ]] && [[ ! -a dataBase ]];
+then 
+    echo "./dataBase is a broken symlink"
+    echo "   ... clearing ./dataBase"
+
+    rm dataBase
+fi
+
+if [ -e dataBase ];
+then
+    echo "dataBase exists"
+else
+    echo "no local dataBase found"
+    echo "   ... looking for parent dataBase"
+    
+    if [ -e ../dataBase ];
+    then
+        echo "parent dataBase exists"
+    else
+        echo "parent dataBase not found"
+        echo "   ... looking for source data"
+        
+        if [ -e ../init ];
+        then
+            echo "init case exists"
+            echo "   ... creating dataBase"
+            
+            cd ../init
+            ./createDataBase
+            cd ../recRunA
+            
+        else
+            echo "no init case found"
+            
+            exit 666
+        fi
+    fi
+    
+    echo "   ... linking to dataBase"
+    ln -s ../dataBase dataBase
+fi
+
+echo ""
+
+#------------------------------------------------------------------------------

tutorials/testTwoFluidRecurrenceTurbulence/testRecurrenceKEpsilon/recRun/checkOrCreateMesh

@@ -0,0 +1,27 @@
+#!/bin/bash
+cd ${0%/*} || exit 1    # Run from this directory
+
+
+if [ -e constant/polyMesh ];
+then
+    echo "mesh exists"
+else
+    echo "no mesh found"
+    echo "   ... looking for dataBase mesh"
+    
+    if [ -e ../dataBase ];
+    then
+        echo "dataBase mesh exists"
+        echo "   ... copying mesh from dataBase case"
+        
+        cp -r ../dataBase/constant/polyMesh constant/
+    else
+        echo "dataBase mesh not found"
+        
+        exit 666
+    fi
+fi
+
+echo ""
+
+#------------------------------------------------------------------------------

tutorials/testTwoFluidRecurrenceTurbulence/testRecurrenceKEpsilon/recRun/constant/g

@@ -0,0 +1,22 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  2.3.x                                 |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       uniformDimensionedVectorField;
+    location    "constant";
+    object      g;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+dimensions      [0 1 -2 0 0 0 0];
+value           (0 0 -9.81);
+
+
+// ************************************************************************* //

tutorials/testTwoFluidRecurrenceTurbulence/testRecurrenceKEpsilon/recRun/constant/phaseProperties

@@ -0,0 +1,173 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  4.0                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    location    "constant";
+    object      phaseProperties;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+type    heatAndMomentumTransferTwoPhaseSystem;
+
+phases (air water);
+
+air
+{
+    type            purePhaseModel;
+    diameterModel   isothermal;
+    isothermalCoeffs
+    {
+        d0              3e-3;
+        p0              1e5;
+    }
+
+    residualAlpha   1e-6;
+}
+
+water
+{
+    type            purePhaseModel;
+    diameterModel   constant;
+    constantCoeffs
+    {
+        d               1e-4;
+    }
+
+    residualAlpha   1e-6;
+}
+
+blending
+{
+    default
+    {
+        type            linear;
+        minFullyContinuousAlpha.air 0.7;
+        minPartlyContinuousAlpha.air 0.5;
+        minFullyContinuousAlpha.water 0.7;
+        minPartlyContinuousAlpha.water 0.5;
+    }
+}
+
+surfaceTension
+(
+    (air and water)
+    {
+        type            constant;
+        sigma           0.07;
+    }
+);
+
+aspectRatio
+(
+    (air in water)
+    {
+        type            constant;
+        E0              1.0;
+    }
+
+    (water in air)
+    {
+        type            constant;
+        E0              1.0;
+    }
+);
+
+drag
+(
+    (air in water)
+    {
+        type            TomiyamaCorrelated;
+        A               24.0;
+        
+        residualRe      1e-3;
+        swarmCorrection
+        {
+            type        none;
+        }
+    }
+
+    (water in air)
+    {
+        type            SchillerNaumann;
+        residualRe      1e-3;
+        swarmCorrection
+        {
+            type        none;
+        }
+    }
+
+    (air and water)
+    {
+        type            segregated;
+        m               0.5;
+        n               8;
+        swarmCorrection
+        {
+            type        none;
+        }
+    }
+);
+
+virtualMass
+(
+    (air in water)
+    {
+        type            constantCoefficient;
+        Cvm             0.5;
+    }
+
+    (water in air)
+    {
+        type            constantCoefficient;
+        Cvm             0.5;
+    }
+);
+
+heatTransfer
+(
+    (air in water)
+    {
+        type            RanzMarshall;
+        residualAlpha   1e-4;
+    }
+
+    (water in air)
+    {
+        type            RanzMarshall;
+        residualAlpha   1e-4;
+    }
+);
+
+lift
+(
+    (air in water)
+	{
+		type			Tomiyama;
+		residualAlpha   1e-6;
+        residualRe      1e-3;
+		residualEo		1e-6;
+        residualEE      1e-6;
+	}
+);
+
+wallLubrication
+(
+);
+
+turbulentDispersion
+(
+);
+
+// Minimum allowable pressure
+pMin            10000;
+
+
+// ************************************************************************* //

tutorials/testTwoFluidRecurrenceTurbulence/testRecurrenceKEpsilon/recRun/constant/recProperties

@@ -0,0 +1,48 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  4.0                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    location    "constant";
+    object      recProperties;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+recModel standardRecModel;
+
+verbose on;
+
+volScalarFields (alpha.air alpha.water k.water epsilon.water);
+volVectorFields (U.water);
+surfaceScalarFields ();
+
+
+standardRecModelProps
+{
+    verbose on;
+}
+
+
+
+recNorm sqrDiffNorm;
+
+sqrDiffNormProps
+{
+    fieldType volScalarField;
+    fieldName alpha.air;
+}
+
+
+recPath simpleRandomPath;
+
+simpleRandomPathProps
+{
+    verbose on;
+}

tutorials/testTwoFluidRecurrenceTurbulence/testRecurrenceKEpsilon/recRun/constant/scalarTransportProperties

@@ -0,0 +1,19 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  4.0                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    location    "constant";
+    object      scalarTransportProperties;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+
+carrierPhase    water;

tutorials/testTwoFluidRecurrenceTurbulence/testRecurrenceKEpsilon/recRun/constant/thermophysicalProperties.air

@@ -0,0 +1,49 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  2.3.x                                 |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    location    "constant";
+    object      thermophysicalProperties.air;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+thermoType
+{
+    type            heRhoThermo;
+    mixture         pureMixture;
+    transport       const;
+    thermo          hConst;
+    equationOfState perfectGas;
+    specie          specie;
+    energy          sensibleInternalEnergy;
+}
+
+mixture
+{
+    specie
+    {
+        nMoles      1;
+        molWeight   28.9;
+    }
+    thermodynamics
+    {
+        Cp          1007;
+        Hf          0;
+    }
+    transport
+    {
+        mu          1.84e-05;
+        Pr          0.7;
+    }
+}
+
+
+// ************************************************************************* //

tutorials/testTwoFluidRecurrenceTurbulence/testRecurrenceKEpsilon/recRun/constant/thermophysicalProperties.water

@@ -0,0 +1,54 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  2.3.x                                 |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    location    "constant";
+    object      thermophysicalProperties.water;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+thermoType
+{
+    type            heRhoThermo;
+    mixture         pureMixture;
+    transport       const;
+    thermo          hConst;
+    equationOfState perfectFluid;
+    specie          specie;
+    energy          sensibleInternalEnergy;
+}
+
+mixture
+{
+    specie
+    {
+        nMoles      1;
+        molWeight   18;
+    }
+    equationOfState
+    {
+        R           3000;
+        rho0        1027;
+    }
+    thermodynamics
+    {
+        Cp          4195;
+        Hf          0;
+    }
+    transport
+    {
+        mu          3.645e-4;
+        Pr          2.289;
+    }
+}
+
+
+// ************************************************************************* //

tutorials/testTwoFluidRecurrenceTurbulence/testRecurrenceKEpsilon/recRun/constant/turbulenceProperties.air

@@ -0,0 +1,29 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  2.3.x                                 |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    location    "constant";
+    object      turbulenceProperties.air;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+simulationType  laminar;
+//simulationType  RAS;
+
+RAS
+{
+    RASModel mixtureKEpsilon;
+
+    turbulence      on;
+    printCoeffs     on;
+}
+
+// ************************************************************************* //

tutorials/testTwoFluidRecurrenceTurbulence/testRecurrenceKEpsilon/recRun/constant/turbulenceProperties.water

@@ -0,0 +1,29 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  2.3.x                                 |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    location    "constant";
+    object      turbulenceProperties.water;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+simulationType  RAS;
+
+RAS
+{
+    RASModel recurrenceKEpsilon;
+
+    turbulence      on;
+    printCoeffs     on;
+}
+
+
+// ************************************************************************* //

tutorials/testTwoFluidRecurrenceTurbulence/testRecurrenceKEpsilon/recRun/system/controlDict

@@ -0,0 +1,63 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  2.3.x                                 |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    location    "system";
+    object      controlDict;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+application     testTwoFluidRecurrenceTurbulence;
+
+// startFrom       startTime;
+startFrom       latestTime;
+
+startTime       0;
+
+//stopAt          writeNow;
+stopAt          endTime;
+
+endTime         10;
+
+deltaT          0.001;
+
+//writeControl    adjustableRunTime;
+writeControl    runTime;
+
+writeInterval   0.1;
+
+purgeWrite      0;
+
+writeFormat     binary;
+
+writePrecision  6;
+
+writeCompression uncompressed;
+
+timeFormat      general;
+
+timePrecision   6;
+
+runTimeModifiable yes;
+
+adjustTimeStep  no;
+
+maxCo           0.35;
+
+maxDeltaT       1;
+
+libs ("librecurrenceTwoPhaseTurbulenceModels.so");
+
+functions
+{
+}
+
+// ************************************************************************* //

tutorials/testTwoFluidRecurrenceTurbulence/testRecurrenceKEpsilon/recRun/system/fvSchemes

@@ -0,0 +1,79 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  2.3.x                                 |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    location    "system";
+    object      fvSchemes;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+ddtSchemes
+{
+    default         Euler;
+}
+
+gradSchemes
+{
+    default         Gauss linear;
+}
+
+divSchemes
+{
+    default                         none;
+    
+    div(alphaRhoPhi,C)                 Gauss upwind;
+    
+    
+
+    div(phi,alpha.air)              Gauss vanLeer01;
+    div(phir,alpha.air)             Gauss vanLeer01;
+
+    "div\((alphaRhoPhi|alphaPhi|phi).*,U.*\)"      Gauss limitedLinearV 1;
+
+    "div\((alphaRhoPhi|alphaPhi).*,(h|e).*\)"  	Gauss limitedLinear 1;
+    "div\((alphaRhoPhi|alphaPhi).*,K.*\)"      	Gauss limitedLinear 1;
+    "div\(alphaPhi.*,p\)"           			Gauss limitedLinear 1;
+
+    "div\(phim,(k|epsilon)m\)"      				Gauss limitedLinear 1;
+    "div\((alphaRhoPhi|alphaPhi).*,(k|epsilon).*\)"	Gauss limitedLinear 1;
+    
+    div(((alpha.air*nuEff)*dev2(T(grad(U.air)))))			Gauss linear;
+    div(((alpha.air*nuEff.air)*dev2(T(grad(U.air)))))		Gauss linear;
+    div(((alpha.water*nuEff.water)*dev2(T(grad(U.water)))))	Gauss linear;
+    div(alphaPhi.air,thermo:rho.air)						Gauss linear;
+    div(alphaPhi.water,thermo:rho.water)					Gauss linear;
+
+    "div\(\(\(\(alpha.**thermo:rho.*\)*nuEff.*\)*dev2\(T\(grad\(U.*\)\)\)\)\)" Gauss linear;
+}
+
+laplacianSchemes
+{
+    default         Gauss linear uncorrected;
+}
+
+interpolationSchemes
+{
+    default         linear;
+}
+
+snGradSchemes
+{
+    default         uncorrected;
+}
+
+fluxRequired
+{
+    default         no;
+    p               ;
+}
+
+
+// ************************************************************************* //

tutorials/testTwoFluidRecurrenceTurbulence/testRecurrenceKEpsilon/recRun/system/fvSolution

@@ -0,0 +1,109 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  2.3.x                                 |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    location    "system";
+    object      fvSolution;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+solvers
+{
+    alpha.air
+    {
+        nAlphaCorr      1;
+        nAlphaSubCycles 2;
+    }
+
+    p_rgh
+    {
+        solver          GAMG;
+        smoother        DIC;
+        nPreSweeps      0;
+        nPostSweeps     2;
+        nFinestSweeps   2;
+        cacheAgglomeration true;
+        nCellsInCoarsestLevel 330;
+        agglomerator    faceAreaPair;
+        mergeLevels     1;
+        tolerance       1e-8;
+        relTol          0.01;
+    }
+
+    p_rghFinal
+    {
+        $p_rgh;
+        relTol          0;
+    }
+
+    "U.*"
+    {
+        solver          smoothSolver;
+        smoother        symGaussSeidel;
+        tolerance       1e-7;
+        relTol          0;
+        minIter         1;
+    }
+
+    "e.*"
+    {
+        solver          PBiCG;
+        preconditioner  DILU;
+        tolerance       1e-8;
+        relTol          0;
+        minIter         1;
+    }
+
+    "(k|epsilon|Theta).*"
+    {
+        solver          PBiCG;
+        preconditioner  DILU;
+        tolerance       1e-8;
+        relTol          0;
+        minIter         1;
+    }
+    
+    C
+    {
+        solver          PBiCG;
+        preconditioner  DILU;
+        tolerance       1e-8;
+        relTol          0;
+        minIter         1;
+    }
+    /*{
+        solver          smoothSolver;
+        smoother        symGaussSeidel;
+        tolerance       1e-7;
+        relTol          0;
+        minIter         1;
+    }*/
+}
+
+PIMPLE
+{
+    nOuterCorrectors 3;
+    nCorrectors      1;
+    nNonOrthogonalCorrectors 0;
+    
+    faceMomentum    true;
+}
+
+relaxationFactors
+{
+    equations
+    {
+        ".*"            1;
+    }
+}
+
+
+// ************************************************************************* //