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

Merge branch 'master' of github.com-OpenFOAM:OpenFOAM/OpenFOAM-dev

Browse Source
This commit is contained in:
Henry Weller
2022-11-01 11:04:12 +00:00
parent d7501da34c 65b7f62857
commit 7d045de80a
21 changed files with 475 additions and 543 deletions
Download Patch File Download Diff File Expand all files Collapse all files

150
applications/utilities/mesh/manipulation/checkMesh/checkGeometry.C
View File

@ -1,3 +1,28 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2022 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 "PatchTools.H"
#include "checkGeometry.H"
#include "polyMesh.H"
@ -11,12 +36,14 @@
#include "vtkSurfaceWriter.H"
#include "setWriter.H"
#include "writeFile.H"
#include "nonConformalCyclicPolyPatch.H"
#include "checkTools.H"
#include "Time.H"
// Find wedge with opposite orientation. Note: does not actually check that
// it is opposite, only that it has opposite normal and same axis
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
Foam::label Foam::findOppositeWedge
(
const polyMesh& mesh,
@ -942,5 +969,124 @@ Foam::label Foam::checkGeometry
}
}
if (allGeometry)
{
const fileName outputPath =
mesh.time().globalPath()
/functionObjects::writeFile::outputPrefix
/(mesh.name() != polyMesh::defaultRegion ? mesh.name() : word())
/"checkMesh"
/mesh.time().timeName();
const polyBoundaryMesh& patches = mesh.boundaryMesh();
// Compute coverage for all orig patches
PtrList<scalarField> patchCoverage(patches.size());
forAll(patches, nccPatchi)
{
if (isA<nonConformalCyclicPolyPatch>(patches[nccPatchi]))
{
const nonConformalCyclicPolyPatch& nccPp =
refCast<const nonConformalCyclicPolyPatch>
(patches[nccPatchi]);
if (nccPp.owner())
{
const polyPatch& origPp = nccPp.origPatch();
const polyPatch& nbrOrigPp = nccPp.nbrPatch().origPatch();
const patchToPatches::intersection& intersection =
nccPp.intersection();
if (!patchCoverage.set(origPp.index()))
{
patchCoverage.set
(
origPp.index(),
scalarField(origPp.size(), 0)
);
}
patchCoverage[origPp.index()] +=
intersection.srcCoverage();
if (!patchCoverage.set(nbrOrigPp.index()))
{
patchCoverage.set
(
nbrOrigPp.index(),
scalarField(nbrOrigPp.size(), 0)
);
}
patchCoverage[nbrOrigPp.index()] +=
intersection.tgtCoverage();
}
}
}
// Write out to surface files
forAll(patches, patchi)
{
if (patchCoverage.set(patchi))
{
const polyPatch& patch = patches[patchi];
// Collect the patch geometry
labelList pointToGlobal;
labelList uniqueMeshPointLabels;
autoPtr<globalIndex> globalPoints;
autoPtr<globalIndex> globalFaces;
faceList mergedFaces;
pointField mergedPoints;
Foam::PatchTools::gatherAndMerge
(
mesh,
patch.localFaces(),
patch.meshPoints(),
patch.meshPointMap(),
pointToGlobal,
uniqueMeshPointLabels,
globalPoints,
globalFaces,
mergedFaces,
mergedPoints
);
// Collect the patch coverage
scalarField mergedCoverage;
globalFaces().gather
(
UPstream::worldComm,
labelList(UPstream::procID(UPstream::worldComm)),
patchCoverage[patchi],
mergedCoverage
);
// Write the surface
if (Pstream::master())
{
vtkSurfaceWriter
(
mesh.time().writeFormat(),
mesh.time().writeCompression()
).write
(
outputPath,
patch.name() + "_coverage",
mergedPoints,
mergedFaces,
false,
"coverage",
mergedCoverage
);
}
}
}
}
return noFailedChecks;
}
// ************************************************************************* //

45
applications/utilities/mesh/manipulation/checkMesh/checkGeometry.H
View File

@ -1,14 +1,52 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2022 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
Routines for checking mesh geometry
SourceFiles
checkGeometry.C
\*---------------------------------------------------------------------------*/
#ifndef checkGeometry_H
#define checkGeometry_H
#include "label.H"
#include "HashSet.H"
#include "labelVector.H"
#include "setWriter.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
class polyMesh;
class wedgePolyPatch;
class surfaceWriter;
//- Find wedge with opposite orientation. Note: does not actually check
// that it is opposite, only that it has opposite normal and same axis.
label findOppositeWedge(const polyMesh&, const wedgePolyPatch&);
//- Check wedge orientation
@ -23,6 +61,7 @@ namespace Foam
//- Check 0th vertex on coupled faces
bool checkCoupledPoints(const polyMesh&, const bool report, labelHashSet*);
//- Check the geometry
label checkGeometry
(
const polyMesh& mesh,
@ -31,3 +70,9 @@ namespace Foam
const autoPtr<setWriter>&
);
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

30
applications/utilities/mesh/manipulation/checkMesh/checkMeshQuality.C
View File

@ -1,3 +1,28 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2022 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 "checkMeshQuality.H"
#include "polyMesh.H"
#include "cellSet.H"
@ -6,6 +31,8 @@
#include "surfaceWriter.H"
#include "checkTools.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
Foam::label Foam::checkMeshQuality
(
const polyMesh& mesh,
@ -38,3 +65,6 @@ Foam::label Foam::checkMeshQuality
return noFailedChecks;
}
// ************************************************************************* //

45
applications/utilities/mesh/manipulation/checkMesh/checkMeshQuality.H
View File

@ -1,7 +1,44 @@
#include "polyMesh.H"
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2022 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
Routines for checking mesh quality
SourceFiles
checkMeshQuality.C
\*---------------------------------------------------------------------------*/
#ifndef checkMeshQuality_H
#define checkMeshQuality_H
#include "dictionary.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
class polyMesh;
class surfaceWriter;
label checkMeshQuality
@ -11,3 +48,9 @@ namespace Foam
const autoPtr<surfaceWriter>&
);
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

1
applications/utilities/mesh/manipulation/checkMesh/checkTools.C
View File

@ -44,6 +44,7 @@ License
#include "writeFile.H"
#include "coordSet.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
void Foam::printMeshStats(const polyMesh& mesh, const bool allTopology)
{

42
applications/utilities/mesh/manipulation/checkMesh/checkTools.H
View File

@ -1,17 +1,54 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2015-2022 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
Tools for checking the mesh
SourceFiles
checkTools.C
\*---------------------------------------------------------------------------*/
#ifndef checkTools_H
#define checkTools_H
#include "scalar.H"
#include "indirectPrimitivePatch.H"
#include "setWriter.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
class polyMesh;
class surfaceWriter;
class setWriter;
class pointSet;
class faceSet;
class cellSet;
class fileName;
class polyMesh;
//- Print mesh statistics
void printMeshStats(const polyMesh& mesh, const bool allTopology);
//- Generate merged surface on master and write. Needs input patch
@ -38,5 +75,8 @@ namespace Foam
void mergeAndWrite(const setWriter&, const pointSet&);
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

2
applications/utilities/mesh/manipulation/checkMesh/checkTopology.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2021 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License

54
applications/utilities/mesh/manipulation/checkMesh/checkTopology.H
View File

@ -1,18 +1,60 @@
/*---------------------------------------------------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2022 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
Tools for checking the mesh
SourceFiles
checkTopology.C
\*---------------------------------------------------------------------------*/
#ifndef checkTopology_H
#define checkTopology_H
#include "label.H"
#include "autoPtr.H"
#include "setWriter.H"
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
namespace Foam
{
class polyMesh;
class surfaceWriter;
class setWriter;
label checkTopology
(
const polyMesh&,
const bool,
const bool,
const autoPtr<surfaceWriter>&,
const autoPtr<setWriter>&
const polyMesh& mesh,
const bool allTopology,
const bool allGeometry,
const autoPtr<surfaceWriter>& surfWriter,
const autoPtr<Foam::setWriter>& setWriter
);
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#endif
// ************************************************************************* //

170
applications/utilities/mesh/manipulation/checkMesh/printMeshStats.C
View File

@ -1,170 +0,0 @@
#include "printMeshStats.H"
#include "polyMesh.H"
#include "globalMeshData.H"
#include "hexMatcher.H"
#include "wedgeMatcher.H"
#include "prismMatcher.H"
#include "pyrMatcher.H"
#include "tetWedgeMatcher.H"
#include "tetMatcher.H"
#include "IOmanip.H"
void Foam::printMeshStats(const polyMesh& mesh, const bool allTopology)
{
Info<< "Mesh stats" << nl
<< " points: "
<< returnReduce(mesh.points().size(), sumOp<label>()) << nl;
label nInternalPoints = returnReduce
(
mesh.nInternalPoints(),
sumOp<label>()
);
if (nInternalPoints != -Pstream::nProcs())
{
Info<< " internal points: " << nInternalPoints << nl;
if (returnReduce(mesh.nInternalPoints(), minOp<label>()) == -1)
{
WarningInFunction
<< "Some processors have their points sorted into internal"
<< " and external and some do not." << endl
<< "This can cause problems later on." << endl;
}
}
if (allTopology && nInternalPoints != -Pstream::nProcs())
{
label nEdges = returnReduce(mesh.nEdges(), sumOp<label>());
label nInternalEdges = returnReduce
(
mesh.nInternalEdges(),
sumOp<label>()
);
label nInternal1Edges = returnReduce
(
mesh.nInternal1Edges(),
sumOp<label>()
);
label nInternal0Edges = returnReduce
(
mesh.nInternal0Edges(),
sumOp<label>()
);
Info<< " edges: " << nEdges << nl
<< " internal edges: " << nInternalEdges << nl
<< " internal edges using one boundary point: "
<< nInternal1Edges-nInternal0Edges << nl
<< " internal edges using two boundary points: "
<< nInternalEdges-nInternal1Edges << nl;
}
label nFaces = returnReduce(mesh.faces().size(), sumOp<label>());
label nIntFaces = returnReduce(mesh.faceNeighbour().size(), sumOp<label>());
label nCells = returnReduce(mesh.cells().size(), sumOp<label>());
Info<< " faces: " << nFaces << nl
<< " internal faces: " << nIntFaces << nl
<< " cells: " << nCells << nl
<< " faces per cell: "
<< scalar(nFaces + nIntFaces)/max(1, nCells) << nl
<< " boundary patches: " << mesh.boundaryMesh().size() << nl
<< " point zones: " << mesh.pointZones().size() << nl
<< " face zones: " << mesh.faceZones().size() << nl
<< " cell zones: " << mesh.cellZones().size() << nl
<< endl;
// Construct shape recognisers
hexMatcher hex;
prismMatcher prism;
wedgeMatcher wedge;
pyrMatcher pyr;
tetWedgeMatcher tetWedge;
tetMatcher tet;
// Counters for different cell types
label nHex = 0;
label nWedge = 0;
label nPrism = 0;
label nPyr = 0;
label nTet = 0;
label nTetWedge = 0;
label nUnknown = 0;
Map<label> polyhedralFaces;
for (label celli = 0; celli < mesh.nCells(); celli++)
{
if (hex.isA(mesh, celli))
{
nHex++;
}
else if (tet.isA(mesh, celli))
{
nTet++;
}
else if (pyr.isA(mesh, celli))
{
nPyr++;
}
else if (prism.isA(mesh, celli))
{
nPrism++;
}
else if (wedge.isA(mesh, celli))
{
nWedge++;
}
else if (tetWedge.isA(mesh, celli))
{
nTetWedge++;
}
else
{
nUnknown++;
polyhedralFaces(mesh.cells()[celli].size())++;
}
}
reduce(nHex,sumOp<label>());
reduce(nPrism,sumOp<label>());
reduce(nWedge,sumOp<label>());
reduce(nPyr,sumOp<label>());
reduce(nTetWedge,sumOp<label>());
reduce(nTet,sumOp<label>());
reduce(nUnknown,sumOp<label>());
Info<< "Overall number of cells of each type:" << nl
<< " hexahedra: " << nHex << nl
<< " prisms: " << nPrism << nl
<< " wedges: " << nWedge << nl
<< " pyramids: " << nPyr << nl
<< " tet wedges: " << nTetWedge << nl
<< " tetrahedra: " << nTet << nl
<< " polyhedra: " << nUnknown
<< endl;
if (nUnknown > 0)
{
Pstream::mapCombineGather(polyhedralFaces, plusEqOp<label>());
Info<< " Breakdown of polyhedra by number of faces:" << nl
<< " faces" << " number of cells" << endl;
const labelList sortedKeys = polyhedralFaces.sortedToc();
forAll(sortedKeys, keyI)
{
const label nFaces = sortedKeys[keyI];
Info<< setf(std::ios::right) << setw(13)
<< nFaces << " " << polyhedralFaces[nFaces] << nl;
}
}
Info<< endl;
}

6
applications/utilities/mesh/manipulation/checkMesh/printMeshStats.H
View File

@ -1,6 +0,0 @@
namespace Foam
{
class polyMesh;
void printMeshStats(const polyMesh& mesh, const bool allTopology);
}

13
src/functionObjects/field/fieldAverage/fieldAverage.C
View File

@ -2,7 +2,7 @@
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Copyright (C) 2011-2021 OpenFOAM Foundation
\\ / A nd | Copyright (C) 2011-2022 OpenFOAM Foundation
\\/ M anipulation |
-------------------------------------------------------------------------------
License
@ -123,8 +123,6 @@ void Foam::functionObjects::fieldAverage::initialise()
// ensure first averaging works unconditionally
prevTimeIndex_ = -1;
initialised_ = true;
}
@ -142,11 +140,6 @@ void Foam::functionObjects::fieldAverage::restart()
void Foam::functionObjects::fieldAverage::calcAverages()
{
if (!initialised_)
{
initialise();
}
const label currentTimeIndex = obr_.time().timeIndex();
const scalar currentTime = obr_.time().value();
@ -306,7 +299,6 @@ Foam::functionObjects::fieldAverage::fieldAverage
restartOnOutput_(false),
periodicRestart_(false),
restartPeriod_(great),
initialised_(false),
base_(baseType::iter),
window_(-1.0),
windowName_(""),
@ -331,7 +323,6 @@ bool Foam::functionObjects::fieldAverage::read(const dictionary& dict)
{
fvMeshFunctionObject::read(dict);
initialised_ = false;
Log << type() << " " << name() << ":" << nl;
@ -361,6 +352,8 @@ bool Foam::functionObjects::fieldAverage::read(const dictionary& dict)
readAveragingProperties();
initialise();
Log << endl;
return true;

3
src/functionObjects/field/fieldAverage/fieldAverage.H
View File

@ -157,9 +157,6 @@ protected:
//- Restart period
scalar restartPeriod_;
//- Initialised flag
bool initialised_;
//- Averaging base type names
static const NamedEnum<baseType, 2> baseTypeNames_;

14
src/mesh/snappyHexMesh/snappyHexMeshDriver/snappySnapDriver.C
View File

@ -2799,20 +2799,18 @@ void Foam::snappySnapDriver::doSnap
}
}
// Merge any introduced baffles (from faceZones of faceType 'internal')
{
autoPtr<polyTopoChangeMap> mapPtr = mergeZoneBaffles(baffles);
if (mapPtr.valid())
{
forAll(duplicateFace, facei)
{
if (duplicateFace[facei] != -1)
{
duplicateFace[facei] = mapPtr().reverseFaceMap()[facei];
}
}
meshRefinement::updateList
(
mapPtr().faceMap(),
label(-1),
duplicateFace
);
}
}

3
src/meshTools/patchToPatch/intersection/intersectionPatchToPatch.C
View File

@ -847,7 +847,8 @@ Foam::label Foam::patchToPatches::intersection::finalise
"openness", false, srcOpenness,
"error", false, srcError,
"depth", false, srcDepth,
"angle", false, srcAngle
"angle", false, srcAngle,
"normals", true, srcPointNormals
);
Info<< indent << "Writing target patch to "

