zhyang-dev/OpenFOAM-12
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

nutUTabulatedWallFunctionFvPatchScalarField: Removed redundant code

Browse Source 
The current rough wall functions cover most requirements and there is no clear
need to maintain nutUTabulatedWallFunctionFvPatchScalarField and associated
clutter.
This commit is contained in:
Henry Weller
2020-11-13 16:17:45 +00:00
parent 922c172352
commit fbadc20773
21 changed files with 0 additions and 2143 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
applications/utilities/preProcessing/wallFunctionTable/Allwclean
View File

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

10
applications/utilities/preProcessing/wallFunctionTable/Allwmake
View File

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

3
applications/utilities/preProcessing/wallFunctionTable/Make/files
View File

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

9
applications/utilities/preProcessing/wallFunctionTable/Make/options
View File

@ -1,9 +0,0 @@
EXE_INC = \
-I./tabulatedWallFunction/lnInclude \
-I$(LIB_SRC)/finiteVolume/lnInclude \
-I$(LIB_SRC)/meshTools/lnInclude
EXE_LIBS = \
-ltabulatedWallFunctions \
-lfiniteVolume \
-lmeshTools

7
applications/utilities/preProcessing/wallFunctionTable/tabulatedWallFunction/Make/files
View File

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

7
applications/utilities/preProcessing/wallFunctionTable/tabulatedWallFunction/Make/options
View File

@ -1,7 +0,0 @@
EXE_INC = \
-I$(LIB_SRC)/finiteVolume/lnInclude \
-I$(LIB_SRC)/transportModels
LIB_LIBS = \
-lfiniteVolume

196
applications/utilities/preProcessing/wallFunctionTable/tabulatedWallFunction/SpaldingsLaw/SpaldingsLaw.C
View File

@ -1,196 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2019 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.0/3.0*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_)
{
WarningInFunction
<< "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_(coeffDict_.lookup<scalar>("kappa")),
E_(coeffDict_.lookup<scalar>("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;
}
}
}
// ************************************************************************* //

139
applications/utilities/preProcessing/wallFunctionTable/tabulatedWallFunction/SpaldingsLaw/SpaldingsLaw.H
View File

@ -1,139 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2018 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
// ************************************************************************* //

243
applications/utilities/preProcessing/wallFunctionTable/tabulatedWallFunction/general/general.C
View File

@ -1,243 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2018 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:
{
FatalErrorInFunction
<< "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)
{
FatalErrorInFunction
<< "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;
}
}
}
// ************************************************************************* //

171
applications/utilities/preProcessing/wallFunctionTable/tabulatedWallFunction/general/general.H
View File

@ -1,171 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2020 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
// ************************************************************************* //

86
applications/utilities/preProcessing/wallFunctionTable/tabulatedWallFunction/tabulatedWallFunction/tabulatedWallFunction.C
View File

@ -1,86 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2020 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.optionalSubDict(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_.localObjectPath() << endl;
invertedTable_.write();
}
// ************************************************************************* //

147
applications/utilities/preProcessing/wallFunctionTable/tabulatedWallFunction/tabulatedWallFunction/tabulatedWallFunction.H
View File

@ -1,147 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2020 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:
// Protected 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
// ************************************************************************* //

44
applications/utilities/preProcessing/wallFunctionTable/tabulatedWallFunction/tabulatedWallFunction/tabulatedWallFunctionI.H
View File

@ -1,44 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2018 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_;
}
// ************************************************************************* //

68
applications/utilities/preProcessing/wallFunctionTable/tabulatedWallFunction/tabulatedWallFunction/tabulatedWallFunctionNew.C
View File

@ -1,68 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2018 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())
{
FatalErrorInFunction
<< "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
// ************************************************************************* //

65
applications/utilities/preProcessing/wallFunctionTable/wallFunctionTable.C
View File

@ -1,65 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2019 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->write();
Info<< "End\n" << endl;
return 0;
}
// ************************************************************************* //

1
src/MomentumTransportModels/momentumTransportModels/Make/files
View File

@ -36,7 +36,6 @@ $(nutWallFunctions)/nutkRoughWallFunction/nutkRoughWallFunctionFvPatchScalarFiel
$(nutWallFunctions)/nutUWallFunction/nutUWallFunctionFvPatchScalarField.C
$(nutWallFunctions)/nutUSpaldingWallFunction/nutUSpaldingWallFunctionFvPatchScalarField.C
$(nutWallFunctions)/nutUTabulatedWallFunction/nutUTabulatedWallFunctionFvPatchScalarField.C
$(nutWallFunctions)/nutLowReWallFunction/nutLowReWallFunctionFvPatchScalarField.C
$(nutWallFunctions)/nutURoughWallFunction/nutURoughWallFunctionFvPatchScalarField.C

