zhyang-dev/openfoam
1
0
Fork 0
mirror of https://develop.openfoam.com/Development/openfoam.git synced 2025-11-28 03:28:01 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

wallDist: Add support for cached wall-reflection vectors

Browse Source 
Currently these vectors are generated at the same time as the wall-distance field
by the same run-time selected algorithm.  This will be changed so that the wall-reflection
vectors are only generated and stored if required.
This commit is contained in:
Henry
2015-01-08 16:08:53 +00:00
parent 917852b74e
commit c4804e5a0b
28 changed files with 132 additions and 1006 deletions
Download Patch File Download Diff File Expand all files Collapse all files

27
applications/solvers/multiphase/twoPhaseEulerFoam/interfacialModels/wallDependentModel/wallDependentModel.C
View File

@ -25,7 +25,6 @@ License
#include "wallDependentModel.H" #include "wallDependentModel.H"
#include "wallDist.H" #include "wallDist.H"
#include "wallDistReflection.H"
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
@ -51,31 +50,7 @@ const Foam::volScalarField& Foam::wallDependentModel::yWall() const
const Foam::volVectorField& Foam::wallDependentModel::nWall() const const Foam::volVectorField& Foam::wallDependentModel::nWall() const
{ {
if (!mesh_.foundObject<volVectorField>("nWall")) return wallDist::New(mesh_).n();
{
wallDistReflection w(mesh_);
volVectorField* nPtr
(
new volVectorField
(
IOobject
(
"nWall",
mesh_.time().timeName(),
mesh_,
IOobject::NO_READ,
IOobject::NO_WRITE,
true
),
w.n()
)
);
nPtr->checkIn();
}
return mesh_.lookupObject<volVectorField>("nWall");
} }

3
applications/test/nearWallDist-wave/Make/files
View File

@ -1,3 +0,0 @@
Test-WallDist.C
EXE = $(FOAM_USER_APPBIN)/Test-WallDist

7
applications/test/nearWallDist-wave/README
View File

@ -1,7 +0,0 @@
Test-WallDist.C:
calculate distance to wall and reflection vectors.
Test-WallDist2.C:
for debugging: same but do explicit iterations and dump every
timestep.

215
applications/test/nearWallDist-wave/Test-WallDist2.C
View File

