MeshPtr MeshTools::timeSliceMesh(MeshPtr spaceTimeMesh, double t,
map<GlobalIndexType, GlobalIndexType> &sliceCellIDToSpaceTimeCellID, int H1OrderForSlice) {
MeshTopologyPtr meshTopo = spaceTimeMesh->getTopology();
set<IndexType> cellIDsToCheck = meshTopo->getRootCellIndices();
set<IndexType> activeCellIDsForTime;
set<IndexType> allActiveCellIDs = meshTopo->getActiveCellIndices();
int spaceDim = meshTopo->getSpaceDim() - 1; // # of true spatial dimensions
MeshTopologyPtr sliceTopo = Teuchos::rcp( new MeshTopology(spaceDim) );
set<IndexType> rootCellIDs = meshTopo->getRootCellIndices();
for (set<IndexType>::iterator rootCellIt = rootCellIDs.begin(); rootCellIt != rootCellIDs.end(); rootCellIt++) {
IndexType rootCellID = *rootCellIt;
FieldContainer<double> physicalNodes = spaceTimeMesh->physicalCellNodesForCell(rootCellID);
if (cellMatches(physicalNodes, t)) { // cell and some subset of its descendents should be included in slice mesh
vector< vector< double > > sliceNodes = timeSliceForCell(physicalNodes, t);
CellTopoPtrLegacy cellTopo = getBottomTopology(meshTopo, rootCellID);
CellPtr sliceCell = sliceTopo->addCell(cellTopo, sliceNodes);
sliceCellIDToSpaceTimeCellID[sliceCell->cellIndex()] = rootCellID;
}
}
MeshPtr sliceMesh = Teuchos::rcp( new Mesh(sliceTopo, spaceTimeMesh->bilinearForm(), H1OrderForSlice, spaceDim) );
// process refinements. For now, we assume isotropic refinements, which means that each refinement in spacetime induces a refinement in the spatial slice
set<IndexType> sliceCellIDsToCheckForRefinement = sliceTopo->getActiveCellIndices();
while (sliceCellIDsToCheckForRefinement.size() > 0) {
set<IndexType>::iterator cellIt = sliceCellIDsToCheckForRefinement.begin();
IndexType sliceCellID = *cellIt;
sliceCellIDsToCheckForRefinement.erase(cellIt);
CellPtr sliceCell = sliceTopo->getCell(sliceCellID);
CellPtr spaceTimeCell = meshTopo->getCell(sliceCellIDToSpaceTimeCellID[sliceCellID]);
if (spaceTimeCell->isParent()) {
set<GlobalIndexType> cellsToRefine;
cellsToRefine.insert(sliceCellID);
sliceMesh->hRefine(cellsToRefine, RefinementPattern::regularRefinementPattern(sliceCell->topology()->getKey()));
vector<IndexType> spaceTimeChildren = spaceTimeCell->getChildIndices();
for (int childOrdinal=0; childOrdinal<spaceTimeChildren.size(); childOrdinal++) {
IndexType childID = spaceTimeChildren[childOrdinal];
FieldContainer<double> childNodes = meshTopo->physicalCellNodesForCell(childID);
if (cellMatches(childNodes, t)) {
vector< vector<double> > childSlice = timeSliceForCell(childNodes, t);
CellPtr childSliceCell = sliceTopo->findCellWithVertices(childSlice);
sliceCellIDToSpaceTimeCellID[childSliceCell->cellIndex()] = childID;
sliceCellIDsToCheckForRefinement.insert(childSliceCell->cellIndex());
}
}
}
}
return sliceMesh;
}
MeshPtr MeshTools::timeSliceMesh(MeshPtr spaceTimeMesh, double t,
map<GlobalIndexType, GlobalIndexType> &sliceCellIDToSpaceTimeCellID, int H1OrderForSlice)
{
MeshTopology* meshTopo = dynamic_cast<MeshTopology*>(spaceTimeMesh->getTopology().get());
TEUCHOS_TEST_FOR_EXCEPTION(!meshTopo, std::invalid_argument, "timeSliceMesh() called with spaceTimeMesh that appears to be pure MeshTopologyView. This is not supported.");
set<IndexType> cellIDsToCheck = meshTopo->getRootCellIndices();
set<IndexType> activeCellIDsForTime;
set<IndexType> allActiveCellIDs = meshTopo->getActiveCellIndices();
int spaceDim = meshTopo->getDimension() - 1; // # of true spatial dimensions
MeshTopologyPtr sliceTopo = Teuchos::rcp( new MeshTopology(spaceDim) );
set<IndexType> rootCellIDs = meshTopo->getRootCellIndices();
for (set<IndexType>::iterator rootCellIt = rootCellIDs.begin(); rootCellIt != rootCellIDs.end(); rootCellIt++)
{
IndexType rootCellID = *rootCellIt;
FieldContainer<double> physicalNodes = spaceTimeMesh->physicalCellNodesForCell(rootCellID);
if (cellMatches(physicalNodes, t)) // cell and some subset of its descendents should be included in slice mesh
{
vector< vector< double > > sliceNodes = timeSliceForCell(physicalNodes, t);
CellTopoPtr cellTopo = getBottomTopology(meshTopo, rootCellID);
GlobalIndexType newCellID = sliceTopo->cellCount();
CellPtr sliceCell = sliceTopo->addCell(newCellID, cellTopo, sliceNodes); // for consistency, this is only valid if run on every MPI rank.
sliceCellIDToSpaceTimeCellID[sliceCell->cellIndex()] = rootCellID;
}
}
MeshPtr sliceMesh = Teuchos::rcp( new Mesh(sliceTopo, spaceTimeMesh->bilinearForm(), H1OrderForSlice, spaceDim) );
// process refinements. For now, we assume isotropic refinements, which means that each refinement in spacetime induces a refinement in the spatial slice
set<IndexType> sliceCellIDsToCheckForRefinement = sliceTopo->getActiveCellIndices();
while (sliceCellIDsToCheckForRefinement.size() > 0)
{
set<IndexType>::iterator cellIt = sliceCellIDsToCheckForRefinement.begin();
IndexType sliceCellID = *cellIt;
sliceCellIDsToCheckForRefinement.erase(cellIt);
CellPtr sliceCell = sliceTopo->getCell(sliceCellID);
CellPtr spaceTimeCell = meshTopo->getCell(sliceCellIDToSpaceTimeCellID[sliceCellID]);
if (spaceTimeCell->isParent(spaceTimeMesh->getTopology()))
{
set<GlobalIndexType> cellsToRefine;
cellsToRefine.insert(sliceCellID);
sliceMesh->hRefine(cellsToRefine, RefinementPattern::regularRefinementPattern(sliceCell->topology()));
vector<IndexType> spaceTimeChildren = spaceTimeCell->getChildIndices(spaceTimeMesh->getTopology());
for (int childOrdinal=0; childOrdinal<spaceTimeChildren.size(); childOrdinal++)
{
IndexType childID = spaceTimeChildren[childOrdinal];
FieldContainer<double> childNodes = meshTopo->physicalCellNodesForCell(childID);
if (cellMatches(childNodes, t))
{
vector< vector<double> > childSlice = timeSliceForCell(childNodes, t);
CellPtr childSliceCell = sliceTopo->findCellWithVertices(childSlice);
sliceCellIDToSpaceTimeCellID[childSliceCell->cellIndex()] = childID;
sliceCellIDsToCheckForRefinement.insert(childSliceCell->cellIndex());
}
}
}
}
MeshPartitionPolicyPtr partitionPolicy = MeshPartitionPolicy::inducedPartitionPolicy(sliceMesh, spaceTimeMesh, sliceCellIDToSpaceTimeCellID);
sliceMesh->setPartitionPolicy(partitionPolicy);
return sliceMesh;
}
bool MeshTestUtility::determineRefTestPointsForNeighbors(MeshTopologyViewPtr meshTopo, CellPtr fineCell, unsigned int sideOrdinal,
FieldContainer<double> &fineSideRefPoints, FieldContainer<double> &fineCellRefPoints,
FieldContainer<double> &coarseSideRefPoints, FieldContainer<double> &coarseCellRefPoints)
{
unsigned spaceDim = meshTopo->getDimension();
unsigned sideDim = spaceDim - 1;
if (spaceDim == 1)
{
fineSideRefPoints.resize(0,0);
coarseSideRefPoints.resize(0,0);
fineCellRefPoints.resize(1,1);
coarseCellRefPoints.resize(1,1);
FieldContainer<double> lineRefNodes(2,1);
CellTopoPtr line = CellTopology::line();
CamelliaCellTools::refCellNodesForTopology(lineRefNodes, line);
fineCellRefPoints[0] = lineRefNodes[sideOrdinal];
unsigned neighborSideOrdinal = fineCell->getNeighborInfo(sideOrdinal, meshTopo).second;
if (neighborSideOrdinal != -1)
{
coarseCellRefPoints[0] = lineRefNodes[neighborSideOrdinal];
return true;
}
else
{
return false;
}
}
pair<GlobalIndexType, unsigned> neighborInfo = fineCell->getNeighborInfo(sideOrdinal, meshTopo);
if (neighborInfo.first == -1)
{
// boundary
return false;
}
CellPtr neighborCell = meshTopo->getCell(neighborInfo.first);
if (neighborCell->isParent(meshTopo))
{
return false; // fineCell isn't the finer of the two...
}
CellTopoPtr fineSideTopo = fineCell->topology()->getSubcell(sideDim, sideOrdinal);
CubatureFactory cubFactory;
int cubDegree = 4; // fairly arbitrary choice: enough to get a decent number of test points...
Teuchos::RCP<Cubature<double> > fineSideTopoCub = cubFactory.create(fineSideTopo, cubDegree);
int numCubPoints = fineSideTopoCub->getNumPoints();
FieldContainer<double> cubPoints(numCubPoints, sideDim);
FieldContainer<double> cubWeights(numCubPoints); // we neglect these...
fineSideTopoCub->getCubature(cubPoints, cubWeights);
FieldContainer<double> sideRefCellNodes(fineSideTopo->getNodeCount(),sideDim);
CamelliaCellTools::refCellNodesForTopology(sideRefCellNodes, fineSideTopo);
int numTestPoints = numCubPoints + fineSideTopo->getNodeCount();
FieldContainer<double> testPoints(numTestPoints, sideDim);
for (int ptOrdinal=0; ptOrdinal<testPoints.dimension(0); ptOrdinal++)
{
if (ptOrdinal<fineSideTopo->getNodeCount())
{
for (int d=0; d<sideDim; d++)
{
testPoints(ptOrdinal,d) = sideRefCellNodes(ptOrdinal,d);
}
}
else
{
for (int d=0; d<sideDim; d++)
{
testPoints(ptOrdinal,d) = cubPoints(ptOrdinal-fineSideTopo->getNodeCount(),d);
}
}
}
fineSideRefPoints = testPoints;
fineCellRefPoints.resize(numTestPoints, spaceDim);
CamelliaCellTools::mapToReferenceSubcell(fineCellRefPoints, testPoints, sideDim, sideOrdinal, fineCell->topology());
CellTopoPtr coarseSideTopo = neighborCell->topology()->getSubcell(sideDim, neighborInfo.second);
unsigned fineSideAncestorPermutation = fineCell->ancestralPermutationForSubcell(sideDim, sideOrdinal, meshTopo);
unsigned coarseSidePermutation = neighborCell->subcellPermutation(sideDim, neighborInfo.second);
unsigned coarseSideAncestorPermutationInverse = CamelliaCellTools::permutationInverse(coarseSideTopo, coarseSidePermutation);
unsigned composedPermutation = CamelliaCellTools::permutationComposition(coarseSideTopo, coarseSideAncestorPermutationInverse, fineSideAncestorPermutation); // goes from coarse ordering to fine.
RefinementBranch fineRefBranch = fineCell->refinementBranchForSide(sideOrdinal, meshTopo);
FieldContainer<double> fineSideNodes(fineSideTopo->getNodeCount(), sideDim); // relative to the ancestral cell whose neighbor is compatible
if (fineRefBranch.size() == 0)
{
CamelliaCellTools::refCellNodesForTopology(fineSideNodes, coarseSideTopo, composedPermutation);
}
else
{
FieldContainer<double> ancestralSideNodes(coarseSideTopo->getNodeCount(), sideDim);
CamelliaCellTools::refCellNodesForTopology(ancestralSideNodes, coarseSideTopo, composedPermutation);
RefinementBranch fineSideRefBranch = RefinementPattern::sideRefinementBranch(fineRefBranch, sideOrdinal);
fineSideNodes = RefinementPattern::descendantNodes(fineSideRefBranch, ancestralSideNodes);
}
BasisCachePtr sideTopoCache = Teuchos::rcp( new BasisCache(fineSideTopo, 1, false) );
sideTopoCache->setRefCellPoints(testPoints);
// add cell dimension
fineSideNodes.resize(1,fineSideNodes.dimension(0), fineSideNodes.dimension(1));
sideTopoCache->setPhysicalCellNodes(fineSideNodes, vector<GlobalIndexType>(), false);
coarseSideRefPoints = sideTopoCache->getPhysicalCubaturePoints();
// strip off the cell dimension:
coarseSideRefPoints.resize(coarseSideRefPoints.dimension(1),coarseSideRefPoints.dimension(2));
coarseCellRefPoints.resize(numTestPoints,spaceDim);
CamelliaCellTools::mapToReferenceSubcell(coarseCellRefPoints, coarseSideRefPoints, sideDim, neighborInfo.second, neighborCell->topology());
return true; // containers filled....
}