Add the OpenFOAM source tree

applications/utilities/preProcessing/wallFunctionTable/Allwclean

@@ -0,0 +1,5 @@
+#!/bin/sh
+
+wclean libso tabulatedWallFunction
+wclean
+

applications/utilities/preProcessing/wallFunctionTable/Allwmake

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

applications/utilities/preProcessing/wallFunctionTable/Make/files

@@ -0,0 +1,3 @@
+wallFunctionTableApp.C
+
+EXE = $(FOAM_APPBIN)/wallFunctionTable

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

applications/utilities/preProcessing/wallFunctionTable/tabulatedWallFunction/Make/files

@@ -0,0 +1,7 @@
+tabulatedWallFunction/tabulatedWallFunction.C
+tabulatedWallFunction/tabulatedWallFunctionNew.C
+
+SpaldingsLaw/SpaldingsLaw.C
+general/general.C
+
+LIB = $(FOAM_LIBBIN)/libtabulatedWallFunctions

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

applications/utilities/preProcessing/wallFunctionTable/tabulatedWallFunction/SpaldingsLaw/SpaldingsLaw.C

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

applications/utilities/preProcessing/wallFunctionTable/tabulatedWallFunction/SpaldingsLaw/SpaldingsLaw.H

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

applications/utilities/preProcessing/wallFunctionTable/tabulatedWallFunction/general/general.C

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

applications/utilities/preProcessing/wallFunctionTable/tabulatedWallFunction/general/general.H

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

applications/utilities/preProcessing/wallFunctionTable/tabulatedWallFunction/tabulatedWallFunction/tabulatedWallFunction.C

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

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) 2011 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+Class
+    Foam::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<scalar> 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<scalar>&
+                invertedTable() const;
+
+
+        // I-O
+
+            //- Write
+            virtual void write();
+};
+
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+} // End namespace tabulatedWallFunctions
+} // End namespace Foam
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#include "tabulatedWallFunctionI.H"
+
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+#endif
+
+// ************************************************************************* //

applications/utilities/preProcessing/wallFunctionTable/tabulatedWallFunction/tabulatedWallFunction/tabulatedWallFunctionI.H

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

applications/utilities/preProcessing/wallFunctionTable/tabulatedWallFunction/tabulatedWallFunction/tabulatedWallFunctionNew.C

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

applications/utilities/preProcessing/wallFunctionTable/wallFunctionDict

@@ -0,0 +1,37 @@
+/*--------------------------------*- C++ -*----------------------------------*\
+| =========                 |                                                 |
+| \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox           |
+|  \\    /   O peration     | Version:  dev                                   |
+|   \\  /    A nd           | Web:      www.OpenFOAM.org                      |
+|    \\/     M anipulation  |                                                 |
+\*---------------------------------------------------------------------------*/
+FoamFile
+{
+    version     2.0;
+    format      ascii;
+    class       dictionary;
+    object      wallFunctionDict;
+}
+// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
+
+tabulatedWallFunction SpaldingsLaw;
+
+invertedTableName uPlusWallFunctionData;
+
+dx              0.2;
+
+x0              -3;
+
+xMax            7;
+
+log10           yes;
+
+bound           yes;
+
+SpaldingsLawCoeffs
+{
+    kappa           0.41;
+    E               9.8;
+}
+
+// ************************************************************************* //

applications/utilities/preProcessing/wallFunctionTable/wallFunctionTableApp.C

@@ -0,0 +1,67 @@
+/*---------------------------------------------------------------------------*\
+  =========                 |
+  \\      /  F ield         | OpenFOAM: The Open Source CFD Toolbox
+   \\    /   O peration     |
+    \\  /    A nd           | Copyright (C) 2011-2013 OpenFOAM Foundation
+     \\/     M anipulation  |
+-------------------------------------------------------------------------------
+License
+    This file is part of OpenFOAM.
+
+    OpenFOAM is free software: you can redistribute it and/or modify it
+    under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    OpenFOAM is distributed in the hope that it will be useful, but WITHOUT
+    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+    FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
+    for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with OpenFOAM.  If not, see <http://www.gnu.org/licenses/>.
+
+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_IF_MODIFIED
+        )
+    );
+
+    autoPtr<tabulatedWallFunctions::tabulatedWallFunction>
+        twf(tabulatedWallFunctions::tabulatedWallFunction::New(dict, mesh));
+
+//    twf->writeData(Info);
+
+    twf->write();
+
+    Info<< "End\n" << endl;
+
+    return 0;
+}
+
+
+// ************************************************************************* //