@ -1,215 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 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/>.
Description
Wave propagation of nearwall distance through grid. Every iteration
information goes through one layer of cells.
\*---------------------------------------------------------------------------*/
#include "fvCFD.H"
#include "wallFvPatch.H"
#include "FaceCellWave.H"
#include "wallPoint.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// Main program:
int main(int argc, char *argv[])
{
# include "setRootCase.H"
# include "createTime.H"
# include "createMesh.H"
Info<< "Mesh read in = "
<< runTime.cpuTimeIncrement()
<< " s\n" << endl << endl;
Info<< "Creating field wDistNC\n" << endl;
volScalarField wallDistUncorrected
(
IOobject
(
"wDistNC",
runTime.timeName(),
mesh,
IOobject::NO_READ,
IOobject::AUTO_WRITE
),
mesh,
dimensionedScalar
(
"wallDist",
dimensionSet(0, 1, 0, 0, 0),
0.0
)
);
//
// Set initial changed faces: set wallPoint for wall faces to wall centre
//
// Count walls
label nWalls = 0;
forAll(mesh.boundary(), patchI)
{
const fvPatch& patch = mesh.boundary()[patchI];
if (isA<wallFvPatch>(patch))
{
nWalls += patch.size();
}
}
List<wallPoint> faceDist(nWalls);
labelList changedFaces(nWalls);
label nChangedFaces = 0;
forAll(mesh.boundary(), patchI)
{
const fvPatch& patch = mesh.boundary()[patchI];
if (isA<wallFvPatch>(patch))
{
forAll(patch.Cf(), patchFaceI)
{
const polyPatch& polyPatch = mesh.boundaryMesh()[patchI];
label meshFaceI = polyPatch.start() + patchFaceI;
changedFaces[nChangedFaces] = meshFaceI;
faceDist[nChangedFaces] =
wallPoint(patch.Cf()[patchFaceI], 0.0);
nChangedFaces++;
}
}
}
List<wallPoint> allFaceInfo(mesh.nFaces());
List<wallPoint> allCellInfo(mesh.nCells());
FaceCellWave<wallPoint> wallDistCalc
(
mesh,
changedFaces,
faceDist,
allFaceInfo,
allCellInfo,
0 // max iterations
);
Info<< "\nStarting time loop\n" << endl;
while (runTime.loop())
{
Info<< "Time = " << runTime.timeName() << endl;
label nCells = wallDistCalc.faceToCell();
Info<< " Total changed cells : " << nCells << endl;
if (nCells == 0)
{
break;
}
label nFaces = wallDistCalc.cellToFace();
Info<< " Total changed faces : " << nFaces << endl;
if (nFaces == 0)
{
break;
}
//
// Copy face and cell values into field
//
label nIllegal = 0;
// Copy cell values
forAll(allCellInfo, cellI)
{
scalar dist = allCellInfo[cellI].distSqr();
if (allCellInfo[cellI].valid(wallDistCalc.data()))
{
wallDistUncorrected[cellI] = Foam::sqrt(dist);
}
else
{
wallDistUncorrected[cellI] = -1;
nIllegal++;
}
}
// Copy boundary values
forAll(wallDistUncorrected.boundaryField(), patchI)
{
fvPatchScalarField& patchField =
wallDistUncorrected.boundaryField()[patchI];
forAll(patchField, patchFaceI)
{
const label meshFaceI = patchField.patch().start() + patchFaceI;
scalar dist = allFaceInfo[meshFaceI].distSqr();
if (allFaceInfo[meshFaceI].valid(wallDistCalc.data()))
{
patchField[patchFaceI] = Foam::sqrt(dist);
}
else
{
patchField[patchFaceI] = dist;
nIllegal++;
}
}
}
Info<< "nIllegal:" << nIllegal << endl;
//
// Write it
//
wallDistUncorrected.write();
Info<< "ExecutionTime = "
<< runTime.elapsedCpuTime()
<< " s\n" << endl << endl;
}
Info<< "End\n" << endl;
return 0;
}
// ************************************************************************* //

135
applications/test/nearWallDist-wave/Test-WallDistData.C
View File

@ -1,135 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 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/>.
Description
Calculate distance to wall.
\*---------------------------------------------------------------------------*/
#include "fvCFD.H"
#include "wallDistData.H"
#include "wallPointData.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// Main program:
int main(int argc, char *argv[])
{
# include "setRootCase.H"
# include "createTime.H"
# include "createMesh.H"
Info<< "Mesh read in = "
<< runTime.cpuTimeIncrement()
<< " s\n" << endl << endl;
Info<< "Time now = " << runTime.timeName() << endl;
// wall distance and reflection vectors
volVectorField n
(
IOobject
(
"n",
mesh.time().timeName(),
mesh
),
mesh,
dimensionedVector("n", dimLength, point::max)
);
// Fill wall patches with unit normal
forAll(mesh.boundary(), patchI)
{
const fvPatch& patch = mesh.boundary()[patchI];
if (isA<wallFvPatch>(patch))
{
fvPatchVectorField& wallData = n.boundaryField()[patchI];
forAll(patch.Cf(), patchFaceI)
{
wallData[patchFaceI] = patch.Cf()[patchFaceI];
wallData[patchFaceI] /= Foam::mag(wallData[patchFaceI]);
}
}
}
// Do distance calculation, transporting values of n.
wallDistData<wallPointData<vector> > y(mesh, n, true);
if (y.nUnset() != 0)
{
WarningIn(args.executable())
<< "There are " << y.nUnset()
<< " remaining unset cells and/or boundary values" << endl;
}
y.write();
y.data().write();
runTime++;
Info<< "Time now = " << runTime.timeName() << endl;
// Move points
boundBox meshBb(mesh.points());
pointField newPoints(mesh.points());
const point half(0.5*(meshBb.min() + meshBb.max()));
forAll(newPoints, pointI)
{
point& pt = newPoints[pointI];
// expand around half
pt.y() += pt.y() - half.y();
}
mesh.movePoints(newPoints);
mesh.write();
y.correct();
y.write();
y.data().write();
Info<< "End\n" << endl;
return 0;
}
// ************************************************************************* //

119
applications/test/nearWallDist-wave/Test-YPlus.C
View File

@ -1,119 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011 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/>.
Description
Calculate distance to wall.
\*---------------------------------------------------------------------------*/
#include "fvCFD.H"
#include "wallDistData.H"
#include "wallPointYPlus.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// Main program:
int main(int argc, char *argv[])
{
# include "setRootCase.H"
# include "createTime.H"
# include "createMesh.H"
Info<< "Mesh read in = "
<< runTime.cpuTimeIncrement()
<< " s\n" << endl << endl;
Info<< "Time now = " << runTime.timeName() << endl;
// wall distance and yStar
volScalarField yStar
(
IOobject
(
"yStar",
mesh.time().timeName(),
mesh
),
mesh,
dimensionedScalar("yStar", dimless, 1.0)
);
// Fill wall patches of yStar with some value.
forAll(mesh.boundary(), patchI)
{
const fvPatch& patch = mesh.boundary()[patchI];
if (isA<wallFvPatch>(patch))
{
fvPatchScalarField& wallData = yStar.boundaryField()[patchI];
forAll(patch, patchFaceI)
{
// Hack. Just some value.
wallData[patchFaceI] = 1/2500.0;
}
}
}
// Do distance calculation, transporting values of yStar
wallPointYPlus::yPlusCutOff = 200;
wallDistData<wallPointYPlus> y(mesh, yStar, true);
if (y.nUnset() != 0)
{
WarningIn(args.executable())
<< "There are " << y.nUnset()
<< " remaining unset cells and/or boundary values" << endl;
}
y.write();
y.data().write();
volScalarField yPlus
(
IOobject
(
"yPlus",
mesh.time().timeName(),
mesh
),
y/y.data()
);
yPlus.write();
Info<< "End\n" << endl;
return 0;
}
// ************************************************************************* //

3
applications/test/wallDist/Make/files Normal file
View File

@ -0,0 +1,3 @@
Test-wallDist.C
EXE = $(FOAM_USER_APPBIN)/Test-wallDist

0
applications/test/nearWallDist-wave/Make/options → applications/test/wallDist/Make/options
View File

9
applications/test/nearWallDist-wave/Test-WallDist.C → applications/test/wallDist/Test-wallDist.C
View File

@ -22,7 +22,7 @@ License
along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>. along with OpenFOAM. If not, see <http://www.gnu.org/licenses/>.
Description Description
Calculate distance to wall. Calculate and write the distance-to-wall field for a moving mesh.
\*---------------------------------------------------------------------------*/ \*---------------------------------------------------------------------------*/
@ -48,6 +48,10 @@ int main(int argc, char *argv[])
Info<< "Time now = " << runTime.timeName() << endl; Info<< "Time now = " << runTime.timeName() << endl;
// Wall-reflection vectors
const volVectorField& n = wallDist::New(mesh).n();
n.write();
// Wall distance // Wall distance
const volScalarField& y = wallDist::New(mesh).y(); const volScalarField& y = wallDist::New(mesh).y();
y.write(); y.write();
@ -74,8 +78,7 @@ int main(int argc, char *argv[])
mesh.movePoints(newPoints); mesh.movePoints(newPoints);
mesh.write(); mesh.write();
n.write();
y.correct();
y.write(); y.write();
Info<< "End\n" << endl; Info<< "End\n" << endl;

2
src/finiteVolume/Make/files
View File

@ -44,8 +44,6 @@ $(wallDist)/nearWallDist/nearWallDist.C
$(wallDist)/wallDist/wallDist.C $(wallDist)/wallDist/wallDist.C
$(wallDist)/patchDistMethods/patchDistMethod/patchDistMethod.C $(wallDist)/patchDistMethods/patchDistMethod/patchDistMethod.C
$(wallDist)/patchDistMethods/meshWave/meshWavePatchDistMethod.C $(wallDist)/patchDistMethods/meshWave/meshWavePatchDistMethod.C
$(wallDist)/wallDistReflection/reflectionVectors.C
$(wallDist)/wallDistReflection/wallDistReflection.C
fvMeshMapper = fvMesh/fvMeshMapper fvMeshMapper = fvMesh/fvMeshMapper

56
src/finiteVolume/fvMesh/wallDist/patchDistMethods/meshWave/meshWavePatchDistMethod.C
View File

@ -27,6 +27,8 @@ License
#include "fvMesh.H" #include "fvMesh.H"
#include "volFields.H" #include "volFields.H"
#include "patchWave.H" #include "patchWave.H"
#include "patchDataWave.H"
#include "wallPointData.H"
#include "emptyFvPatchFields.H" #include "emptyFvPatchFields.H"
#include "addToRunTimeSelectionTable.H" #include "addToRunTimeSelectionTable.H"
@ -76,10 +78,10 @@ bool Foam::patchDistMethods::meshWave::correct(volScalarField& y)
// Calculate distance starting from patch faces // Calculate distance starting from patch faces
patchWave wave(mesh_, patchIDs_, correctWalls_); patchWave wave(mesh_, patchIDs_, correctWalls_);
// Transfer cell values from wave into *this // Transfer cell values from wave into y
y.transfer(wave.distance()); y.transfer(wave.distance());
// Transfer values on patches into boundaryField of *this // Transfer values on patches into boundaryField of y
forAll(y.boundaryField(), patchI) forAll(y.boundaryField(), patchI)
{ {
if (!isA<emptyFvPatchScalarField>(y.boundaryField()[patchI])) if (!isA<emptyFvPatchScalarField>(y.boundaryField()[patchI]))
@ -97,4 +99,54 @@ bool Foam::patchDistMethods::meshWave::correct(volScalarField& y)
} }
bool Foam::patchDistMethods::meshWave::correct
(
volScalarField& y,
volVectorField& n
)
{
// Collect pointers to data on patches
UPtrList<vectorField> patchData(mesh_.boundaryMesh().size());
forAll(n.boundaryField(), patchI)
{
patchData.set(patchI, &n.boundaryField()[patchI]);
}
// Do mesh wave
patchDataWave<wallPointData<vector> > wave
(
mesh_,
patchIDs_,
patchData,
correctWalls_
);
// Transfer cell values from wave into y and n
y.transfer(wave.distance());
n.transfer(wave.cellData());
// Transfer values on patches into boundaryField of y and n
forAll(y.boundaryField(), patchI)
{
scalarField& waveFld = wave.patchDistance()[patchI];
if (!isA<emptyFvPatchScalarField>(y.boundaryField()[patchI]))
{
y.boundaryField()[patchI].transfer(waveFld);
vectorField& wavePatchData = wave.patchData()[patchI];
n.boundaryField()[patchI].transfer(wavePatchData);
}
}
// Transfer number of unset values
nUnset_ = wave.nUnset();
return nUnset_ > 0;
}
// ************************************************************************* // // ************************************************************************* //

3
src/finiteVolume/fvMesh/wallDist/patchDistMethods/meshWave/meshWavePatchDistMethod.H
View File

