diff --git a/applications/utilities/preProcessing/wallFunctionTable/Allwclean b/applications/utilities/preProcessing/wallFunctionTable/Allwclean
new file mode 100755
index 0000000000000000000000000000000000000000..bf93e1c06b73b1711ff8d87c7c149526bfb6219a
--- /dev/null
+++ b/applications/utilities/preProcessing/wallFunctionTable/Allwclean
@@ -0,0 +1,5 @@
+#!/bin/sh
+
+wclean libso tabulatedWallFunction
+wclean
+
diff --git a/applications/utilities/preProcessing/wallFunctionTable/Allwmake b/applications/utilities/preProcessing/wallFunctionTable/Allwmake
new file mode 100755
index 0000000000000000000000000000000000000000..57795a542fae3d0cdd2659b8b95b2e4d266db12f
--- /dev/null
+++ b/applications/utilities/preProcessing/wallFunctionTable/Allwmake
@@ -0,0 +1,5 @@
+#!/bin/sh
+
+wmake libso tabulatedWallFunction
+wmake
+
diff --git a/applications/utilities/preProcessing/wallFunctionTable/Make/files b/applications/utilities/preProcessing/wallFunctionTable/Make/files
new file mode 100644
index 0000000000000000000000000000000000000000..49a6c94aa19e61659e935217a57711b0eb08c871
--- /dev/null
+++ b/applications/utilities/preProcessing/wallFunctionTable/Make/files
@@ -0,0 +1,3 @@
+wallFunctionTableApp.C
+
+EXE = $(FOAM_APPBIN)/wallFunctionTable
diff --git a/applications/utilities/preProcessing/wallFunctionTable/Make/options b/applications/utilities/preProcessing/wallFunctionTable/Make/options
new file mode 100644
index 0000000000000000000000000000000000000000..6c78939e7cc5087cd4fad50e145e4b434b783887
--- /dev/null
+++ b/applications/utilities/preProcessing/wallFunctionTable/Make/options
@@ -0,0 +1,8 @@
+EXE_INC = \
+ -I./tabulatedWallFunction/lnInclude \
+ -I$(LIB_SRC)/turbulenceModels/incompressible/RAS/lnInclude \
+ -I$(LIB_SRC)/finiteVolume/lnInclude
+
+EXE_LIBS = \
+ -ltabulatedWallFunctions \
+ -lfiniteVolume
diff --git a/applications/utilities/preProcessing/wallFunctionTable/tabulatedWallFunction/Make/files b/applications/utilities/preProcessing/wallFunctionTable/tabulatedWallFunction/Make/files
new file mode 100644
index 0000000000000000000000000000000000000000..77c9217ded71d0e5387e6ac154435516055bf011
--- /dev/null
+++ b/applications/utilities/preProcessing/wallFunctionTable/tabulatedWallFunction/Make/files
@@ -0,0 +1,7 @@
+tabulatedWallFunction/tabulatedWallFunction.C
+tabulatedWallFunction/newTabulatedWallFunction.C
+
+SpaldingsLaw/SpaldingsLaw.C
+general/general.C
+
+LIB = $(FOAM_LIBBIN)/libtabulatedWallFunctions
diff --git a/applications/utilities/preProcessing/wallFunctionTable/tabulatedWallFunction/Make/options b/applications/utilities/preProcessing/wallFunctionTable/tabulatedWallFunction/Make/options
new file mode 100644
index 0000000000000000000000000000000000000000..cc5bf25a93e183eff1054ae71ded26852e5ef8fd
--- /dev/null
+++ b/applications/utilities/preProcessing/wallFunctionTable/tabulatedWallFunction/Make/options
@@ -0,0 +1,9 @@
+
+EXE_INC = \
+ -I$(LIB_SRC)/finiteVolume/lnInclude \
+ -I$(LIB_SRC)/turbulenceModels \
+ -I$(LIB_SRC)/turbulenceModels/incompressible/RAS/lnInclude \
+ -I$(LIB_SRC)/transportModels
+
+LIB_LIBS = \
+ -lfiniteVolume
diff --git a/applications/utilities/preProcessing/wallFunctionTable/tabulatedWallFunction/SpaldingsLaw/SpaldingsLaw.C b/applications/utilities/preProcessing/wallFunctionTable/tabulatedWallFunction/SpaldingsLaw/SpaldingsLaw.C
new file mode 100644
index 0000000000000000000000000000000000000000..2138000f6e3abf2d21c3dfbd7a8cdb81b8f91f8a
--- /dev/null
+++ b/applications/utilities/preProcessing/wallFunctionTable/tabulatedWallFunction/SpaldingsLaw/SpaldingsLaw.C
@@ -0,0 +1,197 @@
+/*---------------------------------------------------------------------------*\
+ ========= |
+ \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
+ \\ / O peration |
+ \\ / A nd | Copyright (C) 2009-2009 OpenCFD Ltd.
+ \\/ M anipulation |
+-------------------------------------------------------------------------------
+License
+ This file is part of OpenFOAM.
+
+ OpenFOAM is free software; you can redistribute it and/or modify it
+ under the terms of the GNU General Public License as published by the
+ Free Software Foundation; either version 2 of the License, or (at your
+ option) any later version.
+
+ OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with OpenFOAM; if not, write to the Free Software Foundation,
+ Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+\*---------------------------------------------------------------------------*/
+
+#include "SpaldingsLaw.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+ namespace tabulatedWallFunctions
+ {
+ defineTypeNameAndDebug(SpaldingsLaw, 0);
+ addToRunTimeSelectionTable
+ (
+ tabulatedWallFunction,
+ SpaldingsLaw,
+ dictionary
+ );
+ }
+}
+
+const Foam::label Foam::tabulatedWallFunctions::SpaldingsLaw::maxIters_ = 1000;
+
+const Foam::scalar
+ Foam::tabulatedWallFunctions::SpaldingsLaw::tolerance_ = 1e-4;
+
+
+// * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * * //
+
+void Foam::tabulatedWallFunctions::SpaldingsLaw::invertFunction()
+{
+ // Initialise u+ and R
+ scalar Re = 0.0;
+ scalar uPlus = 1;
+
+ // Populate the table
+ for (label i=0; i<invertedTable_.size(); i++)
+ {
+ if (invertedTable_.log10())
+ {
+ Re = pow(10, (i*invertedTable_.dx() + invertedTable_.x0()));
+ }
+ else
+ {
+ Re = i*invertedTable_.dx() + invertedTable_.x0();
+ }
+
+ // Use latest available u+ estimate
+ if (i > 0)
+ {
+ uPlus = invertedTable_[i-1];
+ }
+
+ // Newton iterations to determine u+
+ label iter = 0;
+ scalar error = GREAT;
+ do
+ {
+ scalar kUPlus = min(kappa_*uPlus, 50);
+ scalar A =
+ E_*sqr(uPlus)
+ + uPlus
+ *(exp(kUPlus) - pow3(kUPlus)/6 - 0.5*sqr(kUPlus) - kUPlus - 1);
+
+ scalar f = - Re + A/E_;
+
+ scalar df =
+ (
+ 2*E_*uPlus
+ + exp(kUPlus)*(kUPlus + 1)
+ - 2/3*pow3(kUPlus)
+ - 1.5*sqr(kUPlus)
+ - 2*kUPlus
+ - 1
+ )/E_;
+
+ scalar uPlusNew = uPlus - f/(df + ROOTVSMALL);
+ error = mag((uPlus - uPlusNew)/uPlusNew);
+ uPlus = uPlusNew;
+ } while (error > tolerance_ && ++iter < maxIters_);
+
+ if (iter == maxIters_)
+ {
+ WarningIn("SpaldingsLaw::invertFunction()")
+ << "Newton iterations not converged:" << nl
+ << " iters = " << iter << ", error = " << error << endl;
+ }
+
+ // Set new values - constrain u+ >= 0
+ invertedTable_[i] = max(0, uPlus);
+ }
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
+
+Foam::tabulatedWallFunctions::SpaldingsLaw::SpaldingsLaw
+(
+ const dictionary& dict,
+ const polyMesh& mesh
+)
+:
+ tabulatedWallFunction(dict, mesh, typeName),
+ kappa_(readScalar(coeffDict_.lookup("kappa"))),
+ E_(readScalar(coeffDict_.lookup("E")))
+{
+ invertFunction();
+
+ if (debug)
+ {
+ writeData(Info);
+ }
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
+
+Foam::tabulatedWallFunctions::SpaldingsLaw::~SpaldingsLaw()
+{}
+
+
+// * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * * //
+
+Foam::scalar Foam::tabulatedWallFunctions::SpaldingsLaw::yPlus
+(
+ const scalar uPlus
+) const
+{
+ scalar kUPlus = min(kappa_*uPlus, 50);
+
+ return
+ uPlus
+ + 1/E_*(exp(kUPlus) - pow3(kUPlus)/6 - 0.5*sqr(kUPlus) - kUPlus - 1);
+}
+
+
+Foam::scalar Foam::tabulatedWallFunctions::SpaldingsLaw::Re
+(
+ const scalar uPlus
+) const
+{
+ return uPlus*yPlus(uPlus);
+}
+
+
+void Foam::tabulatedWallFunctions::SpaldingsLaw::writeData(Ostream& os) const
+{
+ if (invertedTable_.log10())
+ {
+ os << "log10(Re), y+, u+:" << endl;
+ forAll(invertedTable_, i)
+ {
+ scalar uPlus = invertedTable_[i];
+ scalar Re = ::log10(this->Re(uPlus));
+ scalar yPlus = this->yPlus(uPlus);
+ os << Re << ", " << yPlus << ", " << uPlus << endl;
+ }
+ }
+ else
+ {
+ os << "Re, y+, u+:" << endl;
+ forAll(invertedTable_, i)
+ {
+ scalar uPlus = invertedTable_[i];
+ scalar Re = this->Re(uPlus);
+ scalar yPlus = this->yPlus(uPlus);
+ os << Re << ", " << yPlus << ", " << uPlus << endl;
+ }
+ }
+}
+
+
+// ************************************************************************* //
diff --git a/applications/utilities/preProcessing/wallFunctionTable/tabulatedWallFunction/SpaldingsLaw/SpaldingsLaw.H b/applications/utilities/preProcessing/wallFunctionTable/tabulatedWallFunction/SpaldingsLaw/SpaldingsLaw.H
new file mode 100644
index 0000000000000000000000000000000000000000..07853ef5ebfa9800572775dcf989175b26a7d99f
--- /dev/null
+++ b/applications/utilities/preProcessing/wallFunctionTable/tabulatedWallFunction/SpaldingsLaw/SpaldingsLaw.H
@@ -0,0 +1,140 @@
+/*---------------------------------------------------------------------------*\
+ ========= |
+ \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
+ \\ / O peration |
+ \\ / A nd | Copyright (C) 2009-2009 OpenCFD Ltd.
+ \\/ M anipulation |
+-------------------------------------------------------------------------------
+License
+ This file is part of OpenFOAM.
+
+ OpenFOAM is free software; you can redistribute it and/or modify it
+ under the terms of the GNU General Public License as published by the
+ Free Software Foundation; either version 2 of the License, or (at your
+ option) any later version.
+
+ OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with OpenFOAM; if not, write to the Free Software Foundation,
+ Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Class
+ Foam::tabulatedWallFunctions::SpaldingsLaw
+
+Description
+ Computes U+ as a function of Reynolds number by inverting Spaldings law.
+
+ Example dictionary specification:
+
+ tabulatedWallFunction SpaldingsLaw;
+
+ // Output table info
+ tableName uPlusWallFunctionData; // Output table name
+ log10 yes; // Rey interpreted as log10(Rey)
+ dx 0.2; // Interval log10(Rey)
+ x0 -3; // Minimum log10(Rey)
+ xMax 7; // Maximum log10(Rey)
+
+ SpaldingsLawCoeffs
+ {
+ kappa 0.41; // Von Karman constant
+ E 9.8; // Law-of-the-wall E coefficient
+ }
+
+
+SourceFiles
+ SpaldingsLaw.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef SpaldingsLaw_H
+#define SpaldingsLaw_H
+
+#include "tabulatedWallFunction.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace tabulatedWallFunctions
+{
+
+/*---------------------------------------------------------------------------*\
+ Class SpaldingsLaw Declaration
+\*---------------------------------------------------------------------------*/
+
+class SpaldingsLaw
+:
+ public tabulatedWallFunction
+{
+protected:
+
+ // Protected data
+
+ //- Von Karman constant
+ scalar kappa_;
+
+ //- Law-of-the-wall E coefficient
+ scalar E_;
+
+
+ // Newton iteration solution properties
+
+ //- Maximum number of iterations
+ static const label maxIters_;
+
+ //- Tolerance
+ static const scalar tolerance_;
+
+
+ // Protected member functions
+
+ //- Invert the function
+ virtual void invertFunction();
+
+
+public:
+
+ //- Run-time type information
+ TypeName("SpaldingsLaw");
+
+
+ // Constructors
+ SpaldingsLaw(const dictionary& dict, const polyMesh& mesh);
+
+ //- Destructor
+ virtual ~SpaldingsLaw();
+
+
+ // Member Functions
+
+ // Access
+
+ //- Return y+ as a function of u+
+ virtual scalar yPlus(const scalar uPlus) const;
+
+ //- Return Reynolds number as a function of u+
+ virtual scalar Re(const scalar uPlus) const;
+
+
+ // I-O
+
+ //- Write to Ostream
+ virtual void writeData(Ostream& os) const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace tabulatedWallFunctions
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/applications/utilities/preProcessing/wallFunctionTable/tabulatedWallFunction/general/general.C b/applications/utilities/preProcessing/wallFunctionTable/tabulatedWallFunction/general/general.C
new file mode 100644
index 0000000000000000000000000000000000000000..76792dc2f83cdffdbe6382f81ab31076230d14c6
--- /dev/null
+++ b/applications/utilities/preProcessing/wallFunctionTable/tabulatedWallFunction/general/general.C
@@ -0,0 +1,254 @@
+/*---------------------------------------------------------------------------*\
+ ========= |
+ \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
+ \\ / O peration |
+ \\ / A nd | Copyright (C) 2009-2009 OpenCFD Ltd.
+ \\/ M anipulation |
+-------------------------------------------------------------------------------
+License
+ This file is part of OpenFOAM.
+
+ OpenFOAM is free software; you can redistribute it and/or modify it
+ under the terms of the GNU General Public License as published by the
+ Free Software Foundation; either version 2 of the License, or (at your
+ option) any later version.
+
+ OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with OpenFOAM; if not, write to the Free Software Foundation,
+ Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+\*---------------------------------------------------------------------------*/
+
+#include "general.H"
+#include "addToRunTimeSelectionTable.H"
+#include "Tuple2.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+ namespace tabulatedWallFunctions
+ {
+ defineTypeNameAndDebug(general, 0);
+ addToRunTimeSelectionTable
+ (
+ tabulatedWallFunction,
+ general,
+ dictionary
+ );
+ }
+}
+
+template<>
+const char*
+Foam::NamedEnum<Foam::tabulatedWallFunctions::general::interpolationType, 1>::
+ names[] =
+ {
+ "linear"
+ };
+
+const
+Foam::NamedEnum<Foam::tabulatedWallFunctions::general::interpolationType, 1>
+ Foam::tabulatedWallFunctions::general::interpolationTypeNames_;
+
+
+// * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * * //
+
+void Foam::tabulatedWallFunctions::general::invertTable()
+{
+ scalarList Rey(uPlus_.size(), 0.0);
+
+ // Calculate Reynolds number
+ forAll(uPlus_, i)
+ {
+ Rey[i] = yPlus_[i]*uPlus_[i];
+ if (invertedTable_.log10())
+ {
+ Rey[i] = ::log10(max(ROOTVSMALL, Rey[i]));
+ }
+ }
+
+ // Populate the U+ vs Re table
+ forAll(invertedTable_, i)
+ {
+ scalar Re = i*invertedTable_.dx() + invertedTable_.x0();
+ invertedTable_[i] = max(0, interpolate(Re, Rey, uPlus_));
+ }
+}
+
+
+Foam::scalar Foam::tabulatedWallFunctions::general::interpolate
+(
+ const scalar xi,
+ const scalarList& x,
+ const scalarList& fx
+) const
+{
+ switch (interpType_)
+ {
+ case itLinear:
+ {
+ if (xi < x[0])
+ {
+ return fx[0];
+ }
+ else if (xi > x[x.size()-1])
+ {
+ return fx[x.size()-1];
+ }
+ else
+ {
+ label i2 = 0;
+ while (x[i2] < xi)
+ {
+ i2++;
+ }
+ label i1 = i2 - 1;
+
+ return (xi - x[i1])/(x[i2] - x[i1])*(fx[i2] - fx[i1]) + fx[i1];
+ }
+
+ break;
+ }
+ default:
+ {
+ FatalErrorIn
+ (
+ "tabulatedWallFunctions::general::interpolate"
+ "("
+ "const scalar, "
+ "const scalarList&, "
+ "const scalarList&"
+ ")"
+ ) << "Unknown interpolation method" << nl
+ << abort(FatalError);
+ }
+ }
+
+ return 0.0;
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
+
+Foam::tabulatedWallFunctions::general::general
+(
+ const dictionary& dict,
+ const polyMesh& mesh
+)
+:
+ tabulatedWallFunction(dict, mesh, typeName),
+ interpType_(interpolationTypeNames_[coeffDict_.lookup("interpType")]),
+ yPlus_(),
+ uPlus_(),
+ log10YPlus_(coeffDict_.lookup("log10YPlus")),
+ log10UPlus_(coeffDict_.lookup("log10UPlus"))
+{
+ List<Tuple2<scalar, scalar> > inputTable = coeffDict_.lookup("inputTable");
+ if (inputTable.size() < 2)
+ {
+ FatalErrorIn
+ (
+ "tabulatedWallFunctions::general::general"
+ "("
+ "const dictionary&, "
+ "const polyMesh&"
+ ")"
+ ) << "Input table must have at least 2 values" << nl
+ << exit(FatalError);
+ }
+
+ yPlus_.setSize(inputTable.size());
+ uPlus_.setSize(inputTable.size());
+
+ forAll(inputTable, i)
+ {
+ if (log10YPlus_)
+ {
+ yPlus_[i] = pow(10, inputTable[i].first());
+ }
+ else
+ {
+ yPlus_[i] = inputTable[i].first();
+ }
+
+ if (log10UPlus_)
+ {
+ uPlus_[i] = pow(10, inputTable[i].second());
+ }
+ else
+ {
+ uPlus_[i] = inputTable[i].second();
+ }
+ }
+
+ invertTable();
+
+ if (debug)
+ {
+ writeData(Info);
+ }
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
+
+Foam::tabulatedWallFunctions::general::~general()
+{}
+
+
+// * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * * //
+
+Foam::scalar Foam::tabulatedWallFunctions::general::yPlus
+(
+ const scalar uPlus
+) const
+{
+ return interpolate(uPlus, uPlus_, yPlus_);
+}
+
+
+Foam::scalar Foam::tabulatedWallFunctions::general::Re
+(
+ const scalar uPlus
+) const
+{
+ return uPlus*yPlus(uPlus);
+}
+
+
+// * * * * * * * * * * * * * * Member Operators * * * * * * * * * * * * * * //
+
+void Foam::tabulatedWallFunctions::general::writeData(Ostream& os) const
+{
+ if (invertedTable_.log10())
+ {
+ os << "log10(Re), y+, u+:" << endl;
+ forAll(invertedTable_, i)
+ {
+ scalar uPlus = invertedTable_[i];
+ scalar Re = ::log10(this->Re(uPlus));
+ scalar yPlus = this->yPlus(uPlus);
+ os << Re << ", " << yPlus << ", " << uPlus << endl;
+ }
+ }
+ else
+ {
+ os << "Re, y+, u+:" << endl;
+ forAll(invertedTable_, i)
+ {
+ scalar uPlus = invertedTable_[i];
+ scalar Re = this->Re(uPlus);
+ scalar yPlus = this->yPlus(uPlus);
+ os << Re << ", " << yPlus << ", " << uPlus << endl;
+ }
+ }
+}
+
+
+// ************************************************************************* //
diff --git a/applications/utilities/preProcessing/wallFunctionTable/tabulatedWallFunction/general/general.H b/applications/utilities/preProcessing/wallFunctionTable/tabulatedWallFunction/general/general.H
new file mode 100644
index 0000000000000000000000000000000000000000..032d2d6cc14cba8a5ff7b30ab63fa197d9c1fe18
--- /dev/null
+++ b/applications/utilities/preProcessing/wallFunctionTable/tabulatedWallFunction/general/general.H
@@ -0,0 +1,172 @@
+/*---------------------------------------------------------------------------*\
+ ========= |
+ \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
+ \\ / O peration |
+ \\ / A nd | Copyright (C) 2009-2009 OpenCFD Ltd.
+ \\/ M anipulation |
+-------------------------------------------------------------------------------
+License
+ This file is part of OpenFOAM.
+
+ OpenFOAM is free software; you can redistribute it and/or modify it
+ under the terms of the GNU General Public License as published by the
+ Free Software Foundation; either version 2 of the License, or (at your
+ option) any later version.
+
+ OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with OpenFOAM; if not, write to the Free Software Foundation,
+ Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Class
+ Foam::tabulatedWallFunctions::general
+
+Description
+ Computes U+ as a function of Reynolds number by inverting table of
+ y+ vs U+
+
+ Example dictionary specification:
+
+ tabulatedWallFunction general;
+
+ // Output table info
+ tableName uPlusWallFunctionData; // Output table name
+ log10 yes; // Re interpreted as log10(Rey)
+ dx 0.2; // Interval log10(Rey)
+ x0 -3; // Minimum log10(Rey)
+ xMax 7; // Maximum log10(Rey)
+
+ generalCoeffs
+ {
+ interpType linear; // Interpolation method
+ log10YPlus true; // y+ values defined as log10(y+)
+ log10UPlus true; // U+ values defined as log10(y+)
+ inputTable
+ (
+ (yPlusValue0 uPlusValue0)
+ ...
+ (yPlusValueN uPlusValueN)
+ );
+
+ }
+
+
+SourceFiles
+ general.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef general_H
+#define general_H
+
+#include "tabulatedWallFunction.H"
+#include "NamedEnum.H"
+#include "Switch.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace tabulatedWallFunctions
+{
+
+/*---------------------------------------------------------------------------*\
+ Class general Declaration
+\*---------------------------------------------------------------------------*/
+
+class general
+:
+ public tabulatedWallFunction
+{
+public:
+
+ // Public data types
+
+ //- Enumeration listing available interpolation types
+ enum interpolationType
+ {
+ itLinear
+ };
+
+ static const NamedEnum<interpolationType, 1> interpolationTypeNames_;
+
+
+protected:
+
+ // Protected data
+
+ //- Type of interpolation to apply when inverting the data set
+ interpolationType interpType_;
+
+ //- Input y+ values
+ List<scalar> yPlus_;
+
+ //- Input U+ values
+ List<scalar> uPlus_;
+
+ //- Are y+ values entered as log10(y+)?
+ Switch log10YPlus_;
+
+ //- Are U+ values entered as log10(U+)?
+ Switch log10UPlus_;
+
+
+ // Protected member functions
+
+ //- Invert the table
+ virtual void invertTable();
+
+ //- Interpolate
+ virtual scalar interpolate
+ (
+ const scalar xi,
+ const scalarList& x,
+ const scalarList& fx
+ ) const;
+
+
+public:
+
+ //- Run-time type information
+ TypeName("general");
+
+
+ // Constructors
+ general(const dictionary& dict, const polyMesh& mesh);
+
+ //- Destructor
+ virtual ~general();
+
+
+ // Member Functions
+
+ // Access
+
+ //- Return y+ as a function of u+
+ virtual scalar yPlus(const scalar uPlus) const;
+
+ //- Return Reynolds number as a function of u+
+ virtual scalar Re(const scalar uPlus) const;
+
+
+ // I-O
+
+ //- Write to Ostream
+ virtual void writeData(Ostream& os) const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace tabulatedWallFunctions
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/applications/utilities/preProcessing/wallFunctionTable/tabulatedWallFunction/tabulatedWallFunction/newTabulatedWallFunction.C b/applications/utilities/preProcessing/wallFunctionTable/tabulatedWallFunction/tabulatedWallFunction/newTabulatedWallFunction.C
new file mode 100644
index 0000000000000000000000000000000000000000..af10c175679968159d792b75947947410049a496
--- /dev/null
+++ b/applications/utilities/preProcessing/wallFunctionTable/tabulatedWallFunction/tabulatedWallFunction/newTabulatedWallFunction.C
@@ -0,0 +1,71 @@
+/*---------------------------------------------------------------------------*\
+ ========= |
+ \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
+ \\ / O peration |
+ \\ / A nd | Copyright (C) 2009-2009 OpenCFD Ltd.
+ \\/ M anipulation |
+-------------------------------------------------------------------------------
+License
+ This file is part of OpenFOAM.
+
+ OpenFOAM is free software; you can redistribute it and/or modify it
+ under the terms of the GNU General Public License as published by the
+ Free Software Foundation; either version 2 of the License, or (at your
+ option) any later version.
+
+ OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with OpenFOAM; if not, write to the Free Software Foundation,
+ Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+\*---------------------------------------------------------------------------*/
+
+#include "tabulatedWallFunction.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace tabulatedWallFunctions
+{
+
+// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
+
+autoPtr<tabulatedWallFunction> tabulatedWallFunction::New
+(
+ const dictionary& dict,
+ const polyMesh& mesh
+)
+{
+ word twfTypeName = dict.lookup("tabulatedWallFunction");
+
+ Info<< "Selecting tabulatedWallFunction " << twfTypeName << endl;
+
+ dictionaryConstructorTable::iterator cstrIter =
+ dictionaryConstructorTablePtr_->find(twfTypeName);
+
+ if (cstrIter == dictionaryConstructorTablePtr_->end())
+ {
+ FatalErrorIn
+ (
+ "tabulatedWallFunction::New(const dictionary&, const polyMesh&)"
+ ) << "Unknown tabulatedWallFunction type " << twfTypeName
+ << nl << nl << "Valid tabulatedWallFunction types are:" << nl
+ << dictionaryConstructorTablePtr_->toc()
+ << exit(FatalError);
+ }
+
+ return autoPtr<tabulatedWallFunction>(cstrIter()(dict, mesh));
+}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace tabulatedWallFunctions
+} // End namespace Foam
+
+// ************************************************************************* //
diff --git a/applications/utilities/preProcessing/wallFunctionTable/tabulatedWallFunction/tabulatedWallFunction/tabulatedWallFunction.C b/applications/utilities/preProcessing/wallFunctionTable/tabulatedWallFunction/tabulatedWallFunction/tabulatedWallFunction.C
new file mode 100644
index 0000000000000000000000000000000000000000..4c0087a87bc8b469622e3a6d10662273e33bf80b
--- /dev/null
+++ b/applications/utilities/preProcessing/wallFunctionTable/tabulatedWallFunction/tabulatedWallFunction/tabulatedWallFunction.C
@@ -0,0 +1,88 @@
+
+/*---------------------------------------------------------------------------*\
+ ========= |
+ \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
+ \\ / O peration |
+ \\ / A nd | Copyright (C) 2009-2009 OpenCFD Ltd.
+ \\/ M anipulation |
+-------------------------------------------------------------------------------
+License
+ This file is part of OpenFOAM.
+
+ OpenFOAM is free software; you can redistribute it and/or modify it
+ under the terms of the GNU General Public License as published by the
+ Free Software Foundation; either version 2 of the License, or (at your
+ option) any later version.
+
+ OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with OpenFOAM; if not, write to the Free Software Foundation,
+ Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+\*---------------------------------------------------------------------------*/
+
+#include "tabulatedWallFunction.H"
+#include "Time.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+ namespace tabulatedWallFunctions
+ {
+ defineTypeNameAndDebug(tabulatedWallFunction, 0);
+ defineRunTimeSelectionTable(tabulatedWallFunction, dictionary);
+ }
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
+
+Foam::tabulatedWallFunctions::tabulatedWallFunction::tabulatedWallFunction
+(
+ const dictionary& dict,
+ const polyMesh& mesh,
+ const word& name
+)
+:
+ dict_(dict),
+ mesh_(mesh),
+ coeffDict_(dict.subDict(name + "Coeffs")),
+ invertedTableName_(dict.lookup("invertedTableName")),
+ invertedTable_(invertedTableName_, mesh_, dict, true)
+{}
+
+
+// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
+
+Foam::tabulatedWallFunctions::tabulatedWallFunction::~tabulatedWallFunction()
+{}
+
+
+// * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * * //
+
+void Foam::tabulatedWallFunctions::tabulatedWallFunction::write()
+{
+ if (invertedTable_.log10())
+ {
+ invertedTable_.note() =
+ "U+ as a function of log10(Re) computed using " + type();
+ }
+ else
+ {
+ invertedTable_.note() =
+ "U+ as a function of Re computed using " + type();
+ }
+
+ Info<< "Writing inverted table to\n " << invertedTable_.objectPath()
+ << endl;
+
+ invertedTable_.write();
+}
+
+
+// ************************************************************************* //
diff --git a/applications/utilities/preProcessing/wallFunctionTable/tabulatedWallFunction/tabulatedWallFunction/tabulatedWallFunction.H b/applications/utilities/preProcessing/wallFunctionTable/tabulatedWallFunction/tabulatedWallFunction/tabulatedWallFunction.H
new file mode 100644
index 0000000000000000000000000000000000000000..afa382407c7e8c127f53f88b3bbedd4e573728ed
--- /dev/null
+++ b/applications/utilities/preProcessing/wallFunctionTable/tabulatedWallFunction/tabulatedWallFunction/tabulatedWallFunction.H
@@ -0,0 +1,147 @@
+/*---------------------------------------------------------------------------*\
+ ========= |
+ \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
+ \\ / O peration |
+ \\ / A nd | Copyright (C) 2009-2009 OpenCFD Ltd.
+ \\/ M anipulation |
+-------------------------------------------------------------------------------
+License
+ This file is part of OpenFOAM.
+
+ OpenFOAM is free software; you can redistribute it and/or modify it
+ under the terms of the GNU General Public License as published by the
+ Free Software Foundation; either version 2 of the License, or (at your
+ option) any later version.
+
+ OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with OpenFOAM; if not, write to the Free Software Foundation,
+ Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Class
+ Foam::tabulatedWallFunctions::tabulatedWallFunction
+
+Description
+ Base class for models that generate tabulated wall function data.
+
+SourceFiles
+ tabulatedWallFunction.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef tabulatedWallFunction_H
+#define tabulatedWallFunction_H
+
+#include "dictionary.H"
+#include "polyMesh.H"
+#include "runTimeSelectionTables.H"
+#include "Switch.H"
+#include "uniformInterpolationTable.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace tabulatedWallFunctions
+{
+
+/*---------------------------------------------------------------------------*\
+ Class tabulatedWallFunction Declaration
+\*---------------------------------------------------------------------------*/
+
+class tabulatedWallFunction
+{
+protected:
+
+ // Proteced data
+
+ //- Main dictionary
+ const dictionary dict_;
+
+ //- Reference to the mesh database
+ const polyMesh& mesh_;
+
+ //- Coefficients dictionary
+ const dictionary coeffDict_;
+
+ //- Name of inverted table
+ word invertedTableName_;
+
+ //- Inverted table
+ uniformInterpolationTable invertedTable_;
+
+
+public:
+
+ //- Run-time type information
+ TypeName("tabulatedWallFunction");
+
+ //- Declare runtime constructor selection table
+ declareRunTimeSelectionTable
+ (
+ autoPtr,
+ tabulatedWallFunction,
+ dictionary,
+ (
+ const dictionary& dict,
+ const polyMesh& mesh
+ ),
+ (dict, mesh)
+ );
+
+ //- Constructor
+ tabulatedWallFunction
+ (
+ const dictionary& dict,
+ const polyMesh& mesh,
+ const word& name
+ );
+
+ //- Destructor
+ virtual ~tabulatedWallFunction();
+
+
+ //- Selector
+ static autoPtr<tabulatedWallFunction> New
+ (
+ const dictionary& dict,
+ const polyMesh& mesh
+ );
+
+
+ // Member Functions
+
+ // Access
+
+ //- Return the inverted table name
+ inline const word& invertedTableName() const;
+
+ //- Return the inverted table
+ inline const uniformInterpolationTable& invertedTable() const;
+
+
+ // I-O
+
+ //- Write
+ virtual void write();
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace tabulatedWallFunctions
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#include "tabulatedWallFunctionI.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/applications/utilities/preProcessing/wallFunctionTable/tabulatedWallFunction/tabulatedWallFunction/tabulatedWallFunctionI.H b/applications/utilities/preProcessing/wallFunctionTable/tabulatedWallFunction/tabulatedWallFunction/tabulatedWallFunctionI.H
new file mode 100644
index 0000000000000000000000000000000000000000..4fbe48d3fe7363618ec6e2b33f5e611a513545fc
--- /dev/null
+++ b/applications/utilities/preProcessing/wallFunctionTable/tabulatedWallFunction/tabulatedWallFunction/tabulatedWallFunctionI.H
@@ -0,0 +1,45 @@
+/*---------------------------------------------------------------------------*\
+ ========= |
+ \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
+ \\ / O peration |
+ \\ / A nd | Copyright (C) 2009-2009 OpenCFD Ltd.
+ \\/ M anipulation |
+-------------------------------------------------------------------------------
+License
+ This file is part of OpenFOAM.
+
+ OpenFOAM is free software; you can redistribute it and/or modify it
+ under the terms of the GNU General Public License as published by the
+ Free Software Foundation; either version 2 of the License, or (at your
+ option) any later version.
+
+ OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with OpenFOAM; if not, write to the Free Software Foundation,
+ Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+\*---------------------------------------------------------------------------*/
+
+#include "tabulatedWallFunction.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+inline const Foam::word&
+Foam::tabulatedWallFunctions::tabulatedWallFunction::invertedTableName() const
+{
+ return invertedTableName_;
+}
+
+
+inline const Foam::uniformInterpolationTable&
+Foam::tabulatedWallFunctions::tabulatedWallFunction::invertedTable() const
+{
+ return invertedTable_;
+}
+
+
+// ************************************************************************* //
diff --git a/applications/utilities/preProcessing/wallFunctionTable/wallFunctionDict b/applications/utilities/preProcessing/wallFunctionTable/wallFunctionDict
new file mode 100644
index 0000000000000000000000000000000000000000..85cd0ba5aa57e8a2b91e0bd3ad1619fc22c428a4
--- /dev/null
+++ b/applications/utilities/preProcessing/wallFunctionTable/wallFunctionDict
@@ -0,0 +1,39 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| ========= | |
+| \\ / F ield | OpenFOAM: The Open Source CFD Toolbox |
+| \\ / O peration | Version: 1.6 |
+| \\ / A nd | Web: www.OpenFOAM.org |
+| \\/ M anipulation | |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+ version 2.0;
+ format ascii;
+ class dictionary;
+ location "constant";
+ object wallFunctionDict;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+tabulatedWallFunction SpaldingsLaw;
+
+invertedTableName uPlusWallFunctionData;
+
+dx 0.2;
+
+x0 -3;
+
+xMax 7;
+
+log10 yes;
+
+bound yes;
+
+SpaldingsLawCoeffs
+{
+ kappa 0.41;
+ E 9.8;
+}
+
+
+// ************************************************************************* //
diff --git a/applications/utilities/preProcessing/wallFunctionTable/wallFunctionTableApp.C b/applications/utilities/preProcessing/wallFunctionTable/wallFunctionTableApp.C
new file mode 100644
index 0000000000000000000000000000000000000000..a729a771c9251f7c601f6c1e4f9e22ac48c137fc
--- /dev/null
+++ b/applications/utilities/preProcessing/wallFunctionTable/wallFunctionTableApp.C
@@ -0,0 +1,68 @@
+/*---------------------------------------------------------------------------*\
+ ========= |
+ \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
+ \\ / O peration |
+ \\ / A nd | Copyright (C) 2009-2009 OpenCFD Ltd.
+ \\/ M anipulation |
+-------------------------------------------------------------------------------
+License
+ This file is part of OpenFOAM.
+
+ OpenFOAM is free software; you can redistribute it and/or modify it
+ under the terms of the GNU General Public License as published by the
+ Free Software Foundation; either version 2 of the License, or (at your
+ option) any later version.
+
+ OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with OpenFOAM; if not, write to the Free Software Foundation,
+ Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Application
+ wallFunctionTable
+
+Description
+ Generates a table suitable for use by tabulated wall functions
+
+\*---------------------------------------------------------------------------*/
+
+#include "fvCFD.H"
+#include "tabulatedWallFunction.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+int main(int argc, char *argv[])
+{
+ #include "setRootCase.H"
+ #include "createTime.H"
+ #include "createMesh.H"
+
+ IOdictionary dict
+ (
+ IOobject
+ (
+ "wallFunctionDict",
+ runTime.constant(),
+ mesh,
+ IOobject::MUST_READ
+ )
+ );
+
+ autoPtr<tabulatedWallFunctions::tabulatedWallFunction>
+ twf(tabulatedWallFunctions::tabulatedWallFunction::New(dict, mesh));
+
+// twf->writeData(Info);
+
+ twf->write();
+
+ Info << "End\n" << endl;
+
+ return 0;
+}
+
+
+// ************************************************************************* //
diff --git a/src/OpenFOAM/Make/files b/src/OpenFOAM/Make/files
index 2823c2a9ec3f0e45310365741915f3667a3446f9..dc5fc33491d61ce0d5a9f1633bc3d997719b4177 100644
--- a/src/OpenFOAM/Make/files
+++ b/src/OpenFOAM/Make/files
@@ -509,6 +509,7 @@ meshes/preservePatchTypes/preservePatchTypes.C
interpolations = interpolations
interpolation = $(interpolations)/interpolation
$(interpolations)/patchToPatchInterpolation/PatchToPatchInterpolationName.C
+$(interpolations)/uniformInterpolationTable/uniformInterpolationTable.C
algorithms/MeshWave/MeshWaveName.C
algorithms/MeshWave/FaceCellWaveName.C
diff --git a/src/OpenFOAM/interpolations/uniformInterpolationTable/uniformInterpolationTable.C b/src/OpenFOAM/interpolations/uniformInterpolationTable/uniformInterpolationTable.C
new file mode 100644
index 0000000000000000000000000000000000000000..33cbc5e9170f074f09ec0d8db779d8c50f7e6096
--- /dev/null
+++ b/src/OpenFOAM/interpolations/uniformInterpolationTable/uniformInterpolationTable.C
@@ -0,0 +1,225 @@
+/*---------------------------------------------------------------------------*\
+ ========= |
+ \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
+ \\ / O peration |
+ \\ / A nd | Copyright (C) 2009-2009 OpenCFD Ltd.
+ \\/ M anipulation |
+-------------------------------------------------------------------------------
+License
+ This file is part of OpenFOAM.
+
+ OpenFOAM is free software; you can redistribute it and/or modify it
+ under the terms of the GNU General Public License as published by the
+ Free Software Foundation; either version 2 of the License, or (at your
+ option) any later version.
+
+ OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with OpenFOAM; if not, write to the Free Software Foundation,
+ Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+\*---------------------------------------------------------------------------*/
+
+#include "uniformInterpolationTable.H"
+#include "Time.H"
+
+// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
+
+namespace Foam
+{
+ defineTypeNameAndDebug(uniformInterpolationTable, 0);
+}
+
+// * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * * //
+
+void Foam::uniformInterpolationTable::checkTable() const
+{
+ if (size() < 2)
+ {
+ FatalErrorIn("uniformInterpolationTable::checkTable()")
+ << "Table " << name() << ": must have at least 2 values." << nl
+ << "Table size = " << size() << nl
+ << " min, interval width = " << x0_ << ", " << dx_ << nl
+ << exit(FatalError);
+ }
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
+
+Foam::uniformInterpolationTable::uniformInterpolationTable
+(
+ const IOobject& io,
+ bool readFields
+)
+:
+ IOobject(io),
+ List<scalar>(2, 0.0),
+ x0_(0.0),
+ dx_(1.0),
+ log10_(false),
+ bound_(false)
+{
+ if (readFields)
+ {
+ IOdictionary dict(io);
+
+ dict.lookup("data") >> *this;
+ dict.lookup("x0") >> x0_;
+ dict.lookup("dx") >> dx_;
+ dict.lookup("log10") >> log10_;
+ dict.lookup("bound") >> bound_;
+ }
+
+ checkTable();
+}
+
+
+Foam::uniformInterpolationTable::uniformInterpolationTable
+(
+ const word& tableName,
+ const objectRegistry& db,
+ const dictionary& dict,
+ const bool initialiseOnly
+)
+:
+ IOobject
+ (
+ tableName,
+ db.time().constant(),
+ db,
+ IOobject::NO_READ,
+ IOobject::NO_WRITE,
+ false // if used in BCs, could be used by multiple patches
+ ),
+ List<scalar>(2, 0.0),
+ x0_(readScalar(dict.lookup("x0"))),
+ dx_(readScalar(dict.lookup("dx"))),
+ log10_(dict.lookup("log10")),
+ bound_(dict.lookup("bound"))
+{
+ if (initialiseOnly)
+ {
+ scalar xMax = readScalar(dict.lookup("xMax"));
+ label nIntervals = static_cast<label>(xMax - x0_)/dx_ + 1;
+ setSize(nIntervals);
+ }
+ else
+ {
+ dict.lookup("data") >> *this;
+ }
+
+ checkTable();
+}
+
+
+Foam::uniformInterpolationTable::uniformInterpolationTable(const uniformInterpolationTable& uit)
+:
+ IOobject(uit),
+ List<scalar>(uit),
+ x0_(uit.x0_),
+ dx_(uit.dx_),
+ log10_(uit.log10_),
+ bound_(uit.bound_)
+{
+ checkTable();
+}
+
+
+// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
+
+Foam::uniformInterpolationTable::~uniformInterpolationTable()
+{}
+
+
+// * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * * //
+
+Foam::scalar Foam::uniformInterpolationTable::interpolate(scalar x) const
+{
+ if (bound_)
+ {
+ x = max(min(xMax() - SMALL*dx_, x), x0_);
+ }
+ else
+ {
+ if (x < x0_)
+ {
+ FatalErrorIn("uniformInterpolationTable::interpolate(scalar x)")
+ << "Supplied value is less than minimum table value:" << nl
+ << "xMin=" << x0_ << ", xMax=" << xMax() << ", x=" << x << nl
+ << exit(FatalError);
+ }
+
+ if (x > xMax())
+ {
+ FatalErrorIn("uniformInterpolationTable::interpolate(scalar x)")
+ << "Supplied value is greater than maximum table value:" << nl
+ << "xMin=" << x0_ << ", xMax=" << xMax() << ", x=" << x << nl
+ << exit(FatalError);
+ }
+ }
+
+ label i = static_cast<label>((x - x0_)/dx_);
+
+ scalar xLo = x0_ + i*dx_;
+
+ scalar fx = (x - xLo)/dx_*(operator[](i+1) - operator[](i)) + operator[](i);
+
+ if (debug)
+ {
+ Info<< "Table: " << name() << ", x=" << x
+ << ", x_lo=" << xLo << ", x_hi=" << xLo + dx_
+ << ", f(x_lo)=" << operator[](i) << ", f(x_hi)=" << operator[](i+1)
+ << ", f(x)=" << fx << endl;
+ }
+
+ return fx;
+}
+
+
+Foam::scalar Foam::uniformInterpolationTable::interpolateLog10(scalar x) const
+{
+ if (log10_)
+ {
+ if (x > 0)
+ {
+ x = ::log10(x);
+ }
+ else if (bound_ && (x <= 0))
+ {
+ x = x0_;
+ }
+ else
+ {
+ FatalErrorIn
+ (
+ "uniformInterpolationTable::interpolateLog10(scalar x)"
+ ) << "Table " << name() << nl
+ << "Supplied value must be greater than 0 when in log10 mode"
+ << nl << "x=" << x << nl << exit(FatalError);
+ }
+ }
+
+ return interpolate(x);
+}
+
+
+void Foam::uniformInterpolationTable::write() const
+{
+ IOdictionary dict(*this);
+
+ dict.add("data", static_cast<const List<scalar>&>(*this));
+ dict.add("x0", x0_);
+ dict.add("dx", dx_);
+ dict.add("log10", log10_);
+ dict.add("bound", bound_);
+
+ dict.regIOobject::write();
+}
+
+
+// ************************************************************************* //
diff --git a/src/OpenFOAM/interpolations/uniformInterpolationTable/uniformInterpolationTable.H b/src/OpenFOAM/interpolations/uniformInterpolationTable/uniformInterpolationTable.H
new file mode 100644
index 0000000000000000000000000000000000000000..c37867933cc5cfd0e6bfdb2cbebca4cc7dcda3d0
--- /dev/null
+++ b/src/OpenFOAM/interpolations/uniformInterpolationTable/uniformInterpolationTable.H
@@ -0,0 +1,218 @@
+/*---------------------------------------------------------------------------*\
+ ========= |
+ \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
+ \\ / O peration |
+ \\ / A nd | Copyright (C) 2009-2009 OpenCFD Ltd.
+ \\/ M anipulation |
+-------------------------------------------------------------------------------
+License
+ This file is part of OpenFOAM.
+
+ OpenFOAM is free software; you can redistribute it and/or modify it
+ under the terms of the GNU General Public License as published by the
+ Free Software Foundation; either version 2 of the License, or (at your
+ option) any later version.
+
+ OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with OpenFOAM; if not, write to the Free Software Foundation,
+ Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Class
+ Foam::uniformInterpolationTable
+
+Description
+ Table with uniform interval in independant variable, with linear
+ interpolation
+
+ Values specified in a dictionary:
+
+ {
+ x0 0; // lower limit
+ dx 0.2; // fixed interval
+ log10 true; // take log(10) when interpolating?
+ data // list of dependent data values
+ (
+ 7870 // value at x0
+ 7870 // value at x0 + dx
+ ...
+ 7870 // value at x0 + n*dx
+ );
+ }
+
+SourceFiles
+ uniformInterpolationTable.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef uniformInterpolationTable_H
+#define uniformInterpolationTable_H
+
+#include "List.H"
+#include "Switch.H"
+#include "IOobject.H"
+#include "objectRegistry.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+
+/*---------------------------------------------------------------------------*\
+ Class uniformInterpolationTable Declaration
+\*---------------------------------------------------------------------------*/
+
+class uniformInterpolationTable
+:
+ public IOobject,
+ public List<scalar>
+{
+ // Private data
+
+ // Control parameetrs
+
+ //- Lower limit
+ scalar x0_;
+
+ //- Fixed interval
+ scalar dx_;
+
+ //- Flag to indicate that x data is given in log10(x) form
+ Switch log10_;
+
+ //- Bound x values
+ Switch bound_;
+
+
+ // Private Member Functions
+
+ //- Check that the table is valid
+ void checkTable() const;
+
+ //- Disallow default bitwise assignment
+ void operator=(const uniformInterpolationTable&);
+
+
+public:
+
+ //- Runtime type information
+ TypeName("uniformInterpolationTable");
+
+
+ // Constructors
+
+ //- Construct from IOobject and readFields flag. Creates a null object
+ // if readFields = false
+ uniformInterpolationTable(const IOobject& io, const bool readFields);
+
+ //- Construct from name, objectRegistry and dictionary.
+ // If initialiseOnly flag is set, control parameters are read from
+ // the dictionary, but not the data table
+ uniformInterpolationTable
+ (
+ const word& tableName,
+ const objectRegistry& db,
+ const dictionary& dict,
+ const bool initialiseOnly = false
+ );
+
+ //- Construct as copy
+ uniformInterpolationTable(const uniformInterpolationTable& uit);
+
+
+ //- Destructor
+ ~uniformInterpolationTable();
+
+
+ // Member Functions
+
+ // Access
+
+ //- Return the lower limit
+ inline scalar x0() const;
+
+ //- Return the fixed interval
+ inline scalar dx() const;
+
+ //- Return the log10(x) flag
+ inline const Switch& log10() const;
+
+ //- Return the bound flag
+ inline const Switch& bound() const;
+
+
+ // Edit
+
+ //- Return the lower limit
+ inline scalar& x0();
+
+ //- Return the fixed interval
+ inline scalar& dx();
+
+ //- Return the log10(x) flag
+ inline Switch& log10();
+
+ //- Return the bound flag
+ inline Switch& bound();
+
+
+ // Evaluation
+
+ //- Return the minimum x value
+ inline scalar xMin() const;
+
+ //- Return the maximum x value
+ inline scalar xMax() const;
+
+ //- Interpolate
+ scalar interpolate(scalar x) const;
+
+ //- Interpolate - takes log10 flag into account
+ scalar interpolateLog10(scalar x) const;
+
+
+ // Override ancestor size() function and [] operator
+
+ //- Return the size of the table
+ label size() const
+ {
+ return List<scalar>::size();
+ }
+
+ //- Use List[] operator for read access
+ scalar operator[](label x) const
+ {
+ return List<scalar>::operator[](x);
+ }
+
+ //- Use List[] operator for write access
+ scalar& operator[](label x)
+ {
+ return List<scalar>::operator[](x);
+ }
+
+
+ // I-O
+
+ //- Write
+ void write() const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#include "uniformInterpolationTableI.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //
diff --git a/src/OpenFOAM/interpolations/uniformInterpolationTable/uniformInterpolationTableI.H b/src/OpenFOAM/interpolations/uniformInterpolationTable/uniformInterpolationTableI.H
new file mode 100644
index 0000000000000000000000000000000000000000..49e69b1c50ac565084280822ecf93871074c7c94
--- /dev/null
+++ b/src/OpenFOAM/interpolations/uniformInterpolationTable/uniformInterpolationTableI.H
@@ -0,0 +1,87 @@
+/*---------------------------------------------------------------------------*\
+ ========= |
+ \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
+ \\ / O peration |
+ \\ / A nd | Copyright (C) 2009-2009 OpenCFD Ltd.
+ \\/ M anipulation |
+-------------------------------------------------------------------------------
+License
+ This file is part of OpenFOAM.
+
+ OpenFOAM is free software; you can redistribute it and/or modify it
+ under the terms of the GNU General Public License as published by the
+ Free Software Foundation; either version 2 of the License, or (at your
+ option) any later version.
+
+ OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with OpenFOAM; if not, write to the Free Software Foundation,
+ Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+\*---------------------------------------------------------------------------*/
+
+Foam::scalar Foam::uniformInterpolationTable::x0() const
+{
+ return x0_;
+}
+
+
+Foam::scalar Foam::uniformInterpolationTable::dx() const
+{
+ return dx_;
+}
+
+
+const Foam::Switch& Foam::uniformInterpolationTable::log10() const
+{
+ return log10_;
+}
+
+
+const Foam::Switch& Foam::uniformInterpolationTable::bound() const
+{
+ return bound_;
+}
+
+
+Foam::scalar& Foam::uniformInterpolationTable::x0()
+{
+ return x0_;
+}
+
+
+Foam::scalar& Foam::uniformInterpolationTable::dx()
+{
+ return dx_;
+}
+
+
+Foam::Switch& Foam::uniformInterpolationTable::log10()
+{
+ return log10_;
+}
+
+
+Foam::Switch& Foam::uniformInterpolationTable::bound()
+{
+ return bound_;
+}
+
+
+Foam::scalar Foam::uniformInterpolationTable::xMin() const
+{
+ return x0_;
+}
+
+
+Foam::scalar Foam::uniformInterpolationTable::xMax() const
+{
+ return x0_ + (size()-1)*dx_;
+}
+
+
+// ************************************************************************* //
diff --git a/src/turbulenceModels/incompressible/RAS/Make/files b/src/turbulenceModels/incompressible/RAS/Make/files
index d81b1735b82d5309188e066eeb0f5fb3aba130f3..394e7391a75965341d8875f8288313646ff8af7a 100644
--- a/src/turbulenceModels/incompressible/RAS/Make/files
+++ b/src/turbulenceModels/incompressible/RAS/Make/files
@@ -26,6 +26,7 @@ $(nutWallFunctions)/nutkWallFunction/nutkWallFunctionFvPatchScalarField.C
$(nutWallFunctions)/nutURoughWallFunction/nutURoughWallFunctionFvPatchScalarField.C
$(nutWallFunctions)/nutUSpaldingWallFunction/nutUSpaldingWallFunctionFvPatchScalarField.C
$(nutWallFunctions)/nutUWallFunction/nutUWallFunctionFvPatchScalarField.C
+$(nutWallFunctions)/nutUTabulatedWallFunction/nutUTabulatedWallFunctionFvPatchScalarField.C
epsilonWallFunctions = $(wallFunctions)/epsilonWallFunctions
$(epsilonWallFunctions)/epsilonWallFunction/epsilonWallFunctionFvPatchScalarField.C
diff --git a/src/turbulenceModels/incompressible/RAS/derivedFvPatchFields/wallFunctions/nutWallFunctions/nutUTabulatedWallFunction/nutUTabulatedWallFunctionFvPatchScalarField.C b/src/turbulenceModels/incompressible/RAS/derivedFvPatchFields/wallFunctions/nutWallFunctions/nutUTabulatedWallFunction/nutUTabulatedWallFunctionFvPatchScalarField.C
new file mode 100644
index 0000000000000000000000000000000000000000..a3dfb6dedac9eaa04c9c839b1756a0a5908f5e5f
--- /dev/null
+++ b/src/turbulenceModels/incompressible/RAS/derivedFvPatchFields/wallFunctions/nutWallFunctions/nutUTabulatedWallFunction/nutUTabulatedWallFunctionFvPatchScalarField.C
@@ -0,0 +1,215 @@
+/*---------------------------------------------------------------------------*\
+ ========= |
+ \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
+ \\ / O peration |
+ \\ / A nd | Copyright (C) 2009-2009 OpenCFD Ltd.
+ \\/ M anipulation |
+-------------------------------------------------------------------------------
+License
+ This file is part of OpenFOAM.
+
+ OpenFOAM is free software; you can redistribute it and/or modify it
+ under the terms of the GNU General Public License as published by the
+ Free Software Foundation; either version 2 of the License, or (at your
+ option) any later version.
+
+ OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with OpenFOAM; if not, write to the Free Software Foundation,
+ Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+\*---------------------------------------------------------------------------*/
+
+#include "nutUTabulatedWallFunctionFvPatchScalarField.H"
+#include "RASModel.H"
+#include "fvPatchFieldMapper.H"
+#include "volFields.H"
+#include "addToRunTimeSelectionTable.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace incompressible
+{
+namespace RASModels
+{
+
+// * * * * * * * * * * * * Protected Member Functions * * * * * * * * * * * //
+
+tmp<scalarField> nutUTabulatedWallFunctionFvPatchScalarField::calcNut() const
+{
+ const label patchI = patch().index();
+
+ const RASModel& rasModel = db().lookupObject<RASModel>("RASProperties");
+ const scalarField& y = rasModel.y()[patchI];
+ const fvPatchVectorField& Uw = rasModel.U().boundaryField()[patchI];
+ const scalarField magUp = mag(Uw.patchInternalField() - Uw);
+ const scalarField magGradU = mag(Uw.snGrad()) + ROOTVSMALL;
+ const scalarField& nuw = rasModel.nu().boundaryField()[patchI];
+
+ return
+ max
+ (
+ scalar(0),
+ sqr(magUp/(calcUPlus(magUp*y/nuw) + ROOTVSMALL))/magGradU - nuw
+ );
+}
+
+
+tmp<scalarField> nutUTabulatedWallFunctionFvPatchScalarField::calcUPlus
+(
+ const scalarField& Rey
+) const
+{
+ tmp<scalarField> tuPlus(new scalarField(patch().size(), 0.0));
+ scalarField& uPlus = tuPlus();
+
+ forAll(uPlus, faceI)
+ {
+ uPlus[faceI] = uPlusTable_.interpolateLog10(Rey[faceI]);
+ }
+
+ return tuPlus;
+}
+
+
+// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
+
+nutUTabulatedWallFunctionFvPatchScalarField::
+nutUTabulatedWallFunctionFvPatchScalarField
+(
+ const fvPatch& p,
+ const DimensionedField<scalar, volMesh>& iF
+)
+:
+ nutkWallFunctionFvPatchScalarField(p, iF),
+ uPlusTableName_("undefined-uPlusTableName"),
+ uPlusTable_
+ (
+ IOobject
+ (
+ uPlusTableName_,
+ patch().boundaryMesh().mesh().time().constant(),
+ patch().boundaryMesh().mesh(),
+ IOobject::NO_READ,
+ IOobject::NO_WRITE,
+ false
+ ),
+ false
+ )
+{}
+
+
+nutUTabulatedWallFunctionFvPatchScalarField::
+nutUTabulatedWallFunctionFvPatchScalarField
+(
+ const nutUTabulatedWallFunctionFvPatchScalarField& ptf,
+ const fvPatch& p,
+ const DimensionedField<scalar, volMesh>& iF,
+ const fvPatchFieldMapper& mapper
+)
+:
+ nutkWallFunctionFvPatchScalarField(ptf, p, iF, mapper),
+ uPlusTableName_(ptf.uPlusTableName_),
+ uPlusTable_(ptf.uPlusTable_)
+{}
+
+
+nutUTabulatedWallFunctionFvPatchScalarField::
+nutUTabulatedWallFunctionFvPatchScalarField
+(
+ const fvPatch& p,
+ const DimensionedField<scalar, volMesh>& iF,
+ const dictionary& dict
+)
+:
+ nutkWallFunctionFvPatchScalarField(p, iF, dict),
+ uPlusTableName_(dict.lookup("uPlusTable")),
+ uPlusTable_
+ (
+ IOobject
+ (
+ uPlusTableName_,
+ patch().boundaryMesh().mesh().time().constant(),
+ patch().boundaryMesh().mesh(),
+ IOobject::MUST_READ,
+ IOobject::NO_WRITE,
+ false
+ ),
+ true
+ )
+{}
+
+
+nutUTabulatedWallFunctionFvPatchScalarField::
+nutUTabulatedWallFunctionFvPatchScalarField
+(
+ const nutUTabulatedWallFunctionFvPatchScalarField& wfpsf
+)
+:
+ nutkWallFunctionFvPatchScalarField(wfpsf),
+ uPlusTableName_(wfpsf.uPlusTableName_),
+ uPlusTable_(wfpsf.uPlusTable_)
+{}
+
+
+nutUTabulatedWallFunctionFvPatchScalarField::
+nutUTabulatedWallFunctionFvPatchScalarField
+(
+ const nutUTabulatedWallFunctionFvPatchScalarField& wfpsf,
+ const DimensionedField<scalar, volMesh>& iF
+)
+:
+ nutkWallFunctionFvPatchScalarField(wfpsf, iF),
+ uPlusTableName_(wfpsf.uPlusTableName_),
+ uPlusTable_(wfpsf.uPlusTable_)
+{}
+
+
+// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
+
+tmp<scalarField> nutUTabulatedWallFunctionFvPatchScalarField::yPlus() const
+{
+ const label patchI = patch().index();
+
+ const RASModel& rasModel = db().lookupObject<RASModel>("RASProperties");
+ const scalarField& y = rasModel.y()[patchI];
+ const fvPatchVectorField& Uw = rasModel.U().boundaryField()[patchI];
+ const scalarField magUp = mag(Uw.patchInternalField() - Uw);
+ const scalarField& nuw = rasModel.nu().boundaryField()[patchI];
+ const scalarField Rey = magUp*y/nuw;
+
+ return Rey/(calcUPlus(Rey) + ROOTVSMALL);
+}
+
+
+void nutUTabulatedWallFunctionFvPatchScalarField::write(Ostream& os) const
+{
+ fvPatchField<scalar>::write(os);
+// writeLocalEntries(os); // not applicable to this nut BC
+ os.writeKeyword("uPlusTable") << uPlusTableName_
+ << token::END_STATEMENT << nl;
+ writeEntry("value", os);
+}
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+makePatchTypeField
+(
+ fvPatchScalarField,
+ nutUTabulatedWallFunctionFvPatchScalarField
+);
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace RASModels
+} // End namespace incompressible
+} // End namespace Foam
+
+// ************************************************************************* //
diff --git a/src/turbulenceModels/incompressible/RAS/derivedFvPatchFields/wallFunctions/nutWallFunctions/nutUTabulatedWallFunction/nutUTabulatedWallFunctionFvPatchScalarField.H b/src/turbulenceModels/incompressible/RAS/derivedFvPatchFields/wallFunctions/nutWallFunctions/nutUTabulatedWallFunction/nutUTabulatedWallFunctionFvPatchScalarField.H
new file mode 100644
index 0000000000000000000000000000000000000000..b04c72b7babffdd829e561fe59dc43fccf2654a4
--- /dev/null
+++ b/src/turbulenceModels/incompressible/RAS/derivedFvPatchFields/wallFunctions/nutWallFunctions/nutUTabulatedWallFunction/nutUTabulatedWallFunctionFvPatchScalarField.H
@@ -0,0 +1,177 @@
+/*---------------------------------------------------------------------------*\
+ ========= |
+ \\ / F ield | OpenFOAM: The Open Source CFD Toolbox
+ \\ / O peration |
+ \\ / A nd | Copyright (C) 2009-2009 OpenCFD Ltd.
+ \\/ M anipulation |
+-------------------------------------------------------------------------------
+License
+ This file is part of OpenFOAM.
+
+ OpenFOAM is free software; you can redistribute it and/or modify it
+ under the terms of the GNU General Public License as published by the
+ Free Software Foundation; either version 2 of the License, or (at your
+ option) any later version.
+
+ OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+ ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
+ for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with OpenFOAM; if not, write to the Free Software Foundation,
+ Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+
+Class
+ Foam::incompressible::RASModels::nutUTabulatedWallFunctionFvPatchScalarField
+
+Description
+ Wall function boundary condition for turbulence kinematic viscosity. Uses a
+ table to return the value of U+ as a function of near-wall Reynolds number.
+
+ Note: the tables are not registered since the same table object may be used
+ for more than one patch.
+
+SourceFiles
+ nutUTabulatedWallFunctionFvPatchScalarField.C
+
+\*---------------------------------------------------------------------------*/
+
+#ifndef nutUTabulatedWallFunctionFvPatchScalarField_H
+#define nutUTabulatedWallFunctionFvPatchScalarField_H
+
+#include "nutkWallFunctionFvPatchScalarField.H"
+#include "uniformInterpolationTable.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+namespace Foam
+{
+namespace incompressible
+{
+namespace RASModels
+{
+
+/*---------------------------------------------------------------------------*\
+ Class nutUTabulatedWallFunctionFvPatchScalarField Declaration
+\*---------------------------------------------------------------------------*/
+
+class nutUTabulatedWallFunctionFvPatchScalarField
+:
+ public nutkWallFunctionFvPatchScalarField
+{
+protected:
+
+ // Protected data
+
+ //- Name of u+ table
+ word uPlusTableName_;
+
+ //- U+ table
+ uniformInterpolationTable uPlusTable_;
+
+
+ // Protected member functions
+
+ //- Calculate the turbulence viscosity
+ virtual tmp<scalarField> calcNut() const;
+
+ //- Calculate wall u+ from table
+ virtual tmp<scalarField> calcUPlus(const scalarField& Rey) const;
+
+
+public:
+
+ //- Runtime type information
+ TypeName("nutTabulatedWallFunction");
+
+
+ // Constructors
+
+ //- Construct from patch and internal field
+ nutUTabulatedWallFunctionFvPatchScalarField
+ (
+ const fvPatch&,
+ const DimensionedField<scalar, volMesh>&
+ );
+
+ //- Construct from patch, internal field and dictionary
+ nutUTabulatedWallFunctionFvPatchScalarField
+ (
+ const fvPatch&,
+ const DimensionedField<scalar, volMesh>&,
+ const dictionary&
+ );
+
+ //- Construct by mapping given
+ // nutUTabulatedWallFunctionFvPatchScalarField
+ // onto a new patch
+ nutUTabulatedWallFunctionFvPatchScalarField
+ (
+ const nutUTabulatedWallFunctionFvPatchScalarField&,
+ const fvPatch&,
+ const DimensionedField<scalar, volMesh>&,
+ const fvPatchFieldMapper&
+ );
+
+ //- Construct as copy
+ nutUTabulatedWallFunctionFvPatchScalarField
+ (
+ const nutUTabulatedWallFunctionFvPatchScalarField&
+ );
+
+ //- Construct and return a clone
+ virtual tmp<fvPatchScalarField> clone() const
+ {
+ return tmp<fvPatchScalarField>
+ (
+ new nutUTabulatedWallFunctionFvPatchScalarField(*this)
+ );
+ }
+
+ //- Construct as copy setting internal field reference
+ nutUTabulatedWallFunctionFvPatchScalarField
+ (
+ const nutUTabulatedWallFunctionFvPatchScalarField&,
+ const DimensionedField<scalar, volMesh>&
+ );
+
+ //- Construct and return a clone setting internal field reference
+ virtual tmp<fvPatchScalarField> clone
+ (
+ const DimensionedField<scalar, volMesh>& iF
+ ) const
+ {
+ return tmp<fvPatchScalarField>
+ (
+ new nutUTabulatedWallFunctionFvPatchScalarField(*this, iF)
+ );
+ }
+
+
+ // Member functions
+
+ // Evaluation functions
+
+ //- Calculate and return the yPlus at the boundary
+ virtual tmp<scalarField> yPlus() const;
+
+
+ // I-O
+
+ //- Write
+ virtual void write(Ostream& os) const;
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace RASModels
+} // End namespace incompressible
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //