bool MeshTopologyTests::testCellsForEntity()
{
bool success = true;
// to begin, a simple test that cellsForEntity()'s side ordinals are consistent
MeshTopologyPtr mesh2D = makeRectMesh(0.0, 0.0, 1.0, 1.0, 1, 1);
IndexType cellID = 0;
CellPtr cell = mesh2D->getCell(cellID); // the only cell in the mesh
int spaceDim = mesh2D->getDimension();
int sideDim = spaceDim - 1;
for (int d=0; d<spaceDim; d++)
{
int scCount = cell->topology()->getSubcellCount(d);
for (int scord=0; scord<scCount; scord++)
{
IndexType scEntityIndex = cell->entityIndex(d, scord);
set< pair<IndexType, unsigned> > cellsContainingEntity = mesh2D->getCellsContainingEntity(d, scEntityIndex);
vector<IndexType> sidesContainingEntity = mesh2D->getSidesContainingEntity(d, scEntityIndex);
if (cellsContainingEntity.size() != 1)
{
cout << "cellsContainingEntity should have exactly one entry, but has " << cellsContainingEntity.size() << endl;
success = false;
}
else
{
pair<IndexType, unsigned> cellEntry = *(cellsContainingEntity.begin());
// cout << "for d " << d << ", scord " << scord << ", cell containing entity is (" << cellEntry.first << ", " << cellEntry.second << ")\n";
if (cellEntry.first != cellID)
{
cout << "Expected cellEntry.first = " << cellID << ", but is " << cellEntry.first << endl;
success = false;
}
else
{
unsigned sideOrdinal = cellEntry.second;
IndexType sideEntityIndex = cell->entityIndex(sideDim, sideOrdinal);
if (std::find(sidesContainingEntity.begin(), sidesContainingEntity.end(), sideEntityIndex) == sidesContainingEntity.end())
{
cout << "The side returned by getCellsContainingEntity() does not contain the specified entity.\n";
success = false;
}
}
}
}
}
return success;
}
bool MeshTestUtility::constraintIsConsistent(MeshTopologyViewPtr meshTopo, AnnotatedEntity &constrainingEntity,
int d, IndexType constrainedEntityIndex, bool requireConstrainingEntityBelongToActiveCell)
{
int sideDim = meshTopo->getDimension() - 1;
CellPtr constrainingCell = meshTopo->getCell(constrainingEntity.cellID);
int constrainingSubcordInCell = CamelliaCellTools::subcellOrdinalMap(constrainingCell->topology(),
sideDim, constrainingEntity.sideOrdinal,
constrainingEntity.dimension, constrainingEntity.subcellOrdinal);
IndexType constrainingEntityIndex = constrainingCell->entityIndex(constrainingEntity.dimension, constrainingSubcordInCell);
bool isAncestor = meshTopo->entityIsGeneralizedAncestor(constrainingEntity.dimension, constrainingEntityIndex, d, constrainedEntityIndex);
if (!isAncestor) return false;
if (requireConstrainingEntityBelongToActiveCell)
{
set<pair<IndexType,unsigned>> cellEntries = meshTopo->getCellsContainingEntity(constrainingEntity.dimension, constrainingEntityIndex);
auto activeCells = &meshTopo->getActiveCellIndices();
for (auto cellEntry : cellEntries)
{
IndexType cellID = cellEntry.first;
if (activeCells->find(cellID) != activeCells->end()) return true; // found an active cell, and isAncestor is true
}
return false;
}
return isAncestor;
}
bool MeshTestUtility::checkConstraintConsistency(MeshPtr meshMinimumRule)
{
MeshTopologyViewPtr meshTopo = meshMinimumRule->getTopology();
GDAMinimumRule* minRule = dynamic_cast<GDAMinimumRule*>(meshMinimumRule->globalDofAssignment().get());
bool consistent = true;
for (IndexType cellID : meshMinimumRule->cellIDsInPartition())
{
CellConstraints constraints = minRule->getCellConstraints(cellID);
CellPtr cell = meshTopo->getCell(cellID);
CellTopoPtr cellTopo = cell->topology();
for (int d=0; d<cellTopo->getDimension(); d++)
{
int scCount = cellTopo->getSubcellCount(d);
for (int scord=0; scord<scCount; scord++)
{
IndexType entityIndex = cell->entityIndex(d, scord);
AnnotatedEntity constrainingEntity = constraints.subcellConstraints[d][scord];
bool isConsistent = constraintIsConsistent(meshTopo, constrainingEntity, d, entityIndex, true);
if (!isConsistent)
{
cout << "Failed consistency test for standard constraints on cell " << cellID << ", " << CamelliaCellTools::entityTypeString(d) << " " << scord << endl;
consistent = false;
break;
}
// now, check space-only constraints (for space-time meshes), if these are defined for this subcell
if (constraints.spatialSliceConstraints != Teuchos::null)
{
AnnotatedEntity constrainingEntityForSpatialSlice = constraints.spatialSliceConstraints->subcellConstraints[d][scord];
if (constrainingEntityForSpatialSlice.cellID != -1) {
isConsistent = constraintIsConsistent(meshTopo, constrainingEntityForSpatialSlice, d, entityIndex, true);
}
if (!isConsistent)
{
cout << "Failed consistency test for spatial slice on cell " << cellID << ", " << CamelliaCellTools::entityTypeString(d) << " " << scord << endl;
consistent = false;
break;
}
}
}
if (!consistent) break;
}
if (!consistent) break;
}
return consistent;
}
bool MeshTopologyTests::testEntityConstraints()
{
bool success = true;
// make two simple meshes
MeshTopologyPtr mesh2D = makeRectMesh(0.0, 0.0, 2.0, 1.0,
2, 1);
MeshTopologyPtr mesh3D = makeHexMesh(0.0, 0.0, 0.0, 2.0, 4.0, 3.0,
2, 2, 1);
unsigned vertexDim = 0;
unsigned edgeDim = 1;
unsigned faceDim = 2;
// first, check that unconstrained edges and faces are unconstrained
set< unsigned > boundaryEdges;
set< unsigned > internalEdges;
for (unsigned cellIndex=0; cellIndex<mesh2D->cellCount(); cellIndex++)
{
CellPtr cell = mesh2D->getCell(cellIndex);
unsigned sideCount = cell->getSideCount();
for (unsigned sideOrdinal=0; sideOrdinal<sideCount; sideOrdinal++)
{
unsigned edgeIndex = cell->entityIndex(edgeDim, sideOrdinal);
unsigned numCells = mesh2D->getActiveCellCount(edgeDim,edgeIndex);
if (numCells == 1) // boundary edge
{
boundaryEdges.insert(edgeIndex);
}
else if (numCells == 2)
{
internalEdges.insert(edgeIndex);
}
else
{
success = false;
cout << "testEntityConstraints: In initial 2D mesh, edge " << edgeIndex << " has active cell count of " << numCells << ".\n";
}
}
}
if (internalEdges.size() != 1)
{
success = false;
cout << "testEntityConstraints: In initial 2D mesh, there are " << internalEdges.size() << " internal edges (expected 1).\n";
}
for (set<unsigned>::iterator edgeIt=internalEdges.begin(); edgeIt != internalEdges.end(); edgeIt++)
{
unsigned edgeIndex = *edgeIt;
unsigned constrainingEntityIndex = mesh2D->getConstrainingEntity(edgeDim,edgeIndex).first;
if (constrainingEntityIndex != edgeIndex)
{
success = false;
cout << "testEntityConstraints: In initial 2D mesh, internal edge is constrained by a different edge.\n";
}
}
set<unsigned> boundaryFaces;
set<unsigned> internalFaces;
map<unsigned, vector<unsigned> > faceToEdges;
for (unsigned cellIndex=0; cellIndex<mesh3D->cellCount(); cellIndex++)
{
CellPtr cell = mesh3D->getCell(cellIndex);
unsigned sideCount = cell->getSideCount();
for (unsigned sideOrdinal=0; sideOrdinal<sideCount; sideOrdinal++)
{
unsigned faceIndex = cell->entityIndex(faceDim, sideOrdinal);
unsigned numCells = mesh3D->getActiveCellCount(faceDim,faceIndex);
if (numCells == 1) // boundary face
{
boundaryFaces.insert(faceIndex);
}
else if (numCells == 2)
{
internalFaces.insert(faceIndex);
}
else
{
success = false;
cout << "testEntityConstraints: In initial 3D mesh, face " << faceIndex << " has active cell count of " << numCells << ".\n";
}
if (faceToEdges.find(faceIndex) == faceToEdges.end())
{
CellTopoPtr faceTopo = cell->topology()->getSubcell(faceDim, sideOrdinal);
unsigned numEdges = faceTopo->getSubcellCount(edgeDim);
vector<unsigned> edgeIndices(numEdges);
for (unsigned edgeOrdinal=0; edgeOrdinal<numEdges; edgeOrdinal++)
{
edgeIndices[edgeOrdinal] = mesh3D->getFaceEdgeIndex(faceIndex, edgeOrdinal);
}
}
}
}
if (internalFaces.size() != 4)
{
success = false;
cout << "testEntityConstraints: In initial 3D mesh, there are " << internalFaces.size() << " internal faces (expected 4).\n";
}
for (set<unsigned>::iterator faceIt=internalFaces.begin(); faceIt != internalFaces.end(); faceIt++)
{
unsigned faceIndex = *faceIt;
unsigned constrainingEntityIndex = mesh3D->getConstrainingEntity(faceDim,faceIndex).first;
if (constrainingEntityIndex != faceIndex)
{
success = false;
cout << "testEntityConstraints: In initial 3D mesh, internal face is constrained by a different face.\n";
}
}
// now, make a single refinement in each mesh:
unsigned cellToRefine2D = 0, cellToRefine3D = 3;
mesh2D->refineCell(cellToRefine2D, RefinementPattern::regularRefinementPatternQuad(), mesh2D->cellCount());
mesh3D->refineCell(cellToRefine3D, RefinementPattern::regularRefinementPatternHexahedron(), mesh3D->cellCount());
// printMeshInfo(mesh2D);
// figure out which faces/edges were refined and add the corresponding
map<unsigned,pair<IndexType,unsigned> > expectedEdgeConstraints2D;
set<unsigned> refinedEdges;
for (set<unsigned>::iterator edgeIt=boundaryEdges.begin(); edgeIt != boundaryEdges.end(); edgeIt++)
{
set<unsigned> children = mesh2D->getChildEntitiesSet(edgeDim, *edgeIt);
if (children.size() > 0)
{
refinedEdges.insert(*edgeIt);
boundaryEdges.insert(children.begin(), children.end());
}
}
for (set<unsigned>::iterator edgeIt=internalEdges.begin(); edgeIt != internalEdges.end(); edgeIt++)
{
set<unsigned> children = mesh2D->getChildEntitiesSet(edgeDim, *edgeIt);
if (children.size() > 0)
{
refinedEdges.insert(*edgeIt);
internalEdges.insert(children.begin(), children.end());
for (set<unsigned>::iterator childIt = children.begin(); childIt != children.end(); childIt++)
{
unsigned childIndex = *childIt;
expectedEdgeConstraints2D[childIndex] = make_pair(*edgeIt, edgeDim);
}
}
}
// 1 quad refined: expect 4 refined edges
if (refinedEdges.size() != 4)
{
success = false;
cout << "After initial refinement, 2D mesh has " << refinedEdges.size() << " refined edges (expected 4).\n";
}
checkConstraints(mesh2D, edgeDim, expectedEdgeConstraints2D);
set<unsigned> refinedFaces;
map<unsigned,pair<IndexType,unsigned> > expectedFaceConstraints3D;
map<unsigned,pair<IndexType,unsigned> > expectedEdgeConstraints3D;
for (set<unsigned>::iterator faceIt=boundaryFaces.begin(); faceIt != boundaryFaces.end(); faceIt++)
{
set<unsigned> children = mesh3D->getChildEntitiesSet(faceDim, *faceIt);
if (children.size() > 0)
{
refinedFaces.insert(*faceIt);
boundaryFaces.insert(children.begin(), children.end());
}
}
for (set<unsigned>::iterator faceIt=internalFaces.begin(); faceIt != internalFaces.end(); faceIt++)
{
vector<unsigned> children = mesh3D->getChildEntities(faceDim, *faceIt);
if (children.size() > 0)
{
refinedFaces.insert(*faceIt);
internalFaces.insert(children.begin(), children.end());
for (unsigned childOrdinal = 0; childOrdinal < children.size(); childOrdinal++)
{
unsigned childIndex = children[childOrdinal];
expectedFaceConstraints3D[childIndex] = make_pair(*faceIt, faceDim);
unsigned numEdges = 4;
unsigned internalEdgeCount = 0; // for each child of a quad, we expect to have 2 internal edges
for (unsigned edgeOrdinal=0; edgeOrdinal<numEdges; edgeOrdinal++)
{
unsigned edgeIndex = mesh3D->getFaceEdgeIndex(childIndex, edgeOrdinal);
unsigned activeCellCount = mesh3D->getActiveCellCount(edgeDim, edgeIndex);
if (activeCellCount==2)
{
internalEdgeCount++;
expectedEdgeConstraints3D[edgeIndex] = make_pair(*faceIt, faceDim);
}
else if (activeCellCount==1) // hanging edge
{
if (! mesh3D->entityHasParent(edgeDim, edgeIndex))
{
cout << "Hanging edge with edgeIndex " << edgeIndex << " (in face " << childIndex << ") does not have a parent edge.\n";
cout << "Edge vertices:\n";
mesh3D->printEntityVertices(edgeDim, edgeIndex);
cout << "Face vertices:\n";
mesh3D->printEntityVertices(faceDim, childIndex);
success = false;
}
else
{
unsigned edgeParentIndex = mesh3D->getEntityParent(edgeDim, edgeIndex);
expectedEdgeConstraints3D[edgeIndex] = make_pair(edgeParentIndex, edgeDim);
}
}
else
{
cout << "Unexpected number of active cells: " << activeCellCount << endl;
}
}
if (internalEdgeCount != 2)
{
cout << "Expected internalEdgeCount to be 2; was " << internalEdgeCount << endl;
success = false;
}
}
}
}
// 1 hex refined: expect 6 refined faces
if (refinedFaces.size() != 6)
{
success = false;
cout << "After initial refinement, 3D mesh has " << refinedFaces.size() << " refined faces (expected 6).\n";
}
if (! checkConstraints(mesh3D, faceDim, expectedFaceConstraints3D, "refined 3D mesh") )
{
cout << "Failed face constraint check for refined 3D mesh." << endl;
success = false;
}
if (! checkConstraints(mesh3D, edgeDim, expectedEdgeConstraints3D, "refined 3D mesh") )
{
cout << "Failed edge constraint check for refined 3D mesh." << endl;
success = false;
}
// now, we refine one of the children of the refined cells in each mesh, to produce a 2-level constraint
set<unsigned> edgeChildren2D;
set<unsigned> cellsForEdgeChildren2D;
for (map<unsigned,pair<IndexType,unsigned> >::iterator edgeConstraint=expectedEdgeConstraints2D.begin();
edgeConstraint != expectedEdgeConstraints2D.end(); edgeConstraint++)
{
edgeChildren2D.insert(edgeConstraint->first);
unsigned cellIndex = mesh2D->getActiveCellIndices(edgeDim, edgeConstraint->first).begin()->first;
cellsForEdgeChildren2D.insert(cellIndex);
// cout << "cellsForEdgeChildren2D: " << cellIndex << endl;
}
// one of these has (1,0) as one of its vertices. Let's figure out which one:
unsigned vertexIndex;
if (! mesh2D->getVertexIndex(makeVertex(1, 0), vertexIndex) )
{
cout << "Error: vertex not found.\n";
success = false;
}
vector< pair<unsigned,unsigned> > cellsForVertex = mesh2D->getActiveCellIndices(vertexDim, vertexIndex);
if (cellsForVertex.size() != 2)
{
cout << "cellsForVertex should have 2 entries; has " << cellsForVertex.size() << endl;
success = false;
}
unsigned childCellForVertex, childCellConstrainedEdge;
set<unsigned> childNewlyConstrainingEdges; // the two interior edges that we break
for (vector< pair<unsigned,unsigned> >::iterator cellIt=cellsForVertex.begin(); cellIt != cellsForVertex.end(); cellIt++)
{
// cout << "cellsForVertex: " << cellIt->first << endl;
if ( cellsForEdgeChildren2D.find( cellIt->first ) != cellsForEdgeChildren2D.end() )
{
// found match
childCellForVertex = cellIt->first;
// now, figure out which of the "edgeChildren2D" is shared by this cell:
CellPtr cell = mesh2D->getCell(childCellForVertex);
unsigned numEdges = cell->getSideCount();
for (unsigned edgeOrdinal=0; edgeOrdinal<numEdges; edgeOrdinal++)
{
unsigned edgeIndex = cell->entityIndex(edgeDim, edgeOrdinal);
if (edgeChildren2D.find(edgeIndex) != edgeChildren2D.end())
{
childCellConstrainedEdge = edgeIndex;
}
else if ( mesh2D->getActiveCellCount(edgeDim, edgeIndex) == 2 )
{
childNewlyConstrainingEdges.insert(edgeIndex);
}
}
}
}
if (childNewlyConstrainingEdges.size() != 2)
{
cout << "Expected 2 newly constraining edges after 2nd refinement of 2D mesh, but found " << childNewlyConstrainingEdges.size() << endl;
success = false;
}
// refine the cell that matches (1,0):
mesh2D->refineCell(childCellForVertex, RefinementPattern::regularRefinementPatternQuad(), mesh2D->cellCount());
// now, fix the expected edge constraints, then check them...
set<unsigned> childEdges = mesh2D->getChildEntitiesSet(edgeDim, childCellConstrainedEdge);
if (childEdges.size() != 2)
{
cout << "Expected 2 child edges, but found " << childEdges.size() << ".\n";
success = false;
}
for (set<unsigned>::iterator edgeIt = childEdges.begin(); edgeIt != childEdges.end(); edgeIt++)
{
expectedEdgeConstraints2D[*edgeIt] = expectedEdgeConstraints2D[childCellConstrainedEdge];
}
expectedEdgeConstraints2D.erase(childCellConstrainedEdge);
for (set<unsigned>::iterator edgeIt = childNewlyConstrainingEdges.begin(); edgeIt != childNewlyConstrainingEdges.end(); edgeIt++)
{
set<unsigned> newChildEdges = mesh2D->getChildEntitiesSet(edgeDim, *edgeIt);
for (set<unsigned>::iterator newEdgeIt = newChildEdges.begin(); newEdgeIt != newChildEdges.end(); newEdgeIt++)
{
expectedEdgeConstraints2D[*newEdgeIt] = make_pair(*edgeIt,edgeDim);
}
}
if (! checkConstraints(mesh2D, edgeDim, expectedEdgeConstraints2D, "twice-refined 2D mesh") )
{
cout << "Failed constraint check for twice-refined 2D mesh." << endl;
success = false;
}
// now, do a second level of refinement for 3D mesh
// one of these has (1,2,0) as one of its vertices. Let's figure out which one:
if (! mesh3D->getVertexIndex(makeVertex(1, 2, 0), vertexIndex) )
{
cout << "Error: vertex not found.\n";
success = false;
}
cellsForVertex = mesh3D->getActiveCellIndices(vertexDim, vertexIndex);
if (cellsForVertex.size() != 4)
{
cout << "cellsForVertex should have 4 entries; has " << cellsForVertex.size() << endl;
success = false;
}
vector<unsigned> justCellsForVertex;
for (vector< pair<unsigned,unsigned> >::iterator entryIt = cellsForVertex.begin(); entryIt != cellsForVertex.end(); entryIt++)
{
justCellsForVertex.push_back(entryIt->first);
}
vector<unsigned> childCellIndices = mesh3D->getCell(cellToRefine3D)->getChildIndices(mesh3D);
std::sort(childCellIndices.begin(), childCellIndices.end());
vector<unsigned> matches(childCellIndices.size() + cellsForVertex.size());
vector<unsigned>::iterator matchEnd = std::set_intersection(justCellsForVertex.begin(), justCellsForVertex.end(), childCellIndices.begin(), childCellIndices.end(), matches.begin());
matches.resize(matchEnd-matches.begin());
if (matches.size() != 1)
{
cout << "matches should have exactly one entry, but has " << matches.size();
success = false;
}
unsigned childCellIndex = matches[0];
CellPtr childCell = mesh3D->getCell(childCellIndex);
set<unsigned> childInteriorUnconstrainedFaces;
set<unsigned> childInteriorConstrainedFaces;
unsigned faceCount = childCell->getSideCount();
for (unsigned faceOrdinal=0; faceOrdinal<faceCount; faceOrdinal++)
{
unsigned faceIndex = childCell->entityIndex(faceDim, faceOrdinal);
if (mesh3D->getActiveCellCount(faceDim, faceIndex) == 1)
{
// that's an interior constrained face, or a boundary face
if (expectedFaceConstraints3D.find(faceIndex) != expectedFaceConstraints3D.end())
{
// constrained face
childInteriorConstrainedFaces.insert(faceIndex);
}
}
else if (mesh3D->getActiveCellCount(faceDim, faceIndex) == 2)
{
// an interior unconstrained face
childInteriorUnconstrainedFaces.insert(faceIndex);
}
else
{
cout << "Error: unexpected active cell count. Expected 1 or 2, but was " << mesh3D->getActiveCellCount(faceDim, faceIndex) << endl;
success = false;
}
}
// Camellia::print("childInteriorUnconstrainedFaces", childInteriorUnconstrainedFaces);
// Camellia::print("childInteriorConstrainedFaces", childInteriorConstrainedFaces);
mesh3D->refineCell(childCellIndex, RefinementPattern::regularRefinementPatternHexahedron(), mesh3D->cellCount());
// update expected face and edge constraints
// set<unsigned> edgeConstraintsToDrop;
for (set<unsigned>::iterator faceIt=childInteriorConstrainedFaces.begin(); faceIt != childInteriorConstrainedFaces.end(); faceIt++)
{
unsigned faceIndex = *faceIt;
set<unsigned> newChildFaces = mesh3D->getChildEntitiesSet(faceDim, faceIndex);
for (set<unsigned>::iterator newChildIt=newChildFaces.begin(); newChildIt != newChildFaces.end(); newChildIt++)
{
unsigned newChildIndex = *newChildIt;
expectedFaceConstraints3D[newChildIndex] = expectedFaceConstraints3D[faceIndex];
// cout << "Expecting two-level face constraint: face " << newChildIndex << " constrained by face " << expectedFaceConstraints3D[newChildIndex].first << endl;
}
unsigned numEdges = mesh3D->getSubEntityCount(faceDim, faceIndex, edgeDim);
set<IndexType> childEdgesOnParentBoundary;
for (unsigned edgeOrdinal=0; edgeOrdinal<numEdges; edgeOrdinal++)
{
unsigned edgeIndex = mesh3D->getSubEntityIndex(faceDim, faceIndex, edgeDim, edgeOrdinal);
set<unsigned> newChildEdges = mesh3D->getChildEntitiesSet(edgeDim, edgeIndex);
for (set<unsigned>::iterator newChildIt=newChildEdges.begin(); newChildIt != newChildEdges.end(); newChildIt++)
{
unsigned newChildIndex = *newChildIt;
expectedEdgeConstraints3D[newChildIndex] = expectedEdgeConstraints3D[edgeIndex];
// cout << "Expecting two-level edge constraint: edge " << newChildIndex << " constrained by ";
// cout << typeString(expectedEdgeConstraints3D[newChildIndex].second) << " " << expectedEdgeConstraints3D[newChildIndex].first << endl;
childEdgesOnParentBoundary.insert(newChildIndex);
// edgeConstraintsToDrop.insert(edgeIndex);
}
}
for (set<unsigned>::iterator newChildIt=newChildFaces.begin(); newChildIt != newChildFaces.end(); newChildIt++)
{
unsigned newChildFaceIndex = *newChildIt;
int numEdges = mesh3D->getSubEntityCount(faceDim, newChildFaceIndex, edgeDim);
for (unsigned edgeOrdinal=0; edgeOrdinal<numEdges; edgeOrdinal++)
{
unsigned newChildEdgeIndex = mesh3D->getSubEntityIndex(faceDim, newChildFaceIndex, edgeDim, edgeOrdinal);
if (childEdgesOnParentBoundary.find(newChildEdgeIndex) == childEdgesOnParentBoundary.end())
{
expectedEdgeConstraints3D[newChildEdgeIndex] = expectedFaceConstraints3D[faceIndex];
}
}
}
expectedFaceConstraints3D.erase(faceIndex);
}
// for (set<unsigned>::iterator edgeToDropIt=edgeConstraintsToDrop.begin(); edgeToDropIt != edgeConstraintsToDrop.end(); edgeToDropIt++) {
// expectedEdgeConstraints3D.erase(*edgeToDropIt);
// }
for (set<unsigned>::iterator faceIt=childInteriorUnconstrainedFaces.begin(); faceIt != childInteriorUnconstrainedFaces.end(); faceIt++)
{
unsigned faceIndex = *faceIt;
set<unsigned> newChildFaces = mesh3D->getChildEntitiesSet(faceDim, faceIndex);
for (set<unsigned>::iterator newChildIt=newChildFaces.begin(); newChildIt != newChildFaces.end(); newChildIt++)
{
unsigned newChildIndex = *newChildIt;
expectedFaceConstraints3D[newChildIndex] = make_pair(faceIndex, faceDim);
}
expectedFaceConstraints3D.erase(faceIndex);
unsigned numEdges = mesh3D->getSubEntityCount(faceDim, faceIndex, edgeDim);
set<IndexType> childEdgesOnParentBoundary;
for (unsigned edgeOrdinal=0; edgeOrdinal<numEdges; edgeOrdinal++)
{
unsigned edgeIndex = mesh3D->getSubEntityIndex(faceDim, faceIndex, edgeDim, edgeOrdinal);
set<unsigned> newChildEdges = mesh3D->getChildEntitiesSet(edgeDim, edgeIndex);
for (set<unsigned>::iterator newChildIt=newChildEdges.begin(); newChildIt != newChildEdges.end(); newChildIt++)
{
unsigned newChildIndex = *newChildIt;
if (expectedEdgeConstraints3D.find(newChildIndex) == expectedEdgeConstraints3D.end()) // only impose edge constraint if there is not one already present
{
expectedEdgeConstraints3D[newChildIndex] = make_pair(edgeIndex,edgeDim);
}
childEdgesOnParentBoundary.insert(newChildIndex);
}
}
for (set<unsigned>::iterator newChildIt=newChildFaces.begin(); newChildIt != newChildFaces.end(); newChildIt++)
{
unsigned newChildFaceIndex = *newChildIt;
int numEdges = mesh3D->getSubEntityCount(faceDim, newChildFaceIndex, edgeDim);
for (unsigned edgeOrdinal=0; edgeOrdinal<numEdges; edgeOrdinal++)
{
unsigned newChildEdgeIndex = mesh3D->getSubEntityIndex(faceDim, newChildFaceIndex, edgeDim, edgeOrdinal);
if (childEdgesOnParentBoundary.find(newChildEdgeIndex) == childEdgesOnParentBoundary.end())
{
if (expectedEdgeConstraints3D.find(newChildEdgeIndex) == expectedEdgeConstraints3D.end()) // only impose edge constraint if there is not one already present
{
expectedEdgeConstraints3D[newChildEdgeIndex] = make_pair(faceIndex, faceDim);
}
}
}
}
}
if (! checkConstraints(mesh3D, edgeDim, expectedEdgeConstraints3D, "twice-refined 3D mesh") )
{
cout << "Failed edge constraint check for twice-refined 3D mesh." << endl;
success = false;
}
if (! checkConstraints(mesh3D, faceDim, expectedFaceConstraints3D, "twice-refined 3D mesh") )
{
cout << "Failed face constraint check for twice-refined 3D mesh." << endl;
success = false;
}
return success;
}