@ -118,6 +118,9 @@ public:
//- Correct the given distance-to-patch field //- Correct the given distance-to-patch field
virtual bool correct(volScalarField& y); virtual bool correct(volScalarField& y);
//- Correct the given distance-to-patch and normal-to-patch fields
virtual bool correct(volScalarField& y, volVectorField& n);
}; };

53
src/finiteVolume/fvMesh/wallDist/patchDistMethods/meshWave/meshWaveWallDist.C
View File

@ -1,53 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 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 "meshWaveWallDist.H"
#include "fvMesh.H"
#include "wallPolyPatch.H"
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
Foam::meshWaveWallDist::meshWaveWallDist
(
const fvMesh& mesh,
const bool correctWalls
)
:
patchDist
(
mesh,
mesh.boundaryMesh().findPatchIDs<wallPolyPatch>(),
correctWalls
)
{}
// * * * * * * * * * * * * * * * * Destructor * * * * * * * * * * * * * * * //
Foam::meshWaveWallDist::~meshWaveWallDist()
{}
// ************************************************************************* //

91
src/finiteVolume/fvMesh/wallDist/patchDistMethods/meshWave/meshWaveWallDist.H
View File

@ -1,91 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 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::meshWaveWallDist
Description
Specialisation of patchDist for wall distance calculation
SourceFiles
meshWaveWallDist.C
\*---------------------------------------------------------------------------*/
#ifndef meshWaveWallDist_H
#define meshWaveWallDist_H
#include "patchDist.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
class fvMesh;
/*---------------------------------------------------------------------------*\
Class meshWaveWallDist Declaration
\*---------------------------------------------------------------------------*/
class meshWaveWallDist
:
public patchDist
{
// Private Member Functions
//- Disallow default bitwise copy construct
meshWaveWallDist(const meshWaveWallDist&);
//- Disallow default bitwise assignment
void operator=(const meshWaveWallDist&);
public:
// Constructors
//- Construct from mesh and flag whether or not to correct wall.
// Calculate for all cells. correctWalls : correct wall (face&point)
// cells for correct distance, searching neighbours.
meshWaveWallDist
(
const fvMesh& mesh,
const bool correctWalls = true
);
//- Destructor
virtual ~meshWaveWallDist();
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

0
src/finiteVolume/fvMesh/wallDist/wallDistReflection/wallDistData.C → src/finiteVolume/fvMesh/wallDist/patchDistMethods/meshWave/wallDistData/wallDistData.C
View File

0
src/finiteVolume/fvMesh/wallDist/wallDistReflection/wallDistData.H → src/finiteVolume/fvMesh/wallDist/patchDistMethods/meshWave/wallDistData/wallDistData.H
View File

3
src/finiteVolume/fvMesh/wallDist/patchDistMethods/patchDistMethod/patchDistMethod.H
View File

@ -138,6 +138,9 @@ public:
//- Correct the given distance-to-patch field //- Correct the given distance-to-patch field
virtual bool correct(volScalarField& y) = 0; virtual bool correct(volScalarField& y) = 0;
//- Correct the given distance-to-patch and reflection vector fields
virtual bool correct(volScalarField& y, volVectorField& n) = 0;
}; };

36
src/finiteVolume/fvMesh/wallDist/wallDist/wallDist.C
View File

