diff --git a/src/turbulenceModels/incompressible/RAS/Make/files b/src/turbulenceModels/incompressible/RAS/Make/files index 9eba12e34..b0f1a0944 100644 --- a/src/turbulenceModels/incompressible/RAS/Make/files +++ b/src/turbulenceModels/incompressible/RAS/Make/files @@ -32,12 +32,14 @@ $(nutWallFunctions)/nutSpalartAllmarasWallFunction/nutSpalartAllmarasWallFunctio $(nutWallFunctions)/nutSpalartAllmarasStandardWallFunction/nutSpalartAllmarasStandardWallFunctionFvPatchScalarField.C $(nutWallFunctions)/nutSpalartAllmarasStandardRoughWallFunction/nutSpalartAllmarasStandardRoughWallFunctionFvPatchScalarField.C $(nutWallFunctions)/nutLowReWallFunction/nutLowReWallFunctionFvPatchScalarField.C +$(nutWallFunctions)/nutCWTWallFunction/nutCWTWallFunctionFvPatchScalarField.C epsilonWallFunctions = $(wallFunctions)/epsilonWallFunctions $(epsilonWallFunctions)/epsilonWallFunction/epsilonWallFunctionFvPatchScalarField.C omegaWallFunctions = $(wallFunctions)/omegaWallFunctions $(omegaWallFunctions)/omegaWallFunction/omegaWallFunctionFvPatchScalarField.C +$(omegaWallFunctions)/omegaCWTWallFunction/omegaCWTWallFunctionFvPatchScalarField.C kqRWallFunctions = $(wallFunctions)/kqRWallFunctions $(kqRWallFunctions)/kqRWallFunction/kqRWallFunctionFvPatchFields.C diff --git a/src/turbulenceModels/incompressible/RAS/derivedFvPatchFields/wallFunctions/nutWallFunctions/nutCWTWallFunction/nutCWTWallFunctionFvPatchScalarField.C b/src/turbulenceModels/incompressible/RAS/derivedFvPatchFields/wallFunctions/nutWallFunctions/nutCWTWallFunction/nutCWTWallFunctionFvPatchScalarField.C new file mode 100644 index 000000000..c6f33360d --- /dev/null +++ b/src/turbulenceModels/incompressible/RAS/derivedFvPatchFields/wallFunctions/nutWallFunctions/nutCWTWallFunction/nutCWTWallFunctionFvPatchScalarField.C @@ -0,0 +1,335 @@ +/*---------------------------------------------------------------------------*\ + ========= | + \\ / F ield | foam-extend: Open Source CFD + \\ / O peration | Version: 4.0 + \\ / A nd | Web: http://www.foam-extend.org + \\/ M anipulation | For copyright notice see file Copyright +------------------------------------------------------------------------------- +License + This file is part of foam-extend. + + foam-extend 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. + + foam-extend 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 foam-extend. If not, see . + +\*---------------------------------------------------------------------------*/ + +#include "nutCWTWallFunctionFvPatchScalarField.H" +#include "RASModel.H" +#include "fvPatchFieldMapper.H" +#include "volFields.H" +#include "addToRunTimeSelectionTable.H" + +// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // + +namespace Foam +{ +namespace incompressible +{ +namespace RASModels +{ + +// * * * * * * * * * * * * Protected Member Functions * * * * * * * * * * * // + +void nutCWTWallFunctionFvPatchScalarField::checkType() +{ + if (!patch().isWall()) + { + FatalErrorIn("nutCWTWallFunctionFvPatchScalarField::checkType()") + << "Invalid wall function specification" << nl + << " Patch type for patch " << patch().name() + << " must be wall" << nl + << " Current patch type is " << patch().type() << nl << endl + << abort(FatalError); + } +} + + +scalar nutCWTWallFunctionFvPatchScalarField::calcYPlusLam +( + const scalar kappa, + const scalar E +) const +{ + scalar ypl = 11.0; + + for (int i = 0; i < 10; i++) + { + ypl = log(E*ypl)/kappa; + } + + return ypl; +} + + +tmp nutCWTWallFunctionFvPatchScalarField::calcNut() const +{ + const label patchI = patch().index(); + + const RASModel& rasModel = db().lookupObject("RASProperties"); + const scalarField& y = rasModel.y()[patchI]; + const tmp tk = rasModel.k(); + const volScalarField& k = tk(); + const scalarField& nuw = rasModel.nu().boundaryField()[patchI]; + + const scalar Cmu25 = pow(Cmu_, 0.25); + + // Get normals + const vectorField n = patch().nf(); + + // Patch velocity field at this wall + const fvPatchVectorField& Uw = + lookupPatchField(UName_); + + const scalarField magGradUw = mag(Uw.snGrad()); + const vectorField UwIn = Uw.patchInternalField(); + + // Patch internal velocity field tangential to the wall + const vectorField UwInTang = UwIn - (UwIn & n)*n; + const scalarField magUwInTang = mag(UwInTang); + + // Calculate tangential direction for patch cells + const vectorField tDir = UwInTang/magUwInTang; + + // Wall-velocity vector field tangential to the wall + const vectorField UwTang = Uw - (Uw & n)*n; + const scalarField magUwTang = mag(UwTang); + + + // Pressure terms + const volScalarField& p = + this->dimensionedInternalField().mesh().lookupObject + < + volScalarField + >(pName_); + + // Pressure gradient + const volVectorField gradp = fvc::grad(p); + + // Pressure gradient in wall adjacent cell + const vectorField gradPIn = + gradp.boundaryField()[this->patch().index()].patchInternalField(); + + // Pressure gradient projected on the wall parallel velocity + const scalarField gradpTang= gradPIn & tDir; + + + // Convective terms + const volVectorField& U = + this->dimensionedInternalField().mesh().lookupObject + < + volVectorField + >(UName_); + + const surfaceScalarField& phi = + this->dimensionedInternalField().mesh().lookupObject + < + surfaceScalarField + >("phi"); + + const volVectorField convection = fvc::div(phi, U); + + const vectorField convectionIn = + convection.boundaryField()[this->patch().index()].patchInternalField(); + + // Convection term projected on the wall parallel velocity + const scalarField convectionTang = convectionIn & tDir; + + tmp tnutw(new scalarField(patch().size())); + scalarField& nutw = tnutw(); + + // Get face cells + const unallocLabelList& fc = patch().faceCells(); + + forAll(nutw, faceI) + { + const label faceCellI = fc[faceI]; + const scalar uStar = Cmu25*sqrt(k[faceCellI]); + + // Note: here yPlus is actually yStar + const scalar yPlus = uStar*y[faceI]/nuw[faceI]; + + // Relative tangential velocity + const scalar magUrel = magUwInTang[faceI] - magUwTang[faceI]; + + const scalar Cu = convectionTang[faceI] + gradpTang[faceI]; + const scalar Psi = 1.0 - Cu/(kappa_*uStar*magGradUw[faceI]); + + const scalar tauwVis = nuw[faceI]*magGradUw[faceI]; + const scalar tauwLog = kappa_*uStar*magUrel*Psi/log(E_*yPlus); + + // Kader blending + const scalar gamma = -0.01*pow(yPlus, 4)/(1.0 + 5.0*yPlus); + const scalar tauw = tauwVis*exp(gamma) + tauwLog*exp(1.0/gamma); + + nutw[faceI] = tauw/magGradUw[faceI] - nuw[faceI]; + } + + return tnutw; +} + + +void nutCWTWallFunctionFvPatchScalarField::writeLocalEntries(Ostream& os) const +{ + writeEntryIfDifferent(os, "U", "U", UName_); + writeEntryIfDifferent(os, "p", "p", pName_); + writeEntryIfDifferent(os, "nut", "nut", nutName_); + os.writeKeyword("Cmu") << Cmu_ << token::END_STATEMENT << nl; + os.writeKeyword("kappa") << kappa_ << token::END_STATEMENT << nl; + os.writeKeyword("E") << E_ << token::END_STATEMENT << nl; +} + + +// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * // + +nutCWTWallFunctionFvPatchScalarField::nutCWTWallFunctionFvPatchScalarField +( + const fvPatch& p, + const DimensionedField& iF +) +: + fixedValueFvPatchScalarField(p, iF), + UName_("U"), + pName_("p"), + nutName_("nut"), + Cmu_(0.09), + kappa_(0.41), + E_(9.8), + yPlusLam_(calcYPlusLam(kappa_, E_)) +{ + checkType(); +} + + +nutCWTWallFunctionFvPatchScalarField::nutCWTWallFunctionFvPatchScalarField +( + const fvPatch& p, + const DimensionedField& iF, + const dictionary& dict +) +: + fixedValueFvPatchScalarField(p, iF, dict), + UName_(dict.lookupOrDefault("U", "U")), + pName_(dict.lookupOrDefault("p", "p")), + nutName_(dict.lookupOrDefault("nut", "nut")), + Cmu_(dict.lookupOrDefault("Cmu", 0.09)), + kappa_(dict.lookupOrDefault("kappa", 0.41)), + E_(dict.lookupOrDefault("E", 9.8)), + yPlusLam_(calcYPlusLam(kappa_, E_)) +{ + checkType(); +} + + +nutCWTWallFunctionFvPatchScalarField::nutCWTWallFunctionFvPatchScalarField +( + const nutCWTWallFunctionFvPatchScalarField& ptf, + const fvPatch& p, + const DimensionedField& iF, + const fvPatchFieldMapper& mapper +) +: + fixedValueFvPatchScalarField(ptf, p, iF, mapper), + UName_(ptf.UName_), + pName_(ptf.pName_), + nutName_(ptf.nutName_), + Cmu_(ptf.Cmu_), + kappa_(ptf.kappa_), + E_(ptf.E_), + yPlusLam_(ptf.yPlusLam_) +{ + checkType(); +} + + +nutCWTWallFunctionFvPatchScalarField::nutCWTWallFunctionFvPatchScalarField +( + const nutCWTWallFunctionFvPatchScalarField& wfpsf +) +: + fixedValueFvPatchScalarField(wfpsf), + UName_(wfpsf.UName_), + pName_(wfpsf.pName_), + nutName_(wfpsf.nutName_), + Cmu_(wfpsf.Cmu_), + kappa_(wfpsf.kappa_), + E_(wfpsf.E_), + yPlusLam_(wfpsf.yPlusLam_) +{ + checkType(); +} + + +nutCWTWallFunctionFvPatchScalarField::nutCWTWallFunctionFvPatchScalarField +( + const nutCWTWallFunctionFvPatchScalarField& wfpsf, + const DimensionedField& iF +) +: + fixedValueFvPatchScalarField(wfpsf, iF), + UName_(wfpsf.UName_), + pName_(wfpsf.pName_), + nutName_(wfpsf.nutName_), + Cmu_(wfpsf.Cmu_), + kappa_(wfpsf.kappa_), + E_(wfpsf.E_), + yPlusLam_(wfpsf.yPlusLam_) +{ + checkType(); +} + + +// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * // + +void nutCWTWallFunctionFvPatchScalarField::updateCoeffs() +{ + operator==(calcNut()); + + fixedValueFvPatchScalarField::updateCoeffs(); +} + + +tmp nutCWTWallFunctionFvPatchScalarField::yPlus() const +{ + const label patchI = patch().index(); + + const RASModel& rasModel = db().lookupObject("RASProperties"); + const scalarField& y = rasModel.y()[patchI]; + + const tmp tk = rasModel.k(); + const volScalarField& k = tk(); + const scalarField kwc = k.boundaryField()[patchI].patchInternalField(); + const scalarField& nuw = rasModel.nu().boundaryField()[patchI]; + + return pow(Cmu_, 0.25)*y*sqrt(kwc)/nuw; +} + + +void nutCWTWallFunctionFvPatchScalarField::write(Ostream& os) const +{ + fvPatchField::write(os); + writeLocalEntries(os); + writeEntry("value", os); +} + + +// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // + +makePatchTypeField(fvPatchScalarField, nutCWTWallFunctionFvPatchScalarField); + +// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // + +} // End namespace RASModels +} // End namespace incompressible +} // End namespace Foam + +// ************************************************************************* // diff --git a/src/turbulenceModels/incompressible/RAS/derivedFvPatchFields/wallFunctions/nutWallFunctions/nutCWTWallFunction/nutCWTWallFunctionFvPatchScalarField.H b/src/turbulenceModels/incompressible/RAS/derivedFvPatchFields/wallFunctions/nutWallFunctions/nutCWTWallFunction/nutCWTWallFunctionFvPatchScalarField.H new file mode 100644 index 000000000..14880b673 --- /dev/null +++ b/src/turbulenceModels/incompressible/RAS/derivedFvPatchFields/wallFunctions/nutWallFunctions/nutCWTWallFunction/nutCWTWallFunctionFvPatchScalarField.H @@ -0,0 +1,215 @@ +/*---------------------------------------------------------------------------*\ + ========= | + \\ / F ield | foam-extend: Open Source CFD + \\ / O peration | Version: 4.0 + \\ / A nd | Web: http://www.foam-extend.org + \\/ M anipulation | For copyright notice see file Copyright +------------------------------------------------------------------------------- +License + This file is part of foam-extend. + + foam-extend 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. + + foam-extend 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 foam-extend. If not, see . + +Class + Foam::incompressible::RASModels::nutCWTWallFunctionFvPatchScalarField + +Description + Improved boundary condition for turbulent (kinematic) viscosity, taking into + account non-equilibrium effects and are sensitive to flow unsteadiness and + presence of the pressure gradient. + + Reference (bibtex entry): + + @article{popovacHanjalic2007, + author = {Popovac, M. and Hanjali\'{c}, K.,} + title = {{Compound Wall Treatment for RANS Computation of Complex + Turbulent Flows and Heat Transfer}}, + journal = {Flow Turbulence Combust}, + year = {2007}, + pages = {78--177} + DOI = {10.1007/s10494-006-9067-x} + } + +SourceFiles + nutCWTWallFunctionFvPatchScalarField.C + +Author + Filip Sutalo, FMENA Zagreb. All rights reserved. + +\*---------------------------------------------------------------------------*/ + +#ifndef nutCWTWallFunctionFvPatchScalarField_H +#define nutCWTWallFunctionFvPatchScalarField_H + +#include "fixedValueFvPatchFields.H" + +// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // + +namespace Foam +{ +namespace incompressible +{ +namespace RASModels +{ + +/*---------------------------------------------------------------------------*\ + Class nutCWTWallFunctionFvPatchScalarField Declaration +\*---------------------------------------------------------------------------*/ + +class nutCWTWallFunctionFvPatchScalarField +: + public fixedValueFvPatchScalarField +{ +protected: + + // Protected data + + //- Name of velocity field + word UName_; + + //- Name of pressure field + word pName_; + + //- Name of eddy viscosity field + word nutName_; + + //- Name of omega field + word omegaName_; + + //- Cmu coefficient + scalar Cmu_; + + //- Von Karman constant + scalar kappa_; + + //- E coefficient + scalar E_; + + //- Y+ at the edge of the laminar sublayer + scalar yPlusLam_; + + + // Protected member functions + + //- Check the type of the patch + virtual void checkType(); + + //- Calculate the Y+ at the edge of the laminar sublayer + virtual scalar calcYPlusLam(const scalar kappa, const scalar E) const; + + //- Calculate the turbulence viscosity + virtual tmp calcNut() const; + + //- Write local wall function variables + virtual void writeLocalEntries(Ostream&) const; + + +public: + + //- Runtime type information + TypeName("nutCWTWallTreatment"); + + + // Constructors + + //- Construct from patch and internal field + nutCWTWallFunctionFvPatchScalarField + ( + const fvPatch&, + const DimensionedField& + ); + + //- Construct from patch, internal field and dictionary + nutCWTWallFunctionFvPatchScalarField + ( + const fvPatch&, + const DimensionedField&, + const dictionary& + ); + + //- Construct by mapping given + // nutCWTWallFunctionFvPatchScalarField + // onto a new patch + nutCWTWallFunctionFvPatchScalarField + ( + const nutCWTWallFunctionFvPatchScalarField&, + const fvPatch&, + const DimensionedField&, + const fvPatchFieldMapper& + ); + + //- Construct as copy + nutCWTWallFunctionFvPatchScalarField + ( + const nutCWTWallFunctionFvPatchScalarField& + ); + + //- Construct and return a clone + virtual tmp clone() const + { + return tmp + ( + new nutCWTWallFunctionFvPatchScalarField(*this) + ); + } + + //- Construct as copy setting internal field reference + nutCWTWallFunctionFvPatchScalarField + ( + const nutCWTWallFunctionFvPatchScalarField&, + const DimensionedField& + ); + + //- Construct and return a clone setting internal field reference + virtual tmp clone + ( + const DimensionedField& iF + ) const + { + return tmp + ( + new nutCWTWallFunctionFvPatchScalarField(*this, iF) + ); + } + + + // Member functions + + // Evaluation functions + + //- Calculate and return the yPlus at the boundary + virtual tmp yPlus() const; + + //- Update the coefficients associated with the patch field + virtual void updateCoeffs(); + + + // I-O + + //- Write + virtual void write(Ostream&) const; +}; + + +// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // + +} // End namespace RASModels +} // End namespace incompressible +} // End namespace Foam + +// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // + +#endif + +// ************************************************************************* // diff --git a/src/turbulenceModels/incompressible/RAS/derivedFvPatchFields/wallFunctions/omegaWallFunctions/omegaCWTWallFunction/omegaCWTWallFunctionFvPatchScalarField.C b/src/turbulenceModels/incompressible/RAS/derivedFvPatchFields/wallFunctions/omegaWallFunctions/omegaCWTWallFunction/omegaCWTWallFunctionFvPatchScalarField.C new file mode 100644 index 000000000..9cacb7eb0 --- /dev/null +++ b/src/turbulenceModels/incompressible/RAS/derivedFvPatchFields/wallFunctions/omegaWallFunctions/omegaCWTWallFunction/omegaCWTWallFunctionFvPatchScalarField.C @@ -0,0 +1,337 @@ +/*---------------------------------------------------------------------------*\ + ========= | + \\ / F ield | foam-extend: Open Source CFD + \\ / O peration | Version: 3.2 + \\ / A nd | Web: http://www.foam-extend.org + \\/ M anipulation | For copyright notice see file Copyright +------------------------------------------------------------------------------- +License + This file is part of foam-extend. + + foam-extend 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. + + foam-extend 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 foam-extend. If not, see . + +\*---------------------------------------------------------------------------*/ + +#include "omegaCWTWallFunctionFvPatchScalarField.H" +#include "RASModel.H" +#include "fvPatchFieldMapper.H" +#include "volFields.H" +#include "addToRunTimeSelectionTable.H" + +// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // + +namespace Foam +{ +namespace incompressible +{ +namespace RASModels +{ + +// * * * * * * * * * * * * * Private Member Functions * * * * * * * * * * * // + +void omegaCWTWallFunctionFvPatchScalarField::checkType() +{ + if (!patch().isWall()) + { + FatalErrorIn("omegaCWTWallFunctionFvPatchScalarField::checkType()") + << "Invalid wall function specification" << nl + << " Patch type for patch " << patch().name() + << " must be wall" << nl + << " Current patch type is " << patch().type() << nl << endl + << abort(FatalError); + } +} + + +// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * // + +omegaCWTWallFunctionFvPatchScalarField::omegaCWTWallFunctionFvPatchScalarField +( + const fvPatch& p, + const DimensionedField& iF +) +: + fixedInternalValueFvPatchField(p, iF), + pName_("p"), + UName_("U"), + kName_("k"), + GName_("RASModel::G"), + nuName_("nu"), + nutName_("nut"), + Cmu_(0.09), + kappa_(0.41), + E_(9.8), + beta1_(0.075) +{ + checkType(); +} + + +omegaCWTWallFunctionFvPatchScalarField::omegaCWTWallFunctionFvPatchScalarField +( + const omegaCWTWallFunctionFvPatchScalarField& ptf, + const fvPatch& p, + const DimensionedField& iF, + const fvPatchFieldMapper& mapper +) +: + fixedInternalValueFvPatchField(ptf, p, iF, mapper), + pName_(ptf.pName_), + UName_(ptf.UName_), + kName_(ptf.kName_), + GName_(ptf.GName_), + nuName_(ptf.nuName_), + nutName_(ptf.nutName_), + Cmu_(ptf.Cmu_), + kappa_(ptf.kappa_), + E_(ptf.E_), + beta1_(ptf.beta1_) +{ + checkType(); +} + + +omegaCWTWallFunctionFvPatchScalarField::omegaCWTWallFunctionFvPatchScalarField +( + const fvPatch& p, + const DimensionedField& iF, + const dictionary& dict +) +: + fixedInternalValueFvPatchField(p, iF, dict), + pName_(dict.lookupOrDefault("p", "p")), + UName_(dict.lookupOrDefault("U", "U")), + kName_(dict.lookupOrDefault("k", "k")), + GName_(dict.lookupOrDefault("G", "RASModel::G")), + nuName_(dict.lookupOrDefault("nu", "nu")), + nutName_(dict.lookupOrDefault("nut", "nut")), + Cmu_(dict.lookupOrDefault("Cmu", 0.09)), + kappa_(dict.lookupOrDefault("kappa", 0.41)), + E_(dict.lookupOrDefault("E", 9.8)), + beta1_(dict.lookupOrDefault("beta1", 0.075)) +{ + checkType(); +} + + +omegaCWTWallFunctionFvPatchScalarField::omegaCWTWallFunctionFvPatchScalarField +( + const omegaCWTWallFunctionFvPatchScalarField& owfpsf +) +: + fixedInternalValueFvPatchField(owfpsf), + pName_(owfpsf.pName_), + UName_(owfpsf.UName_), + kName_(owfpsf.kName_), + GName_(owfpsf.GName_), + nuName_(owfpsf.nuName_), + nutName_(owfpsf.nutName_), + Cmu_(owfpsf.Cmu_), + kappa_(owfpsf.kappa_), + E_(owfpsf.E_), + beta1_(owfpsf.beta1_) +{ + checkType(); +} + + +omegaCWTWallFunctionFvPatchScalarField::omegaCWTWallFunctionFvPatchScalarField +( + const omegaCWTWallFunctionFvPatchScalarField& owfpsf, + const DimensionedField& iF +) +: + fixedInternalValueFvPatchField(owfpsf, iF), + pName_(owfpsf.pName_), + UName_(owfpsf.UName_), + kName_(owfpsf.kName_), + GName_(owfpsf.GName_), + nuName_(owfpsf.nuName_), + nutName_(owfpsf.nutName_), + Cmu_(owfpsf.Cmu_), + kappa_(owfpsf.kappa_), + E_(owfpsf.E_), + beta1_(owfpsf.beta1_) +{ + checkType(); +} + + +// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * // + +void omegaCWTWallFunctionFvPatchScalarField::updateCoeffs() +{ + if (updated()) + { + return; + } + + // If G field is not present, execute zero gradient evaluation + // HJ, 20/Mar/2011 + if (!db().foundObject(GName_)) + { + InfoIn("void omegaCWTWallFunctionFvPatchScalarField::updateCoeffs()") + << "Cannot access " << GName_ << " field for patch " + << patch().name() << ". Evaluating as zeroGradient" + << endl; + + fvPatchScalarField::updateCoeffs(); + zeroGradientFvPatchScalarField::evaluate(); + + return; + } + + const RASModel& rasModel = db().lookupObject("RASProperties"); + const scalarField& y = rasModel.y()[patch().index()]; + + const scalar Cmu25 = pow(Cmu_, 0.25); + + volScalarField& G = const_cast + (db().lookupObject(GName_)); + + // Note: omega is now a refValue and set in fixedInternalValueFvPatchField + // HJ, 3/Aug/2011 + scalarField& omega = refValue(); + + const scalarField& k = db().lookupObject(kName_); + + const scalarField& nuw = + lookupPatchField(nuName_); + + const scalarField& nutw = + lookupPatchField(nutName_); + + // Velocity field at the patch + const fvPatchVectorField& Uw = + lookupPatchField(UName_); + + // Patch normals + const vectorField n = patch().nf(); + + // Velocity patch internal field + const vectorField UwIn = Uw.patchInternalField(); + + // Velocity vector tangential to the wall + const vectorField UwInTang = UwIn - (UwIn & n)*n; + const scalarField magUwInTang = mag(UwInTang); + + // Calculate tangential direction for patch cells + const vectorField tDir = UwInTang/magUwInTang; + + // Magnitude of the surface normal gradient velocity + const scalarField magGradUw = mag(Uw.snGrad()); + + // Pressure effects + const volScalarField& p = + this->dimensionedInternalField().mesh().lookupObject + (pName_); + + // Pressure gradient + const volVectorField gradp = fvc::grad(p); + + // Pressure gradient in wall adjacent cell + const vectorField gradPIn = + gradp.boundaryField()[this->patch().index()].patchInternalField(); + + // Pressure gradient projected on the wall parallel velocity + const scalarField gradpTang= gradPIn & tDir; + + // Convective terms + const volVectorField& U = + this->dimensionedInternalField().mesh().lookupObject + < + volVectorField + >(UName_); + + const surfaceScalarField& phi = + this->dimensionedInternalField().mesh().lookupObject + < + surfaceScalarField + >("phi"); + + const volVectorField convection = fvc::div(phi, U); + + const vectorField convectionIn = + convection.boundaryField()[this->patch().index()].patchInternalField(); + + // Convection term projected on the wall parallel velocity + const scalarField convectionTang = convectionIn & tDir; + + // Get face cells + const unallocLabelList& fc = patch().faceCells(); + + // Set omega and G + forAll(nutw, faceI) + { + const label faceCellI = fc[faceI]; + const scalar uStar= Cmu25*sqrt(k[faceCellI]); + + // Note: here yPlus is actually yStar + const scalar yPlus = uStar*y[faceI]/nuw[faceI]; + + const scalar Cu = convectionTang[faceI] + gradpTang[faceI]; + const scalar Psi = 1.0 - Cu/(kappa_*uStar*magGradUw[faceI]); + + // Kader blend for velocity gradient + const scalar gamma = -0.01*pow(yPlus, 4)/(1.0 + 5.0*yPlus); + const scalar gammaEps = - 0.001*pow(yPlus, 4)/(1.0 + yPlus); + + const scalar omegaVis = 6.0*nuw[faceI]/(beta1_*sqr(y[faceI])); + const scalar omegaLog = sqrt(k[faceCellI])/(Cmu25*kappa_*y[faceI]); + + // Menter blend for omega + omega[faceI] = omegaVis*exp(gammaEps) + omegaLog*exp(1.0/gammaEps); + + const scalar Gvis = k[faceCellI]*sqr(magGradUw[faceI])/omega[faceI]; + const scalar Glog = pow(uStar, 3)/(Psi*kappa_*y[faceI]); + + G[faceCellI]= Gvis*exp(gamma) + Glog*exp(1.0/gamma); + } + + // TODO: perform averaging for cells sharing more than one boundary face + + fixedInternalValueFvPatchField::updateCoeffs(); +} + +void omegaCWTWallFunctionFvPatchScalarField::write(Ostream& os) const +{ + fixedInternalValueFvPatchField::write(os); + writeEntryIfDifferent(os, "U", "U", UName_); + writeEntryIfDifferent(os, "p", "p", pName_); + writeEntryIfDifferent(os, "k", "k", kName_); + writeEntryIfDifferent(os, "G", "RASModel::G", GName_); + writeEntryIfDifferent(os, "nu", "nu", nuName_); + writeEntryIfDifferent(os, "nut", "nut", nutName_); + os.writeKeyword("Cmu") << Cmu_ << token::END_STATEMENT << nl; + os.writeKeyword("kappa") << kappa_ << token::END_STATEMENT << nl; + os.writeKeyword("E") << E_ << token::END_STATEMENT << nl; + os.writeKeyword("beta1") << beta1_ << token::END_STATEMENT << nl; +} + + +// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // + +makePatchTypeField +( + fvPatchScalarField, + omegaCWTWallFunctionFvPatchScalarField +); + +// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // + +} // End namespace RASModels +} // End namespace incompressible +} // End namespace Foam + +// ************************************************************************* // diff --git a/src/turbulenceModels/incompressible/RAS/derivedFvPatchFields/wallFunctions/omegaWallFunctions/omegaCWTWallFunction/omegaCWTWallFunctionFvPatchScalarField.H b/src/turbulenceModels/incompressible/RAS/derivedFvPatchFields/wallFunctions/omegaWallFunctions/omegaCWTWallFunction/omegaCWTWallFunctionFvPatchScalarField.H new file mode 100644 index 000000000..47bca6c6c --- /dev/null +++ b/src/turbulenceModels/incompressible/RAS/derivedFvPatchFields/wallFunctions/omegaWallFunctions/omegaCWTWallFunction/omegaCWTWallFunctionFvPatchScalarField.H @@ -0,0 +1,207 @@ +/*---------------------------------------------------------------------------*\ + ========= | + \\ / F ield | foam-extend: Open Source CFD + \\ / O peration | Version: 4.0 + \\ / A nd | Web: http://www.foam-extend.org + \\/ M anipulation | For copyright notice see file Copyright +------------------------------------------------------------------------------- +License + This file is part of foam-extend. + + foam-extend 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. + + foam-extend 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 foam-extend. If not, see . + +Class + Foam::incompressible::RASModels::omegaCWTWallFunctionFvPatchScalarField + +Description + Improved boundary condition for specific dissipation, taking into account + non-equilibrium effects and are sensitive to flow unsteadiness and presence + of the pressure gradient. + + Reference (bibtex entry): + + @article{popovacHanjalic2007, + author = {Popovac, M. and Hanjali\'{c}, K.,} + title = {{Compound Wall Treatment for RANS Computation of Complex + Turbulent Flows and Heat Transfer}}, + journal = {Flow Turbulence Combust}, + year = {2007}, + pages = {78--177} + DOI = {10.1007/s10494-006-9067-x} + } + +SourceFiles + omegaCWTWallFunctionFvPatchScalarField.C + +Author + Filip Sutalo, FMENA Zagreb. All rights reserved. + +\*---------------------------------------------------------------------------*/ + +#ifndef omegaCWTWallFunctionFvPatchScalarField_H +#define omegaCWTWallFunctionFvPatchScalarField_H + +#include "fixedInternalValueFvPatchFields.H" + +// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // + +namespace Foam +{ +namespace incompressible +{ +namespace RASModels +{ + +/*---------------------------------------------------------------------------*\ + Class omegaCWTWallFunctionFvPatchScalarField Declaration +\*---------------------------------------------------------------------------*/ + +class omegaCWTWallFunctionFvPatchScalarField +: + public fixedInternalValueFvPatchScalarField +{ + // Private data + + //- Name of pressure field + word pName_; + + //- Name of velocity field + word UName_; + + //- Name of turbulence kinetic energy field + word kName_; + + //- Name of turbulence generation field + word GName_; + + //- Name of laminar viscosity field + word nuName_; + + //- Name of turbulent viscosity field + word nutName_; + + //- Cmu coefficient + scalar Cmu_; + + //- Von Karman constant + scalar kappa_; + + //- E coefficient + scalar E_; + + //- beta1 coefficient + scalar beta1_; + + + // Private member functions + + //- Check the type of the patch + void checkType(); + + +public: + + //- Runtime type information + TypeName("omegaCWTWallTreatment"); + + + // Constructors + + //- Construct from patch and internal field + omegaCWTWallFunctionFvPatchScalarField + ( + const fvPatch&, + const DimensionedField& + ); + + //- Construct from patch, internal field and dictionary + omegaCWTWallFunctionFvPatchScalarField + ( + const fvPatch&, + const DimensionedField&, + const dictionary& + ); + + //- Construct by mapping given + // omegaCWTWallFunctionFvPatchScalarField + // onto a new patch + omegaCWTWallFunctionFvPatchScalarField + ( + const omegaCWTWallFunctionFvPatchScalarField&, + const fvPatch&, + const DimensionedField&, + const fvPatchFieldMapper& + ); + + //- Construct as copy + omegaCWTWallFunctionFvPatchScalarField + ( + const omegaCWTWallFunctionFvPatchScalarField& + ); + + //- Construct and return a clone + virtual tmp clone() const + { + return tmp + ( + new omegaCWTWallFunctionFvPatchScalarField(*this) + ); + } + + //- Construct as copy setting internal field reference + omegaCWTWallFunctionFvPatchScalarField + ( + const omegaCWTWallFunctionFvPatchScalarField&, + const DimensionedField& + ); + + //- Construct and return a clone setting internal field reference + virtual tmp clone + ( + const DimensionedField& iF + ) const + { + return tmp + ( + new omegaCWTWallFunctionFvPatchScalarField(*this, iF) + ); + } + + + // Member functions + + // Evaluation functions + + //- Update the coefficients associated with the patch field + virtual void updateCoeffs(); + + + // I-O + + //- Write + void write(Ostream&) const; +}; + + +// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // + +} // End namespace RASModels +} // End namespace incompressible +} // End namespace Foam + +// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // + +#endif + +// ************************************************************************* //