6
src/meshTools/patchToPatch/intersection/intersectionPatchToPatch.H
View File

@ -408,6 +408,12 @@ public:
//- For each target face, the target and source areas for each
// source coupling
inline const List<DynamicList<couple>>& tgtCouples() const;
//- Return the proportion of the source faces that are coupled
inline const List<scalar>& srcCoverage() const;
//- Return the proportion of the target faces that are coupled
inline const List<scalar>& tgtCoverage() const;
};

14
src/meshTools/patchToPatch/intersection/intersectionPatchToPatchI.H
View File

@ -57,4 +57,18 @@ Foam::patchToPatches::intersection::tgtCouples() const
}
inline const Foam::List<Foam::scalar>&
Foam::patchToPatches::intersection::srcCoverage() const
{
return srcCoverage_;
}
inline const Foam::List<Foam::scalar>&
Foam::patchToPatches::intersection::tgtCoverage() const
{
return tgtCoverage_;
}
// ************************************************************************* //

4
src/parallel/parallel/domainDecomposition.C
View File

@ -1717,7 +1717,7 @@ void Foam::domainDecomposition::writeComplete(const bool doSets) const
forAllConstIter(faceSet, procSet, iter)
{
cSet.insert(faceMap[iter.key()]);
cSet.insert(mag(faceMap[iter.key()]) - 1);
}
}
forAllConstIter(IOobjectList, pointSetObjects, iter)
@ -1907,7 +1907,7 @@ void Foam::domainDecomposition::writeProcs(const bool doSets) const
faceSet set(procMesh, cs.name(), cs.size()/nProcs());
forAll(procFaceAddressing_[proci], i)
{
if (cs.found(mag(procFaceAddressing_[proci][i])-1))
if (cs.found(mag(procFaceAddressing_[proci][i]) - 1))
{
set.insert(i);
}

18
tutorials/multiphase/interFoam/RAS/mixerVessel/system/blockMeshDict
View File

@ -17,19 +17,19 @@ convertToMeters 1;
vertices
(
( -0.3 -0.3 -0.15)
( 0.3 -0.3 -0.15)
( 0.3 0.3 -0.15)
( -0.3 0.3 -0.15)
( -0.3 -0.3 1.4)
( 0.3 -0.3 1.4)
( 0.3 0.3 1.4)
( -0.3 0.3 1.4)
(-0.275 -0.275 -0.125)
( 0.275 -0.275 -0.125)
( 0.275 0.275 -0.125)
(-0.275 0.275 -0.125)
(-0.275 -0.275 1.325)
( 0.275 -0.275 1.325)
( 0.275 0.275 1.325)
(-0.275 0.275 1.325)
);
blocks
(
hex (0 1 2 3 4 5 6 7) (50 50 100) simpleGrading (1 1 1)
hex (0 1 2 3 4 5 6 7) (88 88 232) simpleGrading (1 1 1)
);
boundary

13
tutorials/multiphase/interFoam/RAS/mixerVessel/system/controlDict
View File

@ -52,4 +52,17 @@ maxAlphaCo 1;
maxDeltaT 1;
functions
{
#includeFunc cutPlaneSurface
(
point=(0 0 0),
normal=(1 -1 0),
interpolate=no,
alpha.oil,
p_rgh,
U
)
}
// ************************************************************************* //

31
tutorials/multiphase/interFoam/RAS/mixerVessel/system/meshQualityDict Normal file
View File

@ -0,0 +1,31 @@
/*--------------------------------*- C++ -*----------------------------------*\
========= |
\\ / F ield | OpenFOAM: The Open Source CFD Toolbox
\\ / O peration | Website: https://openfoam.org
\\ / A nd | Version: dev
\\/ M anipulation |
\*---------------------------------------------------------------------------*/
FoamFile
{
format ascii;
class dictionary;
object meshQualityDict;
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
#includeEtc "caseDicts/mesh/generation/meshQualityDict.cfg"
//- Minimum quality of the tet formed by the face-centre
// and variable base point minimum decomposition triangles and
// the cell centre. Set to very negative number (e.g. -1e30) to
// disable.
// <0 = inside out tet,
// 0 = flat tet
// 1 = regular tet
minTetQuality -1e30;
//- Minimum face twist. Set to <-1 to disable. dot product of face normal
// and face centre triangles normal
minTwist 0.05;
// ************************************************************************* //

354
tutorials/multiphase/interFoam/RAS/mixerVessel/system/snappyHexMeshDict
View File

@ -13,7 +13,8 @@ FoamFile
}
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * //
// Which of the steps to run
#includeEtc "caseDicts/mesh/generation/snappyHexMeshDict.cfg"
castellatedMesh true;
snap true;
addLayers false;
@ -24,7 +25,6 @@ geometry
{
type triSurfaceMesh;
file "mixerVessel-vessel.stl";
regions
{
vessel
@ -33,12 +33,10 @@ geometry
}
}
}
oilInlet
{
type triSurfaceMesh;
file "mixerVessel-oilInlet.stl";
regions
{
oilInlet
@ -47,12 +45,10 @@ geometry
}
}
}
outlet
{
type triSurfaceMesh;
file "mixerVessel-outlet.stl";
regions
{
outlet
@ -61,12 +57,10 @@ geometry
}
}
}
shaftRotating
{
type triSurfaceMesh;
file "mixerVessel-shaftRotating.stl";
regions
{
shaftRotating
@ -75,12 +69,10 @@ geometry
}
}
}
shaft
{
type triSurfaceMesh;
file "mixerVessel-shaft.stl";
regions
{
shaft
@ -89,12 +81,10 @@ geometry
}
}
}
sparger
{
type triSurfaceMesh;
file "mixerVessel-sparger.stl";
regions
{
sparger
@ -103,12 +93,10 @@ geometry
}
}
}
stirrer
{
type triSurfaceMesh;
file "mixerVessel-stirrer.stl";
regions
{
stirrer
@ -117,12 +105,10 @@ geometry
}
}
}
baffles
{
type triSurfaceMesh;
file "mixerVessel-baffles.stl";
regions
{
baffles
@ -131,7 +117,6 @@ geometry
}
}
}
rotating
{
type triSurfaceMesh;
@ -139,430 +124,153 @@ geometry
}
};
// Settings for the castellatedMesh generation.
castellatedMeshControls
{
// Refinement parameters
// ~~~~~~~~~~~~~~~~~~~~~
// If local number of cells is >= maxLocalCells on any processor
// switches from from refinement followed by balancing
// (current method) to (weighted) balancing before refinement.
maxLocalCells 100000;
// Overall cell limit (approximately). Refinement will stop immediately
// upon reaching this number so a refinement level might not complete.
// Note that this is the number of cells before removing the part which
// is not 'visible' from the keepPoint. The final number of cells might
// actually be a lot less.
maxGlobalCells 3000000;
// The surface refinement loop might spend lots of iterations refining just a
// few cells. This setting will cause refinement to stop if <= minimumRefine
// are selected for refinement. Note: it will at least do one iteration
// (unless the number of cells to refine is 0)
minRefinementCells 0;
// Allow a certain level of imbalance during refining
// (since balancing is quite expensive)
// Expressed as fraction of perfect balance (= overall number of cells /
// nProcs). 0=balance always.
maxLoadUnbalance 0.10;
// Number of buffer layers between different levels.
// 1 means normal 2:1 refinement restriction, larger means slower
// refinement.
nCellsBetweenLevels 1;
// Explicit feature edge refinement
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Specifies a level for any cell intersected by explicitly provided
// edges.
// This is a featureEdgeMesh, read from constant/geometry for now.
// Specify 'levels' in the same way as the 'distance' mode in the
// refinementRegions (see below). The old specification
// level 2;
// is equivalent to
// levels ((0 2));
features
(
{
file "mixerVessel-shaftRotating.eMesh";
levels ((1 1));
levels ((0 0));
}
{
file "mixerVessel-shaft.eMesh";
levels ((1 1));
levels ((0 0));
}
{
file "mixerVessel-sparger.eMesh";
levels ((1 1));
levels ((0 0));
}
{
file "mixerVessel-stirrer.eMesh";
levels ((1 1));
levels ((0 0));
}
{
file "mixerVessel-baffles.eMesh";
levels ((1 1));
levels ((0 0));
}
{
file "rotating.eMesh";
levels ((1 1));
levels ((0 0));
}
{
file "mixerVessel-oilInlet.eMesh";
levels ((1 1));
levels ((0 0));
}
{
file "mixerVessel-vessel.eMesh";
levels ((1 1));
levels ((0 0));
}
{
file "mixerVessel-outlet.eMesh";
levels ((1 1));
levels ((0 0));
}
);
// Surface based refinement
// ~~~~~~~~~~~~~~~~~~~~~~~~
// Specifies two levels for every surface. The first is the minimum level,
// every cell intersecting a surface gets refined up to the minimum level.
// The second level is the maximum level. Cells that 'see' multiple
// intersections where the intersections make an
// angle > resolveFeatureAngle get refined up to the maximum level.
refinementSurfaces
{
vessel
{
level (1 2);
level (0 1);
patchInfo
{
type wall;
inGroups (meshedWalls);
}
}
oilInlet
{
level (0 1);
level (0 0);
patchInfo
{
type patch;
}
}
outlet
{
level (0 1);
level (0 0);
patchInfo
{
type patch;
}
}
shaftRotating
{
level (1 1);
level (0 0);
patchInfo
{
$../../vessel/patchInfo
}
}
shaft
{
level (1 1);
level (0 0);
patchInfo
{
$../../vessel/patchInfo
}
}
sparger
{
level (1 1);
level (0 0);
patchInfo
{
$../../vessel/patchInfo
}
}
stirrer
{
level (1 1);
level (0 0);
patchInfo
{
$../../vessel/patchInfo
}
}
baffles
{
level (1 1);
level (0 0);
patchInfo
{
$../../vessel/patchInfo
}
}
rotating
{
level (1 2);
level (0 0);
cellZone rotating;
faceZone rotating;
mode insidePoint;
mode insidePoint;
insidePoint (0 0.1 0.5);
}
}
// Feature angle:
// - used if min and max refinement level of a surface differ
// - used if feature snapping (see snapControls below) is used
resolveFeatureAngle 30;
// Mesh selection
// ~~~~~~~~~~~~~~
// After refinement patches get added for all refinementSurfaces and
// all cells intersecting the surfaces get put into these patches. The
// section reachable from the insidePoint is kept.
// NOTE: This point should never be on a face, always inside a cell, even
// after refinement.
insidePoint (0 0.1 1.0);
// Whether any faceZones (as specified in the refinementSurfaces)
// are only on the boundary of corresponding cellZones or also allow
// free-standing zone faces. Not used if there are no faceZones.
allowFreeStandingZoneFaces true;
allowFreeStandingZoneFaces false;
}
// Settings for the snapping.
snapControls
{
// Number of patch smoothing iterations before finding correspondence
// to surface
nSmoothPatch 3;
// Maximum relative distance for points to be attracted by surface.
// True distance is this factor times local maximum edge length.
// Note: changed(corrected) w.r.t 17x! (17x used 2* tolerance)
tolerance 3.0;
// Number of mesh displacement relaxation iterations.
nSolveIter 30;
// Maximum number of snapping relaxation iterations. Should stop
// before upon reaching a correct mesh.
nRelaxIter 5;
// Feature snapping
// Number of feature edge snapping iterations.
// Leave out altogether to disable.
nFeatureSnapIter 15;
// Detect (geometric only) features by sampling the surface
// (default=false).
implicitFeatureSnap false;
// Use castellatedMeshControls::features (default = true)
explicitFeatureSnap true;
// Detect features between multiple surfaces
// (only for explicitFeatureSnap, default = false)
multiRegionFeatureSnap false;
implicitFeatureSnap false;
explicitFeatureSnap true;
}
// Settings for the layer addition.
addLayersControls
{
// Are the thickness parameters below relative to the undistorted
// size of the refined cell outside layer (true) or absolute sizes (false).
relativeSizes true;
// Layer thickness specification. This can be specified in one of four ways
// - expansionRatio and finalLayerThickness (cell nearest internal mesh)
// - expansionRatio and firstLayerThickness (cell on surface)
// - overall thickness and firstLayerThickness
// - overall thickness and finalLayerThickness
// Expansion factor for layer mesh
expansionRatio 1.0;
// Wanted thickness of final added cell layer. If multiple layers
// is the thickness of the layer furthest away from the wall.
// Relative to undistorted size of cell outside layer.
// See relativeSizes parameter.
finalLayerThickness 0.3;
// Wanted thickness of the layer next to the wall.
// If relativeSizes this is relative to undistorted size of cell
// outside layer.
// firstLayerThickness 0.3;
// Wanted overall thickness of layers.
// If relativeSizes this is relative to undistorted size of cell
// outside layer.
// thickness 0.5
// Minimum overall thickness of total layers. If for any reason layer
// cannot be above minThickness do not add layer.
// If relativeSizes this is relative to undistorted size of cell
// outside layer..
minThickness 0.25;
// Per final patch (so not geometry!) the layer information
// Note: This behaviour changed after 21x. Any non-mentioned patches
// now slide unless:
// - nSurfaceLayers is explicitly mentioned to be 0.
// - angle to nearest surface < slipFeatureAngle (see below)
layers
{
vessel
{
nSurfaceLayers 1;
expansionRatio 1.3;
finalLayerThickness 0.5;
minThickness 0.1;
}
}
{}
// If points get not extruded do nGrow layers of connected faces that are
// also not grown. This helps convergence of the layer addition process
// close to features.
// Note: changed(corrected) w.r.t 17x! (didn't do anything in 17x)
nGrow 0;
// Advanced settings
// When not to extrude surface. 0 is flat surface, 90 is when two faces
// are perpendicular
featureAngle 60;
// At non-patched sides allow mesh to slip if extrusion direction makes
// angle larger than slipFeatureAngle.
slipFeatureAngle 30;
// Maximum number of snapping relaxation iterations. Should stop
// before upon reaching a correct mesh.
nRelaxIter 10;
// Number of smoothing iterations of surface normals
nSmoothSurfaceNormals 1;
// Number of smoothing iterations of interior mesh movement direction
nSmoothNormals 3;
// Smooth layer thickness over surface patches
nSmoothThickness 10;
// Stop layer growth on highly warped cells
maxFaceThicknessRatio 0.5;
// Reduce layer growth where ratio thickness to medial
// distance is large
maxThicknessToMedialRatio 0.3;
// Angle used to pick up medial axis points
// Note: changed(corrected) w.r.t 17x! 90 degrees corresponds to 130 in 17x.
minMedianAxisAngle 90;
// Create buffer region for new layer terminations
nBufferCellsNoExtrude 0;
// Overall max number of layer addition iterations. The mesher will exit
// if it reaches this number of iterations; possibly with an illegal
// mesh.
nLayerIter 50;
// Max number of iterations after which relaxed meshQuality controls
// get used. Up to nRelaxIter it uses the settings in meshQualityControls,
// after nRelaxIter it uses the values in meshQualityControls::relaxed.
nRelaxedIter 20;
// Additional reporting: if there are just a few faces where there
// are mesh errors (after adding the layers) print their face centres.
// This helps in tracking down problematic mesh areas.
// additionalReporting true;
relativeSizes true;
expansionRatio 1.2;
finalLayerThickness 0.5;
minThickness 1e-3;
}
// Generic mesh quality settings. At any undoable phase these determine
// where to undo.
meshQualityControls
{
// Maximum non-orthogonality allowed. Set to 180 to disable.
maxNonOrtho 65;
writeFlags
();
// Max skewness allowed. Set to <0 to disable.
maxBoundarySkewness 20;
maxInternalSkewness 4;
// Max concaveness allowed. Is angle (in degrees) below which concavity
// is allowed. 0 is straight face, <0 would be convex face.
// Set to 180 to disable.
maxConcave 80;
//- Minimum cell pyramid volume relative to min bounding box length^3
// Set to a fraction of the smallest cell volume expected.
// Set to very negative number (e.g. -1e30) to disable.
minVol -1e30;
// Minimum quality of the tet formed by the face-centre
// and variable base point minimum decomposition triangles and
// the cell centre. This has to be a positive number for tracking
// to work. Set to very negative number (e.g. -1e30) to
// disable.
// <0 = inside out tet,
// 0 = flat tet
// 1 = regular tet
minTetQuality -1e-30;
// Minimum face twist. Set to <-1 to disable. dot product of face normal
// and face centre triangles normal
minTwist 0.05;
// minimum normalised cell determinant
// 1 = hex, <= 0 = folded or flattened illegal cell
minDeterminant 0.001;
// minFaceWeight (0 -> 0.5)
minFaceWeight 0.05;
// minVolRatio (0 -> 1)
minVolRatio 0.01;
// Advanced
// Number of error distribution iterations
nSmoothScale 4;
// amount to scale back displacement at error points
errorReduction 0.75;
// Optional : some meshing phases allow usage of relaxed rules.
// See e.g. addLayersControls::nRelaxedIter.
relaxed
{
//- Maximum non-orthogonality allowed. Set to 180 to disable.
maxNonOrtho 75;
}
}
// Advanced
// Merge tolerance. Is fraction of overall bounding box of initial mesh.
// Note: the write tolerance needs to be higher than this.
mergeTolerance 1e-6;
// ************************************************************************* //