@ -24,7 +24,7 @@ License
\*---------------------------------------------------------------------------*/ \*---------------------------------------------------------------------------*/
#include "wallDist.H" #include "wallDist.H"
#include "wallPolyPatch.H" #include "wallFvPatch.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * // // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
@ -58,8 +58,36 @@ Foam::wallDist::wallDist(const fvMesh& mesh)
), ),
mesh, mesh,
dimensionedScalar("yWall", dimLength, GREAT) dimensionedScalar("yWall", dimLength, GREAT)
) ),
n_(NULL)
{ {
// Temporarily always construct n
// until the demand-driven interface is complete
n_ = tmp<volVectorField>
(
new volVectorField
(
IOobject
(
"nWall",
mesh.time().timeName(),
mesh
),
mesh,
dimensionedVector("nWall", dimless, vector::zero)
)
);
const fvPatchList& patches = mesh.boundary();
forAll(patches, patchi)
{
if (isA<wallFvPatch>(patches[patchi]))
{
n_().boundaryField()[patchi] = patches[patchi].nf();
}
}
movePoints(); movePoints();
} }
@ -76,7 +104,7 @@ bool Foam::wallDist::movePoints()
{ {
if (pdm_->movePoints()) if (pdm_->movePoints())
{ {
return pdm_->correct(y_); return pdm_->correct(y_, n_());
} }
else else
{ {
@ -88,7 +116,7 @@ bool Foam::wallDist::movePoints()
void Foam::wallDist::updateMesh(const mapPolyMesh& mpm) void Foam::wallDist::updateMesh(const mapPolyMesh& mpm)
{ {
pdm_->updateMesh(mpm); pdm_->updateMesh(mpm);
pdm_->correct(y_); pdm_->correct(y_, n_());
} }

10
src/finiteVolume/fvMesh/wallDist/wallDist/wallDist.H
View File

@ -62,6 +62,9 @@ class wallDist
//- Distance-to-wall field //- Distance-to-wall field
volScalarField y_; volScalarField y_;
//- Distance-to-wall field
tmp<volVectorField> n_;
// Private Member Functions // Private Member Functions
@ -90,11 +93,18 @@ public:
// Member Functions // Member Functions
//- Return reference to cached distance-to-wall field
const volScalarField& y() const const volScalarField& y() const
{ {
return y_; return y_;
} }
//- Return reference to cached normal-to-wall field
const volVectorField& n() const
{
return n_();
}
//- Update the y-field when the mesh moves //- Update the y-field when the mesh moves
virtual bool movePoints(); virtual bool movePoints();

72
src/finiteVolume/fvMesh/wallDist/wallDistReflection/reflectionVectors.C
View File

@ -1,72 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 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 "reflectionVectors.H"
#include "wallFvPatch.H"
#include "surfaceFields.H"
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
// Construct from components
Foam::reflectionVectors::reflectionVectors(const Foam::fvMesh& mesh)
:
n_
(
IOobject
(
"reflectionVectors",
mesh.time().timeName(),
mesh
),
mesh,
dimensionedVector("n", dimless, vector::zero)
)
{
correct();
}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
void Foam::reflectionVectors::correct()
{
const fvMesh& mesh = n_.mesh();
const fvPatchList& patches = mesh.boundary();
forAll(patches, patchi)
{
// find the nearest face for every cell
if (isA<wallFvPatch>(patches[patchi]))
{
n_.boundaryField()[patchi] =
mesh.Sf().boundaryField()[patchi]
/mesh.magSf().boundaryField()[patchi];
}
}
}
// ************************************************************************* //

98
src/finiteVolume/fvMesh/wallDist/wallDistReflection/reflectionVectors.H
View File

@ -1,98 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 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::reflectionVectors
Description
Container for reflection vectors (= unit normal of nearest wall)
SourceFiles
reflectionVectors.C
\*---------------------------------------------------------------------------*/
#ifndef reflectionVectors_H
#define reflectionVectors_H
#include "volFields.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class reflectionVectors Declaration
\*---------------------------------------------------------------------------*/
class reflectionVectors
{
protected:
// Protected data
volVectorField n_;
private:
// Private Member Functions
//- Disallow default bitwise copy construct
reflectionVectors(const reflectionVectors&);
//- Disallow default bitwise assignment
void operator=(const reflectionVectors&);
public:
// Constructors
//- Construct from mesh
reflectionVectors(const fvMesh& mesh);
// Member Functions
const volVectorField& n() const
{
return n_;
}
//- Correct for mesh geom/topo changes
void correct();
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

57
src/finiteVolume/fvMesh/wallDist/wallDistReflection/wallDistReflection.C
View File

@ -1,57 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 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 "wallDistReflection.H"
// * * * * * * * * * * * * * * * * Constructors * * * * * * * * * * * * * * //
// Construct from components
Foam::wallDistReflection::wallDistReflection
(
const Foam::fvMesh& mesh,
const bool correctWalls
)
:
reflectionVectors(mesh),
wallDistData<wallPointData<vector> >
(
mesh,
reflectionVectors::n_,
correctWalls
)
{}
// * * * * * * * * * * * * * * * Member Functions * * * * * * * * * * * * * //
// Correct for mesh geom/topo changes
void Foam::wallDistReflection::correct()
{
reflectionVectors::correct();
wallDistData<wallPointData<vector> >::correct();
}
// ************************************************************************* //

90
src/finiteVolume/fvMesh/wallDist/wallDistReflection/wallDistReflection.H
View File

@ -1,90 +0,0 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration |
\\ / A nd | Copyright (C) 2011-2015 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::wallDistReflection
Description
Wall distance and reflection vector calculation. See wallDist.H
SourceFiles
wallDistReflection.C
\*---------------------------------------------------------------------------*/
#ifndef wallDistReflection_H
#define wallDistReflection_H
#include "reflectionVectors.H"
#include "wallDistData.H"
#include "wallPointData.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
/*---------------------------------------------------------------------------*\
Class wallDistReflection Declaration
\*---------------------------------------------------------------------------*/
class wallDistReflection
:
public reflectionVectors,
public wallDistData<wallPointData<vector> >
{
// Private Member Functions
//- Disallow default bitwise copy construct
wallDistReflection(const wallDistReflection&);
//- Disallow default bitwise assignment
void operator=(const wallDistReflection&);
public:
// Constructors
//- Construct from mesh and flag whether or not to correct wall.
// Calculate for all cells. correctWalls : correct wall (face&point)
// cells for correct distance, searching neighbours.
wallDistReflection(const fvMesh& mesh, bool correctWalls = true);
// Member Functions
//- Correct for mesh geom/topo changes
void correct();
};
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
} // End namespace Foam
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

16
src/turbulenceModels/compressible/RAS/LaunderGibsonRSTM/LaunderGibsonRSTM.C
View File

@ -184,7 +184,8 @@ LaunderGibsonRSTM::LaunderGibsonRSTM
) )
), ),
yr_(mesh_), n_(wallDist::New(mesh_).n()),
y_(wallDist::New(mesh_).y()),
R_ R_
( (
@ -373,11 +374,6 @@ void LaunderGibsonRSTM::correct()
RASModel::correct(); RASModel::correct();
if (mesh_.changing())
{
yr_.correct();
}
volSymmTensorField P(-twoSymm(R_ & fvc::grad(U_))); volSymmTensorField P(-twoSymm(R_ & fvc::grad(U_)));
volScalarField G(GName(), 0.5*mag(tr(P))); volScalarField G(GName(), 0.5*mag(tr(P)));
@ -443,10 +439,10 @@ void LaunderGibsonRSTM::correct()
// wall reflection terms // wall reflection terms
+ symm + symm
( (
I*((yr_.n() & reflect) & yr_.n()) I*((n_ & reflect) & n_)
- 1.5*(yr_.n()*(reflect & yr_.n()) - 1.5*(n_*(reflect & n_)
+ (yr_.n() & reflect)*yr_.n()) + (n_ & reflect)*n_)
)*pow(Cmu_, 0.75)*rho_*pow(k_, 1.5)/(kappa_*yr_*epsilon_) )*pow(Cmu_, 0.75)*rho_*pow(k_, 1.5)/(kappa_*y_*epsilon_)
); );
REqn().relax(); REqn().relax();

