bool MeshDistFromPatch::updateCell
(
const polyMesh& mesh,
const label thisCellI,
const label neighbourFaceI,
const MeshDistFromPatch& neighbourInfo,
const scalar tol
#ifdef FOAM_FACECELLWAVE_HAS_TRACKINGDATA
,TrackingData &td
#endif
)
{
const scalar d=mag(
mesh.cellCentres()[thisCellI]
-
mesh.faceCentres()[neighbourFaceI]
);
if(!valid(TRACKDATA)) {
dist_=d+neighbourInfo.dist();
return true;
} else {
const scalar nd=d+neighbourInfo.dist();
if(nd<dist_) {
dist_=nd;
return true;
} else {
return false;
}
}
}
Foam::Cloud<ParticleType>::Cloud
(
const polyMesh& pMesh,
const IDLList<ParticleType>& particles
)
:
cloud(pMesh),
IDLList<ParticleType>(particles),
polyMesh_(pMesh),
allFaces_(pMesh.faces()),
points_(pMesh.points()),
cellFaces_(pMesh.cells()),
allFaceCentres_(pMesh.faceCentres()),
owner_(pMesh.faceOwner()),
neighbour_(pMesh.faceNeighbour()),
meshInfo_(polyMesh_)
{}
Foam::Cloud<ParticleType>::Cloud
(
const polyMesh& pMesh,
const bool checkClass
)
:
cloud(pMesh),
polyMesh_(pMesh),
allFaces_(pMesh.faces()),
points_(pMesh.points()),
cellFaces_(pMesh.cells()),
allFaceCentres_(pMesh.faceCentres()),
owner_(pMesh.faceOwner()),
neighbour_(pMesh.faceNeighbour()),
meshInfo_(polyMesh_)
{
initCloud(checkClass);
}
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;
}
