/*! \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(); }