void
Foam::PrimitivePatch<Face, FaceList, PointField, PointType>::
calcPointEdges() const
{
if (debug)
{
Info<< "PrimitivePatch<Face, FaceList, PointField, PointType>::"
<< "calcPointEdges() : calculating pointEdges"
<< endl;
}
if (pointEdgesPtr_)
{
// it is considered an error to attempt to recalculate
// if already allocated
FatalErrorIn
(
"PrimitivePatch<Face, FaceList, PointField, PointType>::"
"calcPointEdges()"
) << "pointEdges already calculated"
<< abort(FatalError);
}
const edgeList& e = edges();
// set up storage for pointEdges
List<SLList<label> > pointEdges(meshPoints().size());
forAll(e, edgeI)
{
pointEdges[e[edgeI].start()].append(edgeI);
pointEdges[e[edgeI].end()].append(edgeI);
}
Foam::label Foam::edgeMesh::regions(labelList& edgeRegion) const
{
edgeRegion.setSize(edges_.size());
edgeRegion = -1;
label startEdgeI = 0;
label currentRegion = 0;
while (true)
{
while (startEdgeI < edges_.size() && edgeRegion[startEdgeI] != -1)
{
startEdgeI++;
}
if (startEdgeI == edges_.size())
{
break;
}
// Found edge that has not yet been assigned a region.
// Mark connected region with currentRegion starting at startEdgeI.
edgeRegion[startEdgeI] = currentRegion;
labelList edgesToVisit(1, startEdgeI);
while (edgesToVisit.size())
{
// neighbours of current edgesToVisit
DynamicList<label> newEdgesToVisit(edgesToVisit.size());
// Mark all point connected edges with current region.
forAll(edgesToVisit, i)
{
label edgeI = edgesToVisit[i];
// Mark connected edges
const edge& e = edges_[edgeI];
forAll(e, fp)
{
const labelList& pEdges = pointEdges()[e[fp]];
forAll(pEdges, pEdgeI)
{
label nbrEdgeI = pEdges[pEdgeI];
if (edgeRegion[nbrEdgeI] == -1)
{
edgeRegion[nbrEdgeI] = currentRegion;
newEdgesToVisit.append(nbrEdgeI);
}
}
}
}
edgesToVisit.transfer(newEdgesToVisit);
}
void Foam::primitiveMesh::calcPointPoints() const
{
if (debug)
{
Pout<< "primitiveMesh::calcPointPoints() : "
<< "calculating pointPoints"
<< endl;
if (debug == -1)
{
// For checking calls:abort so we can quickly hunt down
// origin of call
FatalErrorIn("primitiveMesh::calcPointPoints()")
<< abort(FatalError);
}
}
// It is an error to attempt to recalculate pointPoints
// if the pointer is already set
if (ppPtr_)
{
FatalErrorIn("primitiveMesh::calcPointPoints() const")
<< "pointPoints already calculated"
<< abort(FatalError);
}
else
{
const edgeList& e = edges();
const labelListList& pe = pointEdges();
ppPtr_ = new labelListList(pe.size());
labelListList& pp = *ppPtr_;
forAll (pe, pointI)
{
pp[pointI].setSize(pe[pointI].size());
forAll (pe[pointI], ppi)
{
if (e[pe[pointI][ppi]].start() == pointI)
{
pp[pointI][ppi] = e[pe[pointI][ppi]].end();
}
else if (e[pe[pointI][ppi]].end() == pointI)
{
pp[pointI][ppi] = e[pe[pointI][ppi]].start();
}
else
{
FatalErrorIn("primitiveMesh::calcPointPoints() const")
<< "something wrong with edges"
<< abort(FatalError);
}
}
}
}
void
Foam::PrimitivePatch<Face, FaceList, PointField, PointType>::
calcEdgeLoops() const
{
if (debug)
{
Info<< "PrimitivePatch<Face, FaceList, PointField, PointType>::"
<< "calcEdgeLoops() : "
<< "calculating boundary edge loops"
<< endl;
}
if (edgeLoopsPtr_)
{
// it is considered an error to attempt to recalculate
// if already allocated
FatalErrorIn
(
"PrimitivePatch<Face, FaceList, PointField, PointType>::"
"calcEdgeLoops()"
) << "edge loops already calculated"
<< abort(FatalError);
}
const edgeList& patchEdges = edges();
label nIntEdges = nInternalEdges();
label nBdryEdges = patchEdges.size() - nIntEdges;
if (nBdryEdges == 0)
{
edgeLoopsPtr_ = new labelListList(0);
return;
}
const labelListList& patchPointEdges = pointEdges();
//
// Walk point-edge-point and assign loop number
//
// Loop per (boundary) edge.
labelList loopNumber(nBdryEdges, -1);
// Size return list plenty big
edgeLoopsPtr_ = new labelListList(nBdryEdges);
labelListList& edgeLoops = *edgeLoopsPtr_;
// Current loop number.
label loopI = 0;
while (true)
{
// Find edge not yet given a loop number.
label currentEdgeI = -1;
for (label edgeI = nIntEdges; edgeI < patchEdges.size(); edgeI++)
{
if (loopNumber[edgeI-nIntEdges] == -1)
{
currentEdgeI = edgeI;
break;
}
}
if (currentEdgeI == -1)
{
// Did not find edge not yet assigned a loop number so done all.
break;
}
// Temporary storage for vertices of current loop
dynamicLabelList loop(nBdryEdges);
// Walk from first all the way round, assigning loops
label currentVertI = patchEdges[currentEdgeI].start();
do
{
loop.append(currentVertI);
loopNumber[currentEdgeI - nIntEdges] = loopI;
// Step to next vertex
currentVertI = patchEdges[currentEdgeI].otherVertex(currentVertI);
// Step to next (unmarked, boundary) edge.
const labelList& curEdges = patchPointEdges[currentVertI];
currentEdgeI = -1;
forAll(curEdges, pI)
{
label edgeI = curEdges[pI];
if (edgeI >= nIntEdges && (loopNumber[edgeI - nIntEdges] == -1))
{
// Unassigned boundary edge.
currentEdgeI = edgeI;
break;
}
}
}
while (currentEdgeI != -1);
// Done all for current loop. Transfer to edgeLoops.
edgeLoops[loopI].transfer(loop);
loopI++;
}
edgeLoops.setSize(loopI);
if (debug)
{
Info<< "PrimitivePatch<Face, FaceList, PointField, PointType>::"
<< "calcEdgeLoops() : "
<< "finished calculating boundary edge loops"
<< endl;
}
}