214
src/MomentumTransportModels/momentumTransportModels/derivedFvPatchFields/wallFunctions/nutWallFunctions/nutUTabulatedWallFunction/nutUTabulatedWallFunctionFvPatchScalarField.C
View File

@ -1,214 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2020 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 "nutUTabulatedWallFunctionFvPatchScalarField.H"
#include "momentumTransportModel.H"
#include "fvPatchFieldMapper.H"
#include "volFields.H"
#include "addToRunTimeSelectionTable.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
// * * * * * * * * * * * * Protected Member Functions * * * * * * * * * * * //
tmp<scalarField> nutUTabulatedWallFunctionFvPatchScalarField::nut() const
{
const label patchi = patch().index();
const momentumTransportModel& turbModel =
db().lookupObject<momentumTransportModel>
(
IOobject::groupName
(
momentumTransportModel::typeName,
internalField().group()
)
);
const scalarField& y = turbModel.y()[patchi];
const fvPatchVectorField& Uw = turbModel.U().boundaryField()[patchi];
const scalarField magUp(mag(Uw.patchInternalField() - Uw));
const scalarField magGradU(mag(Uw.snGrad()));
const tmp<scalarField> tnuw = turbModel.nu(patchi);
const scalarField& nuw = tnuw();
return
max
(
scalar(0),
sqr(magUp/(calcUPlus(magUp*y/nuw) + rootVSmall))
/(magGradU + rootVSmall)
- nuw
);
}
tmp<scalarField> nutUTabulatedWallFunctionFvPatchScalarField::calcUPlus
(
const scalarField& Rey
) const
{
tmp<scalarField> tuPlus(new scalarField(patch().size(), 0.0));
scalarField& uPlus = tuPlus.ref();
forAll(uPlus, facei)
{
uPlus[facei] = uPlusTable_.interpolateLog10(Rey[facei]);
}
return tuPlus;
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
nutUTabulatedWallFunctionFvPatchScalarField::
nutUTabulatedWallFunctionFvPatchScalarField
(
const fvPatch& p,
const DimensionedField<scalar, volMesh>& iF
)
:
nutWallFunctionFvPatchScalarField(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
)
:
nutWallFunctionFvPatchScalarField(ptf, p, iF, mapper),
uPlusTableName_(ptf.uPlusTableName_),
uPlusTable_(ptf.uPlusTable_)
{}
nutUTabulatedWallFunctionFvPatchScalarField::
nutUTabulatedWallFunctionFvPatchScalarField
(
const fvPatch& p,
const DimensionedField<scalar, volMesh>& iF,
const dictionary& dict
)
:
nutWallFunctionFvPatchScalarField(p, iF, dict),
uPlusTableName_(dict.lookup("uPlusTable")),
uPlusTable_
(
IOobject
(
uPlusTableName_,
patch().boundaryMesh().mesh().time().constant(),
patch().boundaryMesh().mesh(),
IOobject::MUST_READ_IF_MODIFIED,
IOobject::NO_WRITE,
false
),
true
)
{}
nutUTabulatedWallFunctionFvPatchScalarField::
nutUTabulatedWallFunctionFvPatchScalarField
(
const nutUTabulatedWallFunctionFvPatchScalarField& wfpsf,
const DimensionedField<scalar, volMesh>& iF
)
:
nutWallFunctionFvPatchScalarField(wfpsf, iF),
uPlusTableName_(wfpsf.uPlusTableName_),
uPlusTable_(wfpsf.uPlusTable_)
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
tmp<scalarField> nutUTabulatedWallFunctionFvPatchScalarField::yPlus() const
{
const label patchi = patch().index();
const momentumTransportModel& turbModel =
db().lookupObject<momentumTransportModel>
(
IOobject::groupName
(
momentumTransportModel::typeName,
internalField().group()
)
);
const scalarField& y = turbModel.y()[patchi];
const fvPatchVectorField& Uw = turbModel.U().boundaryField()[patchi];
const scalarField magUp(mag(Uw.patchInternalField() - Uw));
const tmp<scalarField> tnuw = turbModel.nu(patchi);
const scalarField& nuw = tnuw();
const scalarField Rey(magUp*y/nuw);
return Rey/(calcUPlus(Rey) + rootVSmall);
}
void nutUTabulatedWallFunctionFvPatchScalarField::write(Ostream& os) const
{
fvPatchField<scalar>::write(os);
writeEntry(os, "uPlusTable", uPlusTableName_);
writeEntry(os, "value", *this);
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
makePatchTypeField
(
fvPatchScalarField,
nutUTabulatedWallFunctionFvPatchScalarField
);
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// ************************************************************************* //

183
src/MomentumTransportModels/momentumTransportModels/derivedFvPatchFields/wallFunctions/nutWallFunctions/nutUTabulatedWallFunction/nutUTabulatedWallFunctionFvPatchScalarField.H
View File

@ -1,183 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2020 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::nutUTabulatedWallFunctionFvPatchScalarField
Description
This boundary condition provides a turbulent kinematic viscosity condition
when using wall functions. As input, the user specifies a look-up table
of U+ as a function of near-wall Reynolds number. The table should be
located in the $FOAM_CASE/constant directory.
Usage
\table
Property | Description | Required | Default value
uPlusTable | U+ as a function of Re table name | yes |
\endtable
Example of the boundary condition specification:
\verbatim
<patchName>
{
type nutTabulatedWallFunction;
uPlusTable myUPlusTable;
value uniform 0;
}
\endverbatim
Note
The tables are not registered since the same table object may be used for
more than one patch.
See also
Foam::nutWallFunctionFvPatchScalarField
SourceFiles
nutUTabulatedWallFunctionFvPatchScalarField.C
\*---------------------------------------------------------------------------*/
#ifndef nutUTabulatedWallFunctionFvPatchScalarField_H
#define nutUTabulatedWallFunctionFvPatchScalarField_H
#include "nutWallFunctionFvPatchScalarField.H"
#include "uniformInterpolationTable.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class nutUTabulatedWallFunctionFvPatchScalarField Declaration
\*---------------------------------------------------------------------------*/
class nutUTabulatedWallFunctionFvPatchScalarField
:
public nutWallFunctionFvPatchScalarField
{
protected:
// Protected data
//- Name of u+ table
word uPlusTableName_;
//- U+ table
uniformInterpolationTable<scalar> uPlusTable_;
// Protected Member Functions
//- Calculate the turbulence viscosity
virtual tmp<scalarField> nut() 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&
);
//- Disallow copy without setting internal field reference
nutUTabulatedWallFunctionFvPatchScalarField
(
const nutUTabulatedWallFunctionFvPatchScalarField&
) = delete;
//- Copy constructor 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 Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

236
src/OpenFOAM/interpolations/uniformInterpolationTable/uniformInterpolationTable.C
View File

@ -1,236 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2019 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 "uniformInterpolationTable.H"
#include "Time.H"
#include "IOdictionary.H"
// * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * * //
template<class Type>
void Foam::uniformInterpolationTable<Type>::checkTable() const
{
if (size() < 2)
{
FatalErrorInFunction
<< "Table " << name() << ": must have at least 2 values." << nl
<< "Table size = " << size() << nl
<< " min, interval width = " << x0_ << ", " << dx_ << nl
<< exit(FatalError);
}
}
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
template<class Type>
Foam::uniformInterpolationTable<Type>::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.readIfPresent("log10", log10_);
dict.readIfPresent("bound", bound_);
}
checkTable();
}
template<class Type>
Foam::uniformInterpolationTable<Type>::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_(dict.lookup<scalar>("x0")),
dx_(dict.lookup<scalar>("dx")),
log10_(dict.lookupOrDefault<Switch>("log10", false)),
bound_(dict.lookupOrDefault<Switch>("bound", false))
{
if (initialiseOnly)
{
const scalar xMax = dict.lookup<scalar>("xMax");
const label nIntervals = static_cast<label>(xMax - x0_)/dx_ + 1;
this->setSize(nIntervals);
}
else
{
dict.lookup("data") >> *this;
}
checkTable();
}
template<class Type>
Foam::uniformInterpolationTable<Type>::uniformInterpolationTable
(
const uniformInterpolationTable& uit
)
:
IOobject(uit),
List<scalar>(uit),
x0_(uit.x0_),
dx_(uit.dx_),
log10_(uit.log10_),
bound_(uit.bound_)
{
checkTable();
}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
template<class Type>
Foam::uniformInterpolationTable<Type>::~uniformInterpolationTable()
{}
// * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * * //
template<class Type>
Type Foam::uniformInterpolationTable<Type>::interpolate(scalar x) const
{
if (bound_)
{
x = max(min(xMax() - small*dx_, x), x0_);
}
else
{
if (x < x0_)
{
FatalErrorInFunction
<< "Supplied value is less than minimum table value:" << nl
<< "xMin=" << x0_ << ", xMax=" << xMax() << ", x=" << x << nl
<< exit(FatalError);
}
if (x > xMax())
{
FatalErrorInFunction
<< "Supplied value is greater than maximum table value:" << nl
<< "xMin=" << x0_ << ", xMax=" << xMax() << ", x=" << x << nl
<< exit(FatalError);
}
}
const label i = static_cast<label>((x - x0_)/dx_);
const scalar xLo = x0_ + i*dx_;
Type 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;
}
template<class Type>
Type Foam::uniformInterpolationTable<Type>::interpolateLog10
(
scalar x
) const
{
if (log10_)
{
if (x > 0)
{
x = ::log10(x);
}
else if (bound_ && (x <= 0))
{
x = x0_;
}
else
{
FatalErrorInFunction
<< "Table " << name() << nl
<< "Supplied value must be greater than 0 when in log10 mode"
<< nl << "x=" << x << nl << exit(FatalError);
}
}
return interpolate(x);
}
template<class Type>
void Foam::uniformInterpolationTable<Type>::write() const
{
IOdictionary dict(*this);
dict.add("data", static_cast<const List<scalar>&>(*this));
dict.add("x0", x0_);
dict.add("dx", dx_);
if (log10_)
{
dict.add("log10", log10_);
}
if (bound_)
{
dict.add("bound", bound_);
}
dict.regIOobject::write();
}
// ************************************************************************* //

