label meshOptimizer::findLowQualityFaces
(
labelHashSet& badFaces,
const boolList& changedFace
) const
{
badFaces.clear();
polyMeshGenChecks::checkFaceDotProduct
(
mesh_,
false,
70.0,
&badFaces
);
polyMeshGenChecks::checkFaceSkewness
(
mesh_,
false,
2.0,
&badFaces
);
const label nBadFaces = returnReduce(badFaces.size(), sumOp<label>());
return nBadFaces;
}
void Foam::surfaceSets::getSurfaceSets
(
const polyMesh& mesh,
const fileName&,
const triSurface&,
const triSurfaceSearch& querySurf,
const pointField& outsidePts,
const label nCutLayers,
labelHashSet& inside,
labelHashSet& outside,
labelHashSet& cut
)
{
// Construct search engine on mesh
meshSearch queryMesh(mesh);
// Cut faces with surface and classify cells
cellClassification cellType
(
mesh,
queryMesh,
querySurf,
outsidePts
);
if (nCutLayers > 0)
{
// Trim cutCells so they are max nCutLayers away (as seen in point-cell
// walk) from outside cells.
cellType.trimCutCells
(
nCutLayers,
cellClassification::OUTSIDE,
cellClassification::INSIDE
);
}
forAll(cellType, celli)
{
label cType = cellType[celli];
if (cType == cellClassification::CUT)
{
cut.insert(celli);
}
else if (cType == cellClassification::INSIDE)
{
inside.insert(celli);
}
else if (cType == cellClassification::OUTSIDE)
{
outside.insert(celli);
}
}
forAll(ptc, pointi)
{
const labelList& curFaces = pf[ptc[pointi]];
forAll(curFaces, facei)
{
if (!facesToRemoveMap.found(curFaces[facei]))
{
facesToModify.insert(curFaces[facei]);
}
}
}
label meshOptimizer::findBadFaces
(
labelHashSet& badFaces,
const boolList& changedFace
) const
{
badFaces.clear();
polyMeshGenChecks::checkFacePyramids
(
mesh_,
false,
VSMALL,
&badFaces,
&changedFace
);
polyMeshGenChecks::checkFaceFlatness
(
mesh_,
false,
0.8,
&badFaces,
&changedFace
);
polyMeshGenChecks::checkCellPartTetrahedra
(
mesh_,
false,
VSMALL,
&badFaces,
&changedFace
);
polyMeshGenChecks::checkFaceAreas
(
mesh_,
false,
VSMALL,
&badFaces,
&changedFace
);
const label nBadFaces = returnReduce(badFaces.size(), sumOp<label>());
return nBadFaces;
}
forAll(patchIDs, i)
{
const labelUList& fc = pbm[patchIDs[i]].faceCells();
forAll(fc, i)
{
patchCells.insert(fc[i]);
}
void bigParticleVoidFraction::buildLabelHashSet
(
const scalar radius,
const vector position,
const label cellID,
labelHashSet& hashSett
)const
{
hashSett.insert(cellID);
//Info<<"cell inserted"<<cellID<<endl;
const labelList& nc = particleCloud_.mesh().cellCells()[cellID];
forAll(nc,i){
label neighbor=nc[i];
if(!hashSett.found(neighbor) && mag(position-particleCloud_.mesh().C()[neighbor])<radius){
buildLabelHashSet(radius,position,neighbor,hashSett);
}
}
int main(int argc, char *argv[])
{
#include "addOverwriteOption.H"
argList::noParallel();
argList::validArgs.append("patches");
argList::validArgs.append("edgeFraction");
argList::addOption
(
"useSet",
"name",
"restrict cells to refine based on specified cellSet name"
);
#include "setRootCase.H"
#include "createTime.H"
runTime.functionObjects().off();
#include "createPolyMesh.H"
const word oldInstance = mesh.pointsInstance();
// Find set of patches from the list of regular expressions provided
const wordReList patches((IStringStream(args[1])()));
const labelHashSet patchSet(mesh.boundaryMesh().patchSet(patches));
const scalar weight = args.argRead<scalar>(2);
const bool overwrite = args.optionFound("overwrite");
if (!patchSet.size())
{
FatalErrorInFunction
<< "Cannot find any patches in set " << patches << endl
<< "Valid patches are " << mesh.boundaryMesh().names()
<< exit(FatalError);
}
label nPatchFaces = 0;
label nPatchEdges = 0;
forAllConstIter(labelHashSet, patchSet, iter)
{
nPatchFaces += mesh.boundaryMesh()[iter.key()].size();
nPatchEdges += mesh.boundaryMesh()[iter.key()].nEdges();
}
forAll(bMesh, patchI)
{
const polyPatch& patch = bMesh[patchI];
if (patchNamesHash.found(patch.name()))
{
patchIDs.insert(patchI);
}
}
// Find cells to refine
forAllConstIter(labelHashSet, patchSet, iter)
{
const polyPatch& pp = mesh.boundaryMesh()[iter.key()];
const labelList& meshPoints = pp.meshPoints();
forAll(meshPoints, pointI)
{
label meshPointI = meshPoints[pointI];
const labelList& pCells = mesh.pointCells()[meshPointI];
forAll(pCells, pCellI)
{
cutCells.insert(pCells[pCellI]);
}
forAll(mc, celli)
{
const cell& curCell = cells[mc[celli]];
forAll(curCell, facei)
{
// Check if the face is in the master zone. If not, remove it
if
(
mesh.faceZones().whichZone(curCell[facei])
!= faceZoneID_.index()
)
{
facesToRemoveMap.insert(curCell[facei]);
}
}
}
// Step from faceI (on side cellI) to connected face & cell without crossing
// fenceEdges.
void Foam::regionSide::visitConnectedFaces
(
const primitiveMesh& mesh,
const labelHashSet& region,
const labelHashSet& fenceEdges,
const label cellI,
const label faceI,
labelHashSet& visitedFace
)
{
if (!visitedFace.found(faceI))
{
if (debug)
{
Info<< "visitConnectedFaces : cellI:" << cellI << " faceI:"
<< faceI << " isOwner:" << (cellI == mesh.faceOwner()[faceI])
<< endl;
}
// Mark as visited
visitedFace.insert(faceI);
// Mark which side of face was visited.
if (cellI == mesh.faceOwner()[faceI])
{
sideOwner_.insert(faceI);
}
// Visit all neighbouring faces on faceSet. Stay on this 'side' of
// face by doing edge-face-cell walk.
const labelList& fEdges = mesh.faceEdges()[faceI];
forAll(fEdges, fEdgeI)
{
label edgeI = fEdges[fEdgeI];
if (!fenceEdges.found(edgeI))
{
// Step along faces on edge from cell to cell until
// we hit face on faceSet.
// Find face reachable from edge
label otherFaceI = otherFace(mesh, cellI, faceI, edgeI);
if (mesh.isInternalFace(otherFaceI))
{
label otherCellI = cellI;
// Keep on crossing faces/cells until back on face on
// surface
while (!region.found(otherFaceI))
{
visitedFace.insert(otherFaceI);
if (debug)
{
Info<< "visitConnectedFaces : cellI:" << cellI
<< " found insideEdgeFace:" << otherFaceI
<< endl;
}
// Cross otherFaceI into neighbouring cell
otherCellI =
meshTools::otherCell
(
mesh,
otherCellI,
otherFaceI
);
otherFaceI =
otherFace
(
mesh,
otherCellI,
otherFaceI,
edgeI
);
}
visitConnectedFaces
(
mesh,
region,
fenceEdges,
otherCellI,
otherFaceI,
visitedFace
);
}
}
}
}
bool Foam::motionSmootherAlgo::checkMesh
(
const bool report,
const polyMesh& mesh,
const dictionary& dict,
const labelList& checkFaces,
const List<labelPair>& baffles,
labelHashSet& wrongFaces
)
{
const scalar maxNonOrtho
(
readScalar(dict.lookup("maxNonOrtho", true))
);
const scalar minVol
(
readScalar(dict.lookup("minVol", true))
);
const scalar minTetQuality
(
readScalar(dict.lookup("minTetQuality", true))
);
const scalar maxConcave
(
readScalar(dict.lookup("maxConcave", true))
);
const scalar minArea
(
readScalar(dict.lookup("minArea", true))
);
const scalar maxIntSkew
(
readScalar(dict.lookup("maxInternalSkewness", true))
);
const scalar maxBounSkew
(
readScalar(dict.lookup("maxBoundarySkewness", true))
);
const scalar minWeight
(
readScalar(dict.lookup("minFaceWeight", true))
);
const scalar minVolRatio
(
readScalar(dict.lookup("minVolRatio", true))
);
const scalar minTwist
(
readScalar(dict.lookup("minTwist", true))
);
const scalar minTriangleTwist
(
readScalar(dict.lookup("minTriangleTwist", true))
);
scalar minFaceFlatness = -1.0;
dict.readIfPresent("minFaceFlatness", minFaceFlatness, true);
const scalar minDet
(
readScalar(dict.lookup("minDeterminant", true))
);
label nWrongFaces = 0;
Info<< "Checking faces in error :" << endl;
//Pout.setf(ios_base::left);
if (maxNonOrtho < 180.0-SMALL)
{
polyMeshGeometry::checkFaceDotProduct
(
report,
maxNonOrtho,
mesh,
mesh.cellCentres(),
mesh.faceAreas(),
checkFaces,
baffles,
&wrongFaces
);
label nNewWrongFaces = returnReduce(wrongFaces.size(), sumOp<label>());
Info<< " non-orthogonality > "
<< setw(3) << maxNonOrtho
<< " degrees : "
<< nNewWrongFaces-nWrongFaces << endl;
nWrongFaces = nNewWrongFaces;
}
if (minVol > -GREAT)
{
polyMeshGeometry::checkFacePyramids
(
report,
minVol,
mesh,
mesh.cellCentres(),
mesh.points(),
checkFaces,
baffles,
&wrongFaces
);
label nNewWrongFaces = returnReduce(wrongFaces.size(), sumOp<label>());
Info<< " faces with face pyramid volume < "
<< setw(5) << minVol << " : "
<< nNewWrongFaces-nWrongFaces << endl;
nWrongFaces = nNewWrongFaces;
}
if (minTetQuality > -GREAT)
{
polyMeshGeometry::checkFaceTets
(
report,
minTetQuality,
mesh,
mesh.cellCentres(),
mesh.faceCentres(),
mesh.points(),
checkFaces,
baffles,
&wrongFaces
);
label nNewWrongFaces = returnReduce(wrongFaces.size(), sumOp<label>());
Info<< " faces with face-decomposition tet quality < "
<< setw(5) << minTetQuality << " : "
<< nNewWrongFaces-nWrongFaces << endl;
nWrongFaces = nNewWrongFaces;
}
if (maxConcave < 180.0-SMALL)
{
polyMeshGeometry::checkFaceAngles
(
report,
maxConcave,
mesh,
mesh.faceAreas(),
mesh.points(),
checkFaces,
&wrongFaces
);
label nNewWrongFaces = returnReduce(wrongFaces.size(), sumOp<label>());
Info<< " faces with concavity > "
<< setw(3) << maxConcave
<< " degrees : "
<< nNewWrongFaces-nWrongFaces << endl;
nWrongFaces = nNewWrongFaces;
}
if (minArea > -SMALL)
{
polyMeshGeometry::checkFaceArea
(
report,
minArea,
mesh,
mesh.faceAreas(),
checkFaces,
&wrongFaces
);
label nNewWrongFaces = returnReduce(wrongFaces.size(), sumOp<label>());
Info<< " faces with area < "
<< setw(5) << minArea
<< " m^2 : "
<< nNewWrongFaces-nWrongFaces << endl;
nWrongFaces = nNewWrongFaces;
}
if (maxIntSkew > 0 || maxBounSkew > 0)
{
polyMeshGeometry::checkFaceSkewness
(
report,
maxIntSkew,
maxBounSkew,
mesh,
mesh.points(),
mesh.cellCentres(),
mesh.faceCentres(),
mesh.faceAreas(),
checkFaces,
baffles,
&wrongFaces
);
label nNewWrongFaces = returnReduce(wrongFaces.size(), sumOp<label>());
Info<< " faces with skewness > "
<< setw(3) << maxIntSkew
<< " (internal) or " << setw(3) << maxBounSkew
<< " (boundary) : " << nNewWrongFaces-nWrongFaces << endl;
nWrongFaces = nNewWrongFaces;
}
if (minWeight >= 0 && minWeight < 1)
{
polyMeshGeometry::checkFaceWeights
(
report,
minWeight,
mesh,
mesh.cellCentres(),
mesh.faceCentres(),
mesh.faceAreas(),
checkFaces,
baffles,
&wrongFaces
);
label nNewWrongFaces = returnReduce(wrongFaces.size(), sumOp<label>());
Info<< " faces with interpolation weights (0..1) < "
<< setw(5) << minWeight
<< " : "
<< nNewWrongFaces-nWrongFaces << endl;
nWrongFaces = nNewWrongFaces;
}
if (minVolRatio >= 0)
{
polyMeshGeometry::checkVolRatio
(
report,
minVolRatio,
mesh,
mesh.cellVolumes(),
checkFaces,
baffles,
&wrongFaces
);
label nNewWrongFaces = returnReduce(wrongFaces.size(), sumOp<label>());
Info<< " faces with volume ratio of neighbour cells < "
<< setw(5) << minVolRatio
<< " : "
<< nNewWrongFaces-nWrongFaces << endl;
nWrongFaces = nNewWrongFaces;
}
if (minTwist > -1)
{
//Pout<< "Checking face twist: dot product of face normal "
// << "with face triangle normals" << endl;
polyMeshGeometry::checkFaceTwist
(
report,
minTwist,
mesh,
mesh.cellCentres(),
mesh.faceAreas(),
mesh.faceCentres(),
mesh.points(),
checkFaces,
&wrongFaces
);
label nNewWrongFaces = returnReduce(wrongFaces.size(), sumOp<label>());
Info<< " faces with face twist < "
<< setw(5) << minTwist
<< " : "
<< nNewWrongFaces-nWrongFaces << endl;
nWrongFaces = nNewWrongFaces;
}
if (minTriangleTwist > -1)
{
//Pout<< "Checking triangle twist: dot product of consecutive triangle"
// << " normals resulting from face-centre decomposition" << endl;
polyMeshGeometry::checkTriangleTwist
(
report,
minTriangleTwist,
mesh,
mesh.faceAreas(),
mesh.faceCentres(),
mesh.points(),
checkFaces,
&wrongFaces
);
label nNewWrongFaces = returnReduce(wrongFaces.size(), sumOp<label>());
Info<< " faces with triangle twist < "
<< setw(5) << minTriangleTwist
<< " : "
<< nNewWrongFaces-nWrongFaces << endl;
nWrongFaces = nNewWrongFaces;
}
if (minFaceFlatness > -SMALL)
{
polyMeshGeometry::checkFaceFlatness
(
report,
minFaceFlatness,
mesh,
mesh.faceAreas(),
mesh.faceCentres(),
mesh.points(),
checkFaces,
&wrongFaces
);
label nNewWrongFaces = returnReduce(wrongFaces.size(), sumOp<label>());
Info<< " faces with flatness < "
<< setw(5) << minFaceFlatness
<< " : "
<< nNewWrongFaces-nWrongFaces << endl;
nWrongFaces = nNewWrongFaces;
}
if (minDet > -1)
{
polyMeshGeometry::checkCellDeterminant
(
report,
minDet,
mesh,
mesh.faceAreas(),
checkFaces,
polyMeshGeometry::affectedCells(mesh, checkFaces),
&wrongFaces
);
label nNewWrongFaces = returnReduce(wrongFaces.size(), sumOp<label>());
Info<< " faces on cells with determinant < "
<< setw(5) << minDet << " : "
<< nNewWrongFaces-nWrongFaces << endl;
nWrongFaces = nNewWrongFaces;
}
//Pout.setf(ios_base::right);
return nWrongFaces > 0;
}
{
label slaveSideCell = own[ftc[facei]];
if (mesh.isInternalFace(ftc[facei]) && slaveSideCell == mc[facei])
{
// Owner cell of the face is being removed.
// Grab the neighbour instead
slaveSideCell = nei[ftc[facei]];
}
ref.setAction(polyRemoveCell(mc[facei], slaveSideCell));
}
// Remove all the faces from the master layer cells which are not in
// the master face layer
labelHashSet facesToRemoveMap(mc.size()*primitiveMesh::facesPerCell_);
const cellList& cells = mesh.cells();
forAll(mc, celli)
{
const cell& curCell = cells[mc[celli]];
forAll(curCell, facei)
{
// Check if the face is in the master zone. If not, remove it
if
(
mesh.faceZones().whichZone(curCell[facei])
!= faceZoneID_.index()
)
// Same check as snapMesh
void checkSnapMesh
(
const Time& runTime,
const polyMesh& mesh,
labelHashSet& wrongFaces
)
{
IOdictionary snapDict
(
IOobject
(
"snapMeshDict",
runTime.system(),
mesh,
IOobject::MUST_READ,
IOobject::NO_WRITE
)
);
// Max nonorthogonality allowed
scalar maxNonOrtho(readScalar(snapDict.lookup("maxNonOrtho")));
primitiveMesh::nonOrthThreshold_ = maxNonOrtho;
// Max concaveness allowed.
scalar maxConcave(readScalar(snapDict.lookup("maxConcave")));
primitiveMesh::faceAngleThreshold_ = maxConcave;
// Min volume allowed (factor of minimum cellVolume)
scalar relMinVol(readScalar(snapDict.lookup("minVol")));
const scalar minCellVol = min(mesh.cellVolumes());
const scalar minPyrVol = relMinVol*minCellVol;
// Min area
scalar minArea(readScalar(snapDict.lookup("minArea")));
if (maxNonOrtho < 180.0 - SMALL)
{
Pout<< "Checking non orthogonality" << endl;
label nOldSize = wrongFaces.size();
mesh.checkFaceOrthogonality(false, &wrongFaces);
Pout<< "Detected " << wrongFaces.size() - nOldSize
<< " faces with non-orthogonality > " << maxNonOrtho << " degrees"
<< endl;
}
if (minPyrVol > -GREAT)
{
Pout<< "Checking face pyramids" << endl;
label nOldSize = wrongFaces.size();
mesh.checkFacePyramids(false, minPyrVol, &wrongFaces);
Pout<< "Detected additional " << wrongFaces.size() - nOldSize
<< " faces with illegal face pyramids" << endl;
}
if (maxConcave < 180.0 - SMALL)
{
Pout<< "Checking face angles" << endl;
label nOldSize = wrongFaces.size();
mesh.checkFaceAngles(false, &wrongFaces);
Pout<< "Detected additional " << wrongFaces.size() - nOldSize
<< " faces with concavity > " << maxConcave << " degrees"
<< endl;
}
if (minArea > -SMALL)
{
Pout<< "Checking face areas" << endl;
label nOldSize = wrongFaces.size();
const scalarField magFaceAreas = mag(mesh.faceAreas());
forAll(magFaceAreas, faceI)
{
if (magFaceAreas[faceI] < minArea)
{
wrongFaces.insert(faceI);
}
}
Pout<< "Detected additional " << wrongFaces.size() - nOldSize
<< " faces with area < " << minArea << " m^2" << endl;
}
void Foam::surfaceSets::getSurfaceSets
(
const polyMesh& mesh,
const fileName&,
const triSurface&,
const triSurfaceSearch& querySurf,
const pointField& outsidePts,
const label nCutLayers,
labelHashSet& inside,
labelHashSet& outside,
labelHashSet& cut
)
{
// Construct search engine on mesh
meshSearch queryMesh(mesh, true);
// Check all 'outside' points
forAll(outsidePts, outsideI)
{
const point& outsidePoint = outsidePts[outsideI];
// Find cell point is in. Linear search.
if (queryMesh.findCell(outsidePoint, -1, false) == -1)
{
FatalErrorIn
(
"surfaceSets::getSurfaceSets"
"(const polyMesh&, const fileName&, const triSurface&"
", const triSurfaceSearch&, const pointField&"
", labelHashSet&, labelHashSet&, labelHashSet&)"
) << "outsidePoint " << outsidePoint
<< " is not inside any cell"
<< exit(FatalError);
}
}
// Cut faces with surface and classify cells
cellClassification cellType
(
mesh,
queryMesh,
querySurf,
outsidePts
);
if (nCutLayers > 0)
{
// Trim cutCells so they are max nCutLayers away (as seen in point-cell
// walk) from outside cells.
cellType.trimCutCells
(
nCutLayers,
cellClassification::OUTSIDE,
cellClassification::INSIDE
);
}
forAll(cellType, cellI)
{
label cType = cellType[cellI];
if (cType == cellClassification::CUT)
{
cut.insert(cellI);
}
else if (cType == cellClassification::INSIDE)
{
inside.insert(cellI);
}
else if (cType == cellClassification::OUTSIDE)
{
outside.insert(cellI);
}
}