mirror of
https://develop.openfoam.com/Development/openfoam.git
synced 2025-11-28 03:28:01 +00:00
adding tabulated U wall function BC and utility to generate tables
This commit is contained in:
andy
5
applications/utilities/preProcessing/wallFunctionTable/Allwclean
Executable file
5
applications/utilities/preProcessing/wallFunctionTable/Allwclean
Executable file
@ -0,0 +1,5 @@
|
||||
#!/bin/sh
|
||||
|
||||
wclean libso tabulatedWallFunction
|
||||
wclean
|
||||
|
||||
5
applications/utilities/preProcessing/wallFunctionTable/Allwmake
Executable file
5
applications/utilities/preProcessing/wallFunctionTable/Allwmake
Executable file
@ -0,0 +1,5 @@
|
||||
#!/bin/sh
|
||||
|
||||
wmake libso tabulatedWallFunction
|
||||
wmake
|
||||
|
||||
@ -0,0 +1,3 @@
|
||||
wallFunctionTableApp.C
|
||||
|
||||
EXE = $(FOAM_APPBIN)/wallFunctionTable
|
||||
@ -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
|
||||
@ -0,0 +1,7 @@
|
||||
tabulatedWallFunction/tabulatedWallFunction.C
|
||||
tabulatedWallFunction/newTabulatedWallFunction.C
|
||||
|
||||
SpaldingsLaw/SpaldingsLaw.C
|
||||
general/general.C
|
||||
|
||||
LIB = $(FOAM_LIBBIN)/libtabulatedWallFunctions
|
||||
@ -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
|
||||
@ -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;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// ************************************************************************* //
|
||||
@ -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
|
||||
|
||||
// ************************************************************************* //
|
||||
@ -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;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
// ************************************************************************* //
|
||||
@ -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
|
||||
|
||||
// ************************************************************************* //
|
||||
@ -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
|
||||
|
||||
// ************************************************************************* //
|
||||
@ -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();
|
||||
}
|
||||
|
||||
|
||||
// ************************************************************************* //
|
||||
@ -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
|
||||
|
||||
// ************************************************************************* //
|
||||
@ -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_;
|
||||
}
|
||||
|
||||
|
||||
// ************************************************************************* //
|
||||
@ -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;
|
||||
}
|
||||
|
||||
|
||||
// ************************************************************************* //
|
||||
@ -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;
|
||||
}
|
||||
|
||||
|
||||
// ************************************************************************* //
|
||||
@ -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
|
||||
|
||||
@ -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();
|
||||
}
|
||||
|
||||
|
||||
// ************************************************************************* //
|
||||
@ -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
|
||||
|
||||
// ************************************************************************* //
|
||||
@ -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_;
|
||||
}
|
||||
|
||||
|
||||
// ************************************************************************* //
|
||||
@ -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
|
||||
|
||||
@ -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
|
||||
|
||||
// ************************************************************************* //
|
||||
@ -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
|
||||
|
||||
// ************************************************************************* //
|
||||
Reference in New Issue
Block a user