213
src/OpenFOAM/interpolations/uniformInterpolationTable/uniformInterpolationTable.H
View File

@ -1,213 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2020 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::uniformInterpolationTable
Description
Table with uniform interval in independent variable, with linear
interpolation
Example usage (scalar): values specified within a dictionary:
\verbatim
{
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
);
}
\endverbatim
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
\*---------------------------------------------------------------------------*/
template<class Type>
class uniformInterpolationTable
:
public IOobject,
public List<Type>
{
// Private Data
// Control parameters
//- Lower limit
scalar x0_;
//- Fixed interval
scalar dx_;
//- Flag to indicate that x data are given in log10(x) form
Switch log10_;
//- Bound x values
Switch bound_;
// Private Member Functions
//- Check that the table is valid
void checkTable() const;
public:
// Constructors
//- Construct from IOobject and readFields flag.
// Creates a null object if readFields = false
uniformInterpolationTable(const IOobject&, 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&,
const dictionary&,
const bool initialiseOnly = false
);
//- Copy constructor
uniformInterpolationTable(const uniformInterpolationTable&);
//- 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
Type interpolate(scalar x) const;
//- Interpolate - takes log10 flag into account
Type interpolateLog10(scalar x) const;
// Override ancestor size() function and [] operator
//- Return the size of the table
using List<Type>::size;
//- Use List[] operator for read/write access
using List<Type>::operator[];
// I-O
//- Write
void write() const;
// Member Operators
//- Disallow default bitwise assignment
void operator=(const uniformInterpolationTable&) = delete;
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#include "uniformInterpolationTableI.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#ifdef NoRepository
#include "uniformInterpolationTable.C"
#endif
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

96
src/OpenFOAM/interpolations/uniformInterpolationTable/uniformInterpolationTableI.H
View File

@ -1,96 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2018 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/>.
\*---------------------------------------------------------------------------*/
template<class Type>
Foam::scalar Foam::uniformInterpolationTable<Type>::x0() const
{
return x0_;
}
template<class Type>
Foam::scalar Foam::uniformInterpolationTable<Type>::dx() const
{
return dx_;
}
template<class Type>
const Foam::Switch& Foam::uniformInterpolationTable<Type>::log10() const
{
return log10_;
}
template<class Type>
const Foam::Switch& Foam::uniformInterpolationTable<Type>::bound() const
{
return bound_;
}
template<class Type>
Foam::scalar& Foam::uniformInterpolationTable<Type>::x0()
{
return x0_;
}
template<class Type>
Foam::scalar& Foam::uniformInterpolationTable<Type>::dx()
{
return dx_;
}
template<class Type>
Foam::Switch& Foam::uniformInterpolationTable<Type>::log10()
{
return log10_;
}
template<class Type>
Foam::Switch& Foam::uniformInterpolationTable<Type>::bound()
{
return bound_;
}
template<class Type>
Foam::scalar Foam::uniformInterpolationTable<Type>::xMin() const
{
return x0_;
}
template<class Type>
Foam::scalar Foam::uniformInterpolationTable<Type>::xMax() const
{
return x0_ + dx_*(size() - 1);
}
// ************************************************************************* //