/*!
\internal
Find the relative path for the \a filename relative to our path,
with a nut folder inside. This performs a deep pattern search,
looking for sub folders.
*/
QString Settings::findRelativePathDepthSearch( const QString& filename, const QDir& startPoint )
{
// First look inside current folder and children.
QDirIterator it( startPoint, QDirIterator::Subdirectories | QDirIterator::FollowSymlinks );
while( it.hasNext() )
{
QString folder = it.next();
if ( folder.contains( QRegExp("/nut/?$") ) )
{
QDir nut( folder );
if ( nut.exists( filename ) )
return QDir::current().relativeFilePath( QDir( folder ).absoluteFilePath( filename ) );
}
}
return QString();
}
int main(int argc, char *argv[])
{
argList::validOptions.insert("ybl", "scalar");
argList::validOptions.insert("Cbl", "scalar");
argList::validOptions.insert("writenut", "");
# include "setRootCase.H"
# include "createTime.H"
# include "createMesh.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
Info<< "Reading field U\n" << endl;
volVectorField U
(
IOobject
(
"U",
runTime.timeName(),
mesh,
IOobject::MUST_READ,
IOobject::NO_WRITE
),
mesh
);
# include "createPhi.H"
Info<< "Calculating wall distance field" << endl;
volScalarField y = wallDist(mesh).y();
// Set the mean boundary-layer thickness
dimensionedScalar ybl("ybl", dimLength, 0);
if (args.options().found("ybl"))
{
// If the boundary-layer thickness is provided use it
ybl.value() = readScalar(IStringStream(args.options()["ybl"])());
}
else if (args.options().found("Cbl"))
{
// Calculate boundary layer thickness as Cbl * mean distance to wall
ybl.value() =
gAverage(y)*readScalar(IStringStream(args.options()["Cbl"])());
}
else
{
FatalErrorIn(args.executable())
<< "Neither option 'ybl' or 'Cbl' have been provided to calculate"
" the boundary-layer thickness"
<< exit(FatalError);
}
Info<< "\nCreating boundary-layer for U of thickness "
<< ybl.value() << " m" << nl << endl;
// Modify velocity by applying a 1/7th power law boundary-layer
// u/U0 = (y/ybl)^(1/7)
// assumes U0 is the same as the current cell velocity
scalar yblv = ybl.value();
forAll(U, celli)
{
if (y[celli] <= yblv)
{
U[celli] *= ::pow(y[celli]/yblv, (1.0/7.0));
}
}
Info<< "Writing U" << endl;
U.write();
// Update/re-write phi
phi = fvc::interpolate(U) & mesh.Sf();
phi.write();
// Set turbulence constants
dimensionedScalar kappa("kappa", dimless, 0.4187);
dimensionedScalar Cmu("Cmu", dimless, 0.09);
// Read and modify turbulence fields if present
IOobject epsilonHeader
(
"epsilon",
runTime.timeName(),
mesh,
IOobject::MUST_READ
);
IOobject kHeader
(
"k",
runTime.timeName(),
mesh,
IOobject::MUST_READ
);
IOobject nuTildaHeader
(
"nuTilda",
runTime.timeName(),
mesh,
IOobject::MUST_READ
);
// First calculate nut
volScalarField nut
(
"nut",
sqr(kappa*min(y, ybl))*::sqrt(2)*mag(dev(symm(fvc::grad(U))))
);
if (args.options().found("writenut"))
{
Info<< "Writing nut" << endl;
nut.write();
}
// Read and modify turbulence fields if present
if (nuTildaHeader.headerOk())
{
Info<< "Reading field nuTilda\n" << endl;
volScalarField nuTilda(nuTildaHeader, mesh);
nuTilda = nut;
nuTilda.correctBoundaryConditions();
Info<< "Writing nuTilda\n" << endl;
nuTilda.write();
}
if (kHeader.headerOk() && epsilonHeader.headerOk())
{
Info<< "Reading field k\n" << endl;
volScalarField k(kHeader, mesh);
Info<< "Reading field epsilon\n" << endl;
volScalarField epsilon(epsilonHeader, mesh);
scalar ck0 = ::pow(Cmu.value(), 0.25)*kappa.value();
k = sqr(nut/(ck0*min(y, ybl)));
k.correctBoundaryConditions();
scalar ce0 = ::pow(Cmu.value(), 0.75)/kappa.value();
epsilon = ce0*k*sqrt(k)/min(y, ybl);
epsilon.correctBoundaryConditions();
Info<< "Writing k\n" << endl;
k.write();
Info<< "Writing epsilon\n" << endl;
epsilon.write();
}
Info<< nl << "ExecutionTime = " << runTime.elapsedCpuTime() << " s"
<< " ClockTime = " << runTime.elapsedClockTime() << " s"
<< nl << endl;
Info<< "End\n" << endl;
return(0);
}
Foam::tmp<Foam::scalarField>
Foam::incompressibleTurbulenceModel::mut(const label patchi) const
{
return nut(patchi);
}
Foam::tmp<Foam::volScalarField>
Foam::incompressibleTurbulenceModel::mut() const
{
return nut();
}