5
src/turbulenceModels/compressible/RAS/LaunderGibsonRSTM/LaunderGibsonRSTM.H
View File

@ -60,7 +60,7 @@ SourceFiles
#define compressibleLaunderGibsonRSTM_H #define compressibleLaunderGibsonRSTM_H
#include "RASModel.H" #include "RASModel.H"
#include "wallDistReflection.H" #include "wallDist.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -109,7 +109,8 @@ protected:
// Fields // Fields
wallDistReflection yr_; const volVectorField& n_;
const volScalarField& y_;
volSymmTensorField R_; volSymmTensorField R_;
volScalarField k_; volScalarField k_;

7
src/turbulenceModels/incompressible/LES/SpalartAllmarasIDDES/IDDESDelta/IDDESDelta.C
View File

@ -25,7 +25,6 @@ License
#include "IDDESDelta.H" #include "IDDESDelta.H"
#include "addToRunTimeSelectionTable.H" #include "addToRunTimeSelectionTable.H"
#include "wallDistReflection.H"
#include "wallDist.H" #include "wallDist.H"
// * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * // // * * * * * * * * * * * * * * Static Data Members * * * * * * * * * * * * * //
@ -43,10 +42,8 @@ void Foam::IDDESDelta::calcDelta()
{ {
const volScalarField& hmax = hmax_(); const volScalarField& hmax = hmax_();
// initialise wallNorm // Wall-reflection vectors
wallDistReflection wallNorm(mesh()); const volVectorField& n = wallDist::New(mesh()).n();
const volVectorField& n = wallNorm.n();
tmp<volScalarField> tfaceToFacenMax tmp<volScalarField> tfaceToFacenMax
( (

16
src/turbulenceModels/incompressible/RAS/LaunderGibsonRSTM/LaunderGibsonRSTM.C
View File

@ -174,7 +174,8 @@ LaunderGibsonRSTM::LaunderGibsonRSTM
) )
), ),
yr_(mesh_), n_(wallDist::New(mesh_).n()),
y_(wallDist::New(mesh_).y()),
R_ R_
( (
@ -380,11 +381,6 @@ void LaunderGibsonRSTM::correct()
return; return;
} }
if (mesh_.changing())
{
yr_.correct();
}
volSymmTensorField P(-twoSymm(R_ & fvc::grad(U_))); volSymmTensorField P(-twoSymm(R_ & fvc::grad(U_)));
volScalarField G(GName(), 0.5*mag(tr(P))); volScalarField G(GName(), 0.5*mag(tr(P)));
@ -450,10 +446,10 @@ void LaunderGibsonRSTM::correct()
// wall reflection terms // wall reflection terms
+ symm + symm
( (
I*((yr_.n() & reflect) & yr_.n()) I*((n_ & reflect) & n_)
- 1.5*(yr_.n()*(reflect & yr_.n()) - 1.5*(n_*(reflect & n_)
+ (yr_.n() & reflect)*yr_.n()) + (n_ & reflect)*n_)
)*pow(Cmu_, 0.75)*pow(k_, 1.5)/(kappa_*yr_*epsilon_) )*pow(Cmu_, 0.75)*pow(k_, 1.5)/(kappa_*y_*epsilon_)
); );
REqn().relax(); REqn().relax();

5
src/turbulenceModels/incompressible/RAS/LaunderGibsonRSTM/LaunderGibsonRSTM.H
View File

@ -59,7 +59,7 @@ SourceFiles
#define LaunderGibsonRSTM_H #define LaunderGibsonRSTM_H
#include "RASModel.H" #include "RASModel.H"
#include "wallDistReflection.H" #include "wallDist.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * // // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
@ -106,7 +106,8 @@ protected:
// Fields // Fields
wallDistReflection yr_; const volVectorField& n_;
const volScalarField& y_;
volSymmTensorField R_; volSymmTensorField R_;
volScalarField k_; volScalarField k_;