static PetscErrorCode DMPlexTSSetupGradient(DM dm, PetscFV fvm, DMTS_Plex *dmplexts)
{
DM dmFace, dmCell;
PetscScalar *fgeom, *cgeom;
PetscSection sectionGrad;
PetscInt dim, pdim, cStart, cEnd, cEndInterior, c;
PetscErrorCode ierr;
PetscFunctionBegin;
if (dmplexts->setupGrad) PetscFunctionReturn(0);
ierr = DMPlexGetDimension(dm, &dim);CHKERRQ(ierr);
ierr = PetscFVGetNumComponents(fvm, &pdim);CHKERRQ(ierr);
ierr = DMPlexGetHeightStratum(dm, 0, &cStart, &cEnd);CHKERRQ(ierr);
ierr = DMPlexGetHybridBounds(dm, &cEndInterior, NULL, NULL, NULL);CHKERRQ(ierr);
/* Construct the interpolant corresponding to each face from the leat-square solution over the cell neighborhood */
ierr = VecGetDM(dmplexts->facegeom, &dmFace);CHKERRQ(ierr);
ierr = VecGetDM(dmplexts->cellgeom, &dmCell);CHKERRQ(ierr);
ierr = VecGetArray(dmplexts->facegeom, &fgeom);CHKERRQ(ierr);
ierr = VecGetArray(dmplexts->cellgeom, &cgeom);CHKERRQ(ierr);
ierr = BuildGradientReconstruction(dm, fvm, dmFace, fgeom, dmCell, cgeom);CHKERRQ(ierr);
ierr = VecRestoreArray(dmplexts->facegeom, &fgeom);CHKERRQ(ierr);
ierr = VecRestoreArray(dmplexts->cellgeom, &cgeom);CHKERRQ(ierr);
/* Create storage for gradients */
ierr = DMClone(dm, &dmplexts->dmGrad);CHKERRQ(ierr);
ierr = PetscSectionCreate(PetscObjectComm((PetscObject) dm), §ionGrad);CHKERRQ(ierr);
ierr = PetscSectionSetChart(sectionGrad, cStart, cEnd);CHKERRQ(ierr);
for (c = cStart; c < cEnd; ++c) {ierr = PetscSectionSetDof(sectionGrad, c, pdim*dim);CHKERRQ(ierr);}
ierr = PetscSectionSetUp(sectionGrad);CHKERRQ(ierr);
ierr = DMSetDefaultSection(dmplexts->dmGrad, sectionGrad);CHKERRQ(ierr);
ierr = PetscSectionDestroy(§ionGrad);CHKERRQ(ierr);
dmplexts->setupGrad = PETSC_TRUE;
PetscFunctionReturn(0);
}
PetscErrorCode SetupSection(DM dm, AppCtx *user)
{
PetscSection section;
const PetscInt numFields = 1;
PetscInt dim = user->dim;
PetscInt numBC = 0;
PetscInt bcFields[1] = {0};
IS bcPoints[1] = {NULL};
const PetscInt *numFieldDof[1];
PetscInt numComp[1];
PetscInt *numDof;
PetscInt f, d;
PetscErrorCode ierr;
PetscFunctionBegin;
ierr = PetscFEGetNumComponents(user->fe, &numComp[0]);CHKERRQ(ierr);
ierr = PetscFEGetNumDof(user->fe, &numFieldDof[0]);CHKERRQ(ierr);
ierr = PetscMalloc(1*(dim+1) * sizeof(PetscInt), &numDof);CHKERRQ(ierr);
for (d = 0; d <= dim; ++d) {
numDof[0*(dim+1)+d] = numFieldDof[0][d];
}
for (f = 0; f < numFields; ++f) {
for (d = 1; d < dim; ++d) {
if ((numDof[f*(dim+1)+d] > 0) && !user->interpolate) SETERRQ(PetscObjectComm((PetscObject)dm), PETSC_ERR_ARG_WRONG, "Mesh must be interpolated when unknowns are specified on edges or faces.");
}
}
ierr = DMPlexCreateSection(dm, dim, numFields, numComp, numDof, numBC, bcFields, bcPoints, §ion);CHKERRQ(ierr);
ierr = DMSetDefaultSection(dm, section);CHKERRQ(ierr);
ierr = PetscSectionDestroy(§ion);CHKERRQ(ierr);
ierr = PetscFree(numDof);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
DM createSection(DM dm, const PetscInt polyDegree)
{
PetscInt numFields = 1;
PetscInt dim;
PetscInt numComp[numFields];
numComp[0] = 1;
PetscInt numDof[numFields*(dim+1)];
numDof[0*(dim+1)+0] = 1;
numDof[0*(dim+1)+1] = (polyDegree - 1);
numDof[0*(dim+1)+2] = (polyDegree - 1)*(polyDegree - 1);
PetscSection section;
DMPlexCreateSection(dm, dim, numFields, numComp, numDof, 0, NULL,
NULL, NULL, NULL, §ion);
DMSetDefaultSection(dm, section);
/*
Here I'd like to be able to access an ordered list of dof element-wise.
For example, for polynomial degree four on the GLL basis
d12 d17 d18 d19 d13
(v3)--------------------(v2)
| |
d25 | d7 d8 d9 | d22
| |
| |
d24 | d4 d5 d6 | d21
| |
| |
d23 | d1 d2 d3 | d20
| |
(v4)____________________(v1)
d10 d11
d14 d15 d16
with v the element vertices and d the element-local dof. The idea would be to
use this list to construct a local->global mapping on each mesh partition.
Desired functionality:
compute fields on element
*sum fields from element into global dof on each mesh chunk
sum fields across partitions (vecLocToGlob)
*gather fields from global dof on each mesh chunk to element
For the * processes to work we'd need the vertices of each element, along with
an ordered list of the dof on each element. Is this possible?
*/
return dm;
}
PetscErrorCode DMSetUp_Network(DM dm)
{
PetscErrorCode ierr;
DM_Network *network=(DM_Network*)dm->data;
PetscFunctionBegin;
ierr = DMNetworkComponentSetUp(dm);CHKERRQ(ierr);
ierr = DMNetworkVariablesSetUp(dm);CHKERRQ(ierr);
ierr = DMSetDefaultSection(network->plex,network->DofSection);CHKERRQ(ierr);
ierr = DMGetDefaultGlobalSection(network->plex,&network->GlobalDofSection);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
PetscErrorCode TestVecClosure(DM dm, AppCtx *user)
{
PetscSection s;
Vec v;
PetscInt numRuns, cStart, cEnd, c, i;
PetscScalar tmpArray[64];
PetscScalar *userArray = user->reuseArray ? tmpArray : NULL;
PetscReal maxTimePerRun = user->maxVecClosureTime;
PetscStageLog stageLog;
PetscEventPerfLog eventLog;
PetscInt stage;
PetscLogEvent event;
PetscEventPerfInfo eventInfo;
PetscErrorCode ierr;
PetscFunctionBegin;
ierr = PetscLogStageRegister("DMPlex Vector Closure Test", &stage);CHKERRQ(ierr);
ierr = PetscLogEventRegister("VecClosure", PETSC_OBJECT_CLASSID, &event);CHKERRQ(ierr);
ierr = PetscLogStagePush(stage);CHKERRQ(ierr);
ierr = DMPlexCreateSection(dm, user->dim, user->numFields, user->numComponents, user->numDof, 0, NULL, NULL, &s);CHKERRQ(ierr);
ierr = DMSetDefaultSection(dm, s);CHKERRQ(ierr);
ierr = PetscSectionDestroy(&s);CHKERRQ(ierr);
ierr = DMPlexGetHeightStratum(dm, 0, &cStart, &cEnd);CHKERRQ(ierr);
ierr = DMGetLocalVector(dm, &v);CHKERRQ(ierr);
ierr = PetscLogEventBegin(event,0,0,0,0);CHKERRQ(ierr);
for (i = 0; i < user->iterations; ++i) {
for (c = cStart; c < cEnd; ++c) {
PetscScalar *closure = userArray;
PetscInt closureSize = 64;;
ierr = DMPlexVecGetClosure(dm, s, v, c, &closureSize, &closure);CHKERRQ(ierr);
if (!user->reuseArray) {ierr = DMPlexVecRestoreClosure(dm, s, v, c, &closureSize, &closure);CHKERRQ(ierr);}
}
}
ierr = PetscLogEventEnd(event,0,0,0,0);CHKERRQ(ierr);
ierr = DMRestoreLocalVector(dm, &v);CHKERRQ(ierr);
ierr = PetscLogStagePop();CHKERRQ(ierr);
ierr = PetscLogGetStageLog(&stageLog);
ierr = PetscStageLogGetEventPerfLog(stageLog, stage, &eventLog);
numRuns = (cEnd-cStart) * user->iterations;
eventInfo = eventLog->eventInfo[event];
if (eventInfo.count != 1) SETERRQ2(PETSC_COMM_SELF, PETSC_ERR_PLIB, "Number of event calls %d should be %d", eventInfo.count, 1);
if ((PetscInt) eventInfo.flops != 0) SETERRQ2(PETSC_COMM_SELF, PETSC_ERR_PLIB, "Number of event flops %d should be %d", (PetscInt) eventInfo.flops, 0);
if (eventInfo.time > maxTimePerRun * numRuns) {
ierr = PetscPrintf(PETSC_COMM_SELF, "VecClosures: %d Average time per cone: %gs standard: %gs\n", numRuns, eventInfo.time/numRuns, maxTimePerRun);
if (user->errors) SETERRQ2(PETSC_COMM_SELF, PETSC_ERR_PLIB, "Average time for vector closure %g > standard %g", eventInfo.time/numRuns, maxTimePerRun);
}
PetscFunctionReturn(0);
}
/*
There is a problem here with uninterpolated meshes. The index in numDof[] is not dimension in this case,
but sieve depth.
*/
PetscErrorCode SetupSection(DM dm, AppCtx *user)
{
PetscSection section;
const PetscInt numFields = NUM_FIELDS;
PetscInt dim = user->dim;
PetscInt numBC = 0;
PetscInt bcFields[1] = {0};
IS bcPoints[1] = {NULL};
PetscInt numComp[NUM_FIELDS];
const PetscInt *numFieldDof[NUM_FIELDS];
PetscInt *numDof;
PetscInt f, d;
PetscErrorCode ierr;
PetscFunctionBeginUser;
ierr = PetscFEGetNumComponents(user->fe[0], &numComp[0]);CHKERRQ(ierr);
ierr = PetscFEGetNumComponents(user->fe[1], &numComp[1]);CHKERRQ(ierr);
ierr = PetscFEGetNumDof(user->fe[0], &numFieldDof[0]);CHKERRQ(ierr);
ierr = PetscFEGetNumDof(user->fe[1], &numFieldDof[1]);CHKERRQ(ierr);
ierr = PetscMalloc(NUM_FIELDS*(dim+1) * sizeof(PetscInt), &numDof);CHKERRQ(ierr);
for (f = 0; f < NUM_FIELDS; ++f) {
for (d = 0; d <= dim; ++d) {
numDof[f*(dim+1)+d] = numFieldDof[f][d];
}
}
for (f = 0; f < numFields; ++f) {
for (d = 1; d < dim; ++d) {
if ((numDof[f*(dim+1)+d] > 0) && !user->interpolate) SETERRQ(PetscObjectComm((PetscObject)dm), PETSC_ERR_ARG_WRONG, "Mesh must be interpolated when unknowns are specified on edges or faces.");
}
}
if (user->bcType == DIRICHLET) {
numBC = 1;
ierr = DMPlexGetStratumIS(dm, "marker", 1, &bcPoints[0]);CHKERRQ(ierr);
}
ierr = DMPlexCreateSection(dm, dim, numFields, numComp, numDof, numBC, bcFields, bcPoints, §ion);CHKERRQ(ierr);
ierr = PetscSectionSetFieldName(section, 0, "velocity");CHKERRQ(ierr);
ierr = PetscSectionSetFieldName(section, 1, "pressure");CHKERRQ(ierr);
ierr = DMSetDefaultSection(dm, section);CHKERRQ(ierr);
ierr = PetscSectionDestroy(§ion);CHKERRQ(ierr);
if (user->bcType == DIRICHLET) {
ierr = ISDestroy(&bcPoints[0]);CHKERRQ(ierr);
}
ierr = PetscFree(numDof);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
PetscErrorCode SetupMaterialSection(DM dm, AppCtx *user)
{
PetscSection section;
PetscInt dim = user->dim;
PetscInt numBC = 0;
PetscInt numComp[1];
const PetscInt *numDof;
PetscErrorCode ierr;
PetscFunctionBeginUser;
if (user->variableCoefficient != COEFF_FIELD) PetscFunctionReturn(0);
ierr = PetscFEGetNumComponents(user->feAux[0], &numComp[0]);CHKERRQ(ierr);
ierr = PetscFEGetNumDof(user->feAux[0], &numDof);CHKERRQ(ierr);
ierr = DMPlexCreateSection(dm, dim, 1, numComp, numDof, numBC, NULL, NULL, NULL, §ion);CHKERRQ(ierr);
ierr = DMSetDefaultSection(dm, section);CHKERRQ(ierr);
ierr = PetscSectionDestroy(§ion);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
/*
There is a problem here with uninterpolated meshes. The index in numDof[] is not dimension in this case,
but sieve depth.
*/
PetscErrorCode SetupSection(DM dm, AppCtx *user)
{
PetscSection section;
const PetscInt numFields = NUM_FIELDS;
PetscInt dim = user->dim;
PetscInt numBC = 0;
PetscInt numComp[NUM_FIELDS] = {NUM_BASIS_COMPONENTS_0, NUM_BASIS_COMPONENTS_1};
PetscInt bcFields[1] = {0};
IS bcPoints[1] = {NULL};
PetscInt numDof[NUM_FIELDS*(SPATIAL_DIM_0+1)];
PetscInt f, d;
PetscErrorCode ierr;
PetscFunctionBeginUser;
if (dim != SPATIAL_DIM_0) SETERRQ2(PetscObjectComm((PetscObject)dm), PETSC_ERR_ARG_SIZ, "Spatial dimension %d should be %d", dim, SPATIAL_DIM_0);
if (dim != SPATIAL_DIM_1) SETERRQ2(PetscObjectComm((PetscObject)dm), PETSC_ERR_ARG_SIZ, "Spatial dimension %d should be %d", dim, SPATIAL_DIM_1);
for (d = 0; d <= dim; ++d) {
numDof[0*(dim+1)+d] = numDof_0[d];
numDof[1*(dim+1)+d] = numDof_1[d];
}
for (f = 0; f < numFields; ++f) {
for (d = 1; d < dim; ++d) {
if ((numDof[f*(dim+1)+d] > 0) && !user->interpolate) SETERRQ(PetscObjectComm((PetscObject)dm), PETSC_ERR_ARG_WRONG, "Mesh must be interpolated when unknowns are specified on edges or faces.");
}
}
if (user->bcType == DIRICHLET) {
numBC = 1;
ierr = DMPlexGetStratumIS(dm, "marker", 1, &bcPoints[0]);CHKERRQ(ierr);
}
ierr = DMPlexCreateSection(dm, dim, numFields, numComp, numDof, numBC, bcFields, bcPoints, §ion);CHKERRQ(ierr);
ierr = PetscSectionSetFieldName(section, 0, "velocity");CHKERRQ(ierr);
ierr = PetscSectionSetFieldName(section, 1, "pressure");CHKERRQ(ierr);
ierr = DMSetDefaultSection(dm, section);CHKERRQ(ierr);
if (user->bcType == DIRICHLET) {
ierr = ISDestroy(&bcPoints[0]);CHKERRQ(ierr);
}
PetscFunctionReturn(0);
}
/*@
DMNetworkDistribute - Distributes the network and moves associated component data.
Collective
Input Parameter:
+ oldDM - the original DMNetwork object
- overlap - The overlap of partitions, 0 is the default
Output Parameter:
. distDM - the distributed DMNetwork object
Notes:
This routine should be called only when using multiple processors.
Distributes the network with <overlap>-overlapping partitioning of the edges.
Level: intermediate
.seealso: DMNetworkCreate
@*/
PetscErrorCode DMNetworkDistribute(DM oldDM, PetscInt overlap,DM *distDM)
{
PetscErrorCode ierr;
DM_Network *oldDMnetwork = (DM_Network*)oldDM->data;
PetscSF pointsf;
DM newDM;
DM_Network *newDMnetwork;
PetscFunctionBegin;
ierr = DMNetworkCreate(PetscObjectComm((PetscObject)oldDM),&newDM);CHKERRQ(ierr);
newDMnetwork = (DM_Network*)newDM->data;
newDMnetwork->dataheadersize = sizeof(struct _p_DMNetworkComponentHeader)/sizeof(DMNetworkComponentGenericDataType);
/* Distribute plex dm and dof section */
ierr = DMPlexDistribute(oldDMnetwork->plex,overlap,&pointsf,&newDMnetwork->plex);CHKERRQ(ierr);
/* Distribute dof section */
ierr = PetscSectionCreate(PetscObjectComm((PetscObject)oldDM),&newDMnetwork->DofSection);CHKERRQ(ierr);
ierr = PetscSFDistributeSection(pointsf,oldDMnetwork->DofSection,NULL,newDMnetwork->DofSection);CHKERRQ(ierr);
ierr = PetscSectionCreate(PetscObjectComm((PetscObject)oldDM),&newDMnetwork->DataSection);CHKERRQ(ierr);
/* Distribute data and associated section */
ierr = DMPlexDistributeData(newDMnetwork->plex,pointsf,oldDMnetwork->DataSection,MPI_INT,(void*)oldDMnetwork->componentdataarray,newDMnetwork->DataSection,(void**)&newDMnetwork->componentdataarray);CHKERRQ(ierr);
/* Destroy point SF */
ierr = PetscSFDestroy(&pointsf);CHKERRQ(ierr);
ierr = PetscSectionGetChart(newDMnetwork->DataSection,&newDMnetwork->pStart,&newDMnetwork->pEnd);CHKERRQ(ierr);
ierr = DMPlexGetHeightStratum(newDMnetwork->plex,0, &newDMnetwork->eStart,&newDMnetwork->eEnd);CHKERRQ(ierr);
ierr = DMPlexGetHeightStratum(newDMnetwork->plex,1,&newDMnetwork->vStart,&newDMnetwork->vEnd);CHKERRQ(ierr);
newDMnetwork->nEdges = newDMnetwork->eEnd - newDMnetwork->eStart;
newDMnetwork->nNodes = newDMnetwork->vEnd - newDMnetwork->vStart;
newDMnetwork->NNodes = oldDMnetwork->NNodes;
newDMnetwork->NEdges = oldDMnetwork->NEdges;
/* Set Dof section as the default section for dm */
ierr = DMSetDefaultSection(newDMnetwork->plex,newDMnetwork->DofSection);CHKERRQ(ierr);
ierr = DMGetDefaultGlobalSection(newDMnetwork->plex,&newDMnetwork->GlobalDofSection);CHKERRQ(ierr);
*distDM = newDM;
PetscFunctionReturn(0);
}
//! Help PETSc identify the coarser DM dmc given the fine DM dmf
PetscErrorCode libmesh_petsc_DMCoarsen(DM dmf, MPI_Comm /*comm*/, DM * dmc)
{
libmesh_assert(dmc);
libmesh_assert(dmf);
PetscErrorCode ierr;
// Extract our context from the incoming dmf
void * ctx_f = nullptr;
ierr = DMShellGetContext(dmf, &ctx_f);LIBMESH_CHKERR(ierr);
libmesh_assert(ctx_f);
PetscDMContext * p_ctx = static_cast<PetscDMContext*>(ctx_f);
// First, ensure that there exists a coarse DM that we want to
// set. There ought to be as we created it while walking the
// hierarchy.
libmesh_assert(p_ctx->coarser_dm);
libmesh_assert(*(p_ctx->coarser_dm));
// In situations using fieldsplit we need to (potentially)
// provide a coarser DM which only has the relevant subfields in
// it. Since we create global DMs for each mesh level, we need
// to extract the section from the DM, and check the number of
// fields. When less than all the fields are used, we need to
// create the proper subsections.
// Get the number of fields and their names from the incomming
// fine DM and the global reference DM
PetscInt nfieldsf, nfieldsg;
char ** fieldnamesf;
char ** fieldnamesg;
libmesh_assert(p_ctx->global_dm);
DM * globaldm = p_ctx->global_dm;
ierr = DMCreateFieldIS(dmf, &nfieldsf, &fieldnamesf, nullptr);
LIBMESH_CHKERR(ierr);
ierr = DMCreateFieldIS(*globaldm, &nfieldsg, &fieldnamesg, nullptr);
LIBMESH_CHKERR(ierr);
// If the probed number of fields is less than the number of
// global fields, this amounts to PETSc 'indicating' to us we
// are doing FS. So, we must create subsections for the coarser
// DMs.
if ( nfieldsf < nfieldsg )
{
PetscSection section;
PetscSection subsection;
std::vector<PetscInt> subfields(nfieldsf); // extracted fields
// First, get the section from the coarse DM
#if PETSC_VERSION_LESS_THAN(3,10,0)
ierr = DMGetDefaultSection(*(p_ctx->coarser_dm), §ion);
#else
ierr = DMGetSection(*(p_ctx->coarser_dm), §ion);
#endif
LIBMESH_CHKERR(ierr);
// Now, match fine grid DM field names to their global DM
// counterparts. Since PETSc can internally reassign field
// numbering under a fieldsplit, we must extract
// subsections via the field names. This is admittedly
// gross, but c'est la vie.
for (int i = 0; i < nfieldsf ; i++)
{
for (int j = 0; j < nfieldsg ;j++)
if ( strcmp( fieldnamesg[j], fieldnamesf[i] ) == 0 )
subfields[i] = j;
}
// Next, for the found fields we now make a subsection and set it for the coarser DM
ierr = PetscSectionCreateSubsection(section, nfieldsf, subfields.data(), &subsection);
LIBMESH_CHKERR(ierr);
#if PETSC_VERSION_LESS_THAN(3,10,0)
ierr = DMSetDefaultSection(*(p_ctx->coarser_dm) , subsection);
#else
ierr = DMSetSection(*(p_ctx->coarser_dm) , subsection);
#endif
LIBMESH_CHKERR(ierr);
ierr = PetscSectionDestroy(&subsection);
LIBMESH_CHKERR(ierr);
}
// Finally, set the coarser DM
*(dmc) = *(p_ctx->coarser_dm);
return 0;
}
int main(int argc, char **argv)
{
DM dm;
PetscSection s;
Vec u;
AppCtx user;
PetscInt cells[3] = {2, 2, 2};
PetscInt size = 0, cStart, cEnd, cell, c, f, i, j;
PetscErrorCode ierr;
ierr = PetscInitialize(&argc, &argv, NULL,help);if (ierr) return ierr;
ierr = ProcessOptions(PETSC_COMM_WORLD, &user);CHKERRQ(ierr);
ierr = DMPlexCreateHexBoxMesh(PETSC_COMM_WORLD, user.dim, cells, DM_BOUNDARY_NONE, DM_BOUNDARY_NONE, DM_BOUNDARY_NONE, &dm);CHKERRQ(ierr);
ierr = DMSetFromOptions(dm);CHKERRQ(ierr);
/* Create a section for SEM order k */
{
PetscInt *numDof, d;
ierr = PetscMalloc1(user.Nf*(user.dim+1), &numDof);CHKERRQ(ierr);
for (f = 0; f < user.Nf; ++f) {
for (d = 0; d <= user.dim; ++d) numDof[f*(user.dim+1)+d] = PetscPowInt(user.k[f]-1, d)*user.Nc[f];
size += PetscPowInt(user.k[f]+1, d)*user.Nc[f];
}
ierr = DMPlexCreateSection(dm, user.dim, user.Nf, user.Nc, numDof, 0, NULL, NULL, NULL, NULL, &s);CHKERRQ(ierr);
ierr = SetSymmetries(dm, s, &user);CHKERRQ(ierr);
ierr = PetscFree(numDof);CHKERRQ(ierr);
}
ierr = DMSetDefaultSection(dm, s);CHKERRQ(ierr);
/* Create spectral ordering and load in data */
ierr = DMPlexCreateSpectralClosurePermutation(dm, NULL);CHKERRQ(ierr);
ierr = DMGetLocalVector(dm, &u);CHKERRQ(ierr);
switch (user.dim) {
case 2: ierr = LoadData2D(dm, 2, 2, size, u, &user);CHKERRQ(ierr);break;
case 3: ierr = LoadData3D(dm, 2, 2, 2, size, u, &user);CHKERRQ(ierr);break;
}
/* Remove ordering and check some values */
ierr = PetscSectionSetClosurePermutation(s, (PetscObject) dm, NULL);CHKERRQ(ierr);
switch (user.dim) {
case 2:
ierr = CheckPoint(dm, u, 0, &user);CHKERRQ(ierr);
ierr = CheckPoint(dm, u, 13, &user);CHKERRQ(ierr);
ierr = CheckPoint(dm, u, 15, &user);CHKERRQ(ierr);
ierr = CheckPoint(dm, u, 19, &user);CHKERRQ(ierr);
break;
case 3:
ierr = CheckPoint(dm, u, 0, &user);CHKERRQ(ierr);
ierr = CheckPoint(dm, u, 13, &user);CHKERRQ(ierr);
ierr = CheckPoint(dm, u, 15, &user);CHKERRQ(ierr);
ierr = CheckPoint(dm, u, 19, &user);CHKERRQ(ierr);
break;
}
/* Recreate spectral ordering and read out data */
ierr = DMPlexCreateSpectralClosurePermutation(dm, s);CHKERRQ(ierr);
switch (user.dim) {
case 2: ierr = ReadData2D(dm, u, &user);CHKERRQ(ierr);break;
case 3: ierr = ReadData3D(dm, u, &user);CHKERRQ(ierr);break;
}
ierr = DMRestoreLocalVector(dm, &u);CHKERRQ(ierr);
ierr = PetscSectionDestroy(&s);CHKERRQ(ierr);
ierr = DMDestroy(&dm);CHKERRQ(ierr);
ierr = PetscFree(user.Nc);CHKERRQ(ierr);
ierr = PetscFree(user.k);CHKERRQ(ierr);
ierr = PetscFinalize();
return ierr;
}
/* This assumes that the DM has been cloned prior to the call */
PetscErrorCode DMCreateSubDM_Section_Private(DM dm, PetscInt numFields, PetscInt fields[], IS *is, DM *subdm)
{
PetscSection section, sectionGlobal;
PetscInt *subIndices;
PetscInt subSize = 0, subOff = 0, nF, f, pStart, pEnd, p;
PetscErrorCode ierr;
PetscFunctionBegin;
if (!numFields) PetscFunctionReturn(0);
ierr = DMGetDefaultSection(dm, §ion);CHKERRQ(ierr);
ierr = DMGetDefaultGlobalSection(dm, §ionGlobal);CHKERRQ(ierr);
if (!section) SETERRQ(PetscObjectComm((PetscObject)dm), PETSC_ERR_ARG_WRONG, "Must set default section for DM before splitting fields");
if (!sectionGlobal) SETERRQ(PetscObjectComm((PetscObject)dm), PETSC_ERR_ARG_WRONG, "Must set default global section for DM before splitting fields");
ierr = PetscSectionGetNumFields(section, &nF);CHKERRQ(ierr);
if (numFields > nF) SETERRQ2(PetscObjectComm((PetscObject)dm), PETSC_ERR_ARG_WRONG, "Number of requested fields %d greater than number of DM fields %d", numFields, nF);
if (is) {
ierr = PetscSectionGetChart(sectionGlobal, &pStart, &pEnd);CHKERRQ(ierr);
for (p = pStart; p < pEnd; ++p) {
PetscInt gdof;
ierr = PetscSectionGetDof(sectionGlobal, p, &gdof);CHKERRQ(ierr);
if (gdof > 0) {
for (f = 0; f < numFields; ++f) {
PetscInt fdof, fcdof;
ierr = PetscSectionGetFieldDof(section, p, fields[f], &fdof);CHKERRQ(ierr);
ierr = PetscSectionGetFieldConstraintDof(section, p, fields[f], &fcdof);CHKERRQ(ierr);
subSize += fdof-fcdof;
}
}
}
ierr = PetscMalloc1(subSize, &subIndices);CHKERRQ(ierr);
for (p = pStart; p < pEnd; ++p) {
PetscInt gdof, goff;
ierr = PetscSectionGetDof(sectionGlobal, p, &gdof);CHKERRQ(ierr);
if (gdof > 0) {
ierr = PetscSectionGetOffset(sectionGlobal, p, &goff);CHKERRQ(ierr);
for (f = 0; f < numFields; ++f) {
PetscInt fdof, fcdof, fc, f2, poff = 0;
/* Can get rid of this loop by storing field information in the global section */
for (f2 = 0; f2 < fields[f]; ++f2) {
ierr = PetscSectionGetFieldDof(section, p, f2, &fdof);CHKERRQ(ierr);
ierr = PetscSectionGetFieldConstraintDof(section, p, f2, &fcdof);CHKERRQ(ierr);
poff += fdof-fcdof;
}
ierr = PetscSectionGetFieldDof(section, p, fields[f], &fdof);CHKERRQ(ierr);
ierr = PetscSectionGetFieldConstraintDof(section, p, fields[f], &fcdof);CHKERRQ(ierr);
for (fc = 0; fc < fdof-fcdof; ++fc, ++subOff) {
subIndices[subOff] = goff+poff+fc;
}
}
}
}
ierr = ISCreateGeneral(PetscObjectComm((PetscObject)dm), subSize, subIndices, PETSC_OWN_POINTER, is);CHKERRQ(ierr);
}
if (subdm) {
PetscSection subsection;
PetscBool haveNull = PETSC_FALSE;
PetscInt f, nf = 0;
ierr = PetscSectionCreateSubsection(section, numFields, fields, &subsection);CHKERRQ(ierr);
ierr = DMSetDefaultSection(*subdm, subsection);CHKERRQ(ierr);
ierr = PetscSectionDestroy(&subsection);CHKERRQ(ierr);
for (f = 0; f < numFields; ++f) {
(*subdm)->nullspaceConstructors[f] = dm->nullspaceConstructors[fields[f]];
if ((*subdm)->nullspaceConstructors[f]) {
haveNull = PETSC_TRUE;
nf = f;
}
}
if (haveNull && is) {
MatNullSpace nullSpace;
ierr = (*(*subdm)->nullspaceConstructors[nf])(*subdm, nf, &nullSpace);CHKERRQ(ierr);
ierr = PetscObjectCompose((PetscObject) *is, "nullspace", (PetscObject) nullSpace);CHKERRQ(ierr);
ierr = MatNullSpaceDestroy(&nullSpace);CHKERRQ(ierr);
}
if (dm->prob) {
PetscInt Nf;
ierr = PetscDSGetNumFields(dm->prob, &Nf);CHKERRQ(ierr);
if (nF != Nf) SETERRQ2(PetscObjectComm((PetscObject)dm), PETSC_ERR_ARG_WRONG, "The number of DM fields %d does not match the number of Section fields %d", Nf, nF);
ierr = DMSetNumFields(*subdm, numFields);CHKERRQ(ierr);
for (f = 0; f < numFields; ++f) {
PetscObject disc;
ierr = DMGetField(dm, fields[f], &disc);CHKERRQ(ierr);
ierr = DMSetField(*subdm, f, disc);CHKERRQ(ierr);
}
if (numFields == 1 && is) {
PetscObject disc, space, pmat;
ierr = DMGetField(*subdm, 0, &disc);CHKERRQ(ierr);
ierr = PetscObjectQuery(disc, "nullspace", &space);CHKERRQ(ierr);
if (space) {ierr = PetscObjectCompose((PetscObject) *is, "nullspace", space);CHKERRQ(ierr);}
ierr = PetscObjectQuery(disc, "nearnullspace", &space);CHKERRQ(ierr);
if (space) {ierr = PetscObjectCompose((PetscObject) *is, "nearnullspace", space);CHKERRQ(ierr);}
ierr = PetscObjectQuery(disc, "pmat", &pmat);CHKERRQ(ierr);
if (pmat) {ierr = PetscObjectCompose((PetscObject) *is, "pmat", pmat);CHKERRQ(ierr);}
}
}
}
#if 0
/* We need a way to filter the original SF for given fields:
- Keeping the original section around it too much I think
- We could keep the distributed section, and subset it
*/
if (dm->sfNatural) {
PetscSF sfNatural;
ierr = PetscSectionCreateSubsection(dm->originalSection, numFields, fields, &(*subdm)->originalSection);CHKERRQ(ierr);
ierr = DMPlexCreateGlobalToNaturalPetscSF(*subdm, &sfNatural);CHKERRQ(ierr);
ierr = DMPlexSetGlobalToNaturalPetscSF(*subdm, sfNatural);CHKERRQ(ierr);
}
#endif
PetscFunctionReturn(0);
}
/* This assumes that the DM has been cloned prior to the call */
PetscErrorCode DMCreateSubDM_Section_Private(DM dm, PetscInt numFields, PetscInt fields[], IS *is, DM *subdm)
{
PetscSection section, sectionGlobal;
PetscInt *subIndices;
PetscInt subSize = 0, subOff = 0, nF, f, pStart, pEnd, p;
PetscErrorCode ierr;
PetscFunctionBegin;
if (!numFields) PetscFunctionReturn(0);
ierr = DMGetDefaultSection(dm, §ion);CHKERRQ(ierr);
ierr = DMGetDefaultGlobalSection(dm, §ionGlobal);CHKERRQ(ierr);
if (!section) SETERRQ(PetscObjectComm((PetscObject)dm), PETSC_ERR_ARG_WRONG, "Must set default section for DM before splitting fields");
if (!sectionGlobal) SETERRQ(PetscObjectComm((PetscObject)dm), PETSC_ERR_ARG_WRONG, "Must set default global section for DM before splitting fields");
ierr = PetscSectionGetNumFields(section, &nF);CHKERRQ(ierr);
if (numFields > nF) SETERRQ2(PetscObjectComm((PetscObject)dm), PETSC_ERR_ARG_WRONG, "Number of requested fields %d greater than number of DM fields %d", numFields, nF);
if (is) {
ierr = PetscSectionGetChart(sectionGlobal, &pStart, &pEnd);CHKERRQ(ierr);
for (p = pStart; p < pEnd; ++p) {
PetscInt gdof;
ierr = PetscSectionGetDof(sectionGlobal, p, &gdof);CHKERRQ(ierr);
if (gdof > 0) {
for (f = 0; f < numFields; ++f) {
PetscInt fdof, fcdof;
ierr = PetscSectionGetFieldDof(section, p, fields[f], &fdof);CHKERRQ(ierr);
ierr = PetscSectionGetFieldConstraintDof(section, p, fields[f], &fcdof);CHKERRQ(ierr);
subSize += fdof-fcdof;
}
}
}
ierr = PetscMalloc1(subSize, &subIndices);CHKERRQ(ierr);
for (p = pStart; p < pEnd; ++p) {
PetscInt gdof, goff;
ierr = PetscSectionGetDof(sectionGlobal, p, &gdof);CHKERRQ(ierr);
if (gdof > 0) {
ierr = PetscSectionGetOffset(sectionGlobal, p, &goff);CHKERRQ(ierr);
for (f = 0; f < numFields; ++f) {
PetscInt fdof, fcdof, fc, f2, poff = 0;
/* Can get rid of this loop by storing field information in the global section */
for (f2 = 0; f2 < fields[f]; ++f2) {
ierr = PetscSectionGetFieldDof(section, p, f2, &fdof);CHKERRQ(ierr);
ierr = PetscSectionGetFieldConstraintDof(section, p, f2, &fcdof);CHKERRQ(ierr);
poff += fdof-fcdof;
}
ierr = PetscSectionGetFieldDof(section, p, fields[f], &fdof);CHKERRQ(ierr);
ierr = PetscSectionGetFieldConstraintDof(section, p, fields[f], &fcdof);CHKERRQ(ierr);
for (fc = 0; fc < fdof-fcdof; ++fc, ++subOff) {
subIndices[subOff] = goff+poff+fc;
}
}
}
}
ierr = ISCreateGeneral(PetscObjectComm((PetscObject)dm), subSize, subIndices, PETSC_OWN_POINTER, is);CHKERRQ(ierr);
}
if (subdm) {
PetscSection subsection;
PetscBool haveNull = PETSC_FALSE;
PetscInt f, nf = 0;
ierr = PetscSectionCreateSubsection(section, numFields, fields, &subsection);CHKERRQ(ierr);
ierr = DMSetDefaultSection(*subdm, subsection);CHKERRQ(ierr);
ierr = PetscSectionDestroy(&subsection);CHKERRQ(ierr);
for (f = 0; f < numFields; ++f) {
(*subdm)->nullspaceConstructors[f] = dm->nullspaceConstructors[fields[f]];
if ((*subdm)->nullspaceConstructors[f]) {
haveNull = PETSC_TRUE;
nf = f;
}
}
if (haveNull) {
MatNullSpace nullSpace;
ierr = (*(*subdm)->nullspaceConstructors[nf])(*subdm, nf, &nullSpace);CHKERRQ(ierr);
ierr = PetscObjectCompose((PetscObject) *is, "nullspace", (PetscObject) nullSpace);CHKERRQ(ierr);
ierr = MatNullSpaceDestroy(&nullSpace);CHKERRQ(ierr);
}
if (dm->fields) {
if (nF != dm->numFields) SETERRQ2(PetscObjectComm((PetscObject)dm), PETSC_ERR_ARG_WRONG, "The number of DM fields %d does not match the number of Section fields %d", dm->numFields, nF);
ierr = DMSetNumFields(*subdm, numFields);CHKERRQ(ierr);
for (f = 0; f < numFields; ++f) {
ierr = PetscObjectListDuplicate(dm->fields[fields[f]]->olist, &(*subdm)->fields[f]->olist);CHKERRQ(ierr);
}
if (numFields == 1) {
MatNullSpace space;
Mat pmat;
ierr = PetscObjectQuery((*subdm)->fields[0], "nullspace", (PetscObject*) &space);CHKERRQ(ierr);
if (space) {ierr = PetscObjectCompose((PetscObject) *is, "nullspace", (PetscObject) space);CHKERRQ(ierr);}
ierr = PetscObjectQuery((*subdm)->fields[0], "nearnullspace", (PetscObject*) &space);CHKERRQ(ierr);
if (space) {ierr = PetscObjectCompose((PetscObject) *is, "nearnullspace", (PetscObject) space);CHKERRQ(ierr);}
ierr = PetscObjectQuery((*subdm)->fields[0], "pmat", (PetscObject*) &pmat);CHKERRQ(ierr);
if (pmat) {ierr = PetscObjectCompose((PetscObject) *is, "pmat", (PetscObject) pmat);CHKERRQ(ierr);}
}
}
}
PetscFunctionReturn(0);
}
int main(int argc, char *argv[])
{
PetscErrorCode ierr;
DM dm;
PetscBool interpolate = PETSC_TRUE;
PetscInt dim;
PetscInt pStart, pEnd;
PetscInt vStart, vEnd;
PetscInt eStart, eEnd;
PetscInt cStart, cEnd;
PetscSection s;
ierr = PetscInitialize(&argc, &argv, (char*)0, help); CHKERRQ(ierr);
ierr = DMPlexCreateGmshFromFile(MPI_COMM_WORLD, argv[1], interpolate, &dm); CHKERRQ(ierr);
ierr = DMGetDimension(dm, &dim); CHKERRQ(ierr);
printf("dim = %d\n", dim);
ierr = DMPlexGetChart(dm, &pStart, &pEnd); CHKERRQ(ierr);
printf("chart: pstart, pend = %d %d\n", pStart, pEnd);
// vertices
ierr = DMPlexGetDepthStratum(dm, 0, &vStart, &vEnd); CHKERRQ(ierr);
printf("Depth 0: vstart, vend, len = %d %d %d\n", vStart, vEnd, vEnd-vStart);
// edges
ierr = DMPlexGetDepthStratum(dm, 1, &eStart, &eEnd); CHKERRQ(ierr);
printf("Depth 1: estart, eend, len = %d %d %d\n", eStart, eEnd, eEnd-eStart);
// cells
ierr = DMPlexGetDepthStratum(dm, 2, &cStart, &cEnd); CHKERRQ(ierr);
printf("Depth 2: cstart, cend, len = %d %d %d\n", cStart, cEnd, cEnd-cStart);
// cells adjacent to face
{
FILE * fid = fopen("face_nbr.txt","w");
for(PetscInt e=eStart; e<eEnd; ++e)
{
PetscInt nbr;
ierr = DMPlexGetSupportSize(dm, e, &nbr); CHKERRQ(ierr);
const PetscInt *nbcells;
ierr = DMPlexGetSupport(dm, e, &nbcells); CHKERRQ(ierr);
if(nbr == 1) // boundary face
fprintf(fid, "%d %d\n",e-eStart+1,nbcells[0]-cStart+1);
else if(nbr == 2) // interior face
fprintf(fid, "%d %d %d\n",e-eStart+1,nbcells[0]-cStart+1,nbcells[1]-cStart+1);
else
{
printf("nbr is not 1 or 2\n");
exit(0);
}
}
fclose(fid);
}
// point coordinates
{
Vec coordinates;
ierr = DMGetCoordinatesLocal(dm, &coordinates); CHKERRQ(ierr);
const PetscScalar *coords;
ierr = VecGetArrayRead(coordinates, &coords); CHKERRQ(ierr);
DM dmCoord;
ierr = DMGetCoordinateDM(dm, &dmCoord); CHKERRQ(ierr);
FILE * fid = fopen("vertices.txt","w");
for(PetscInt v=vStart; v<vEnd; ++v)
{
PetscScalar *vertex;
ierr = DMPlexPointLocalRead(dmCoord, v, coords, &vertex); CHKERRQ(ierr);
fprintf(fid, "%f %f\n", vertex[0], vertex[1]);
}
fclose(fid);
ierr = VecRestoreArrayRead(coordinates, &coords); CHKERRQ(ierr);
}
// compute cell and face geometry
{
Vec cellgeom, facegeom;
ierr = DMPlexComputeGeometryFVM(dm, &cellgeom, &facegeom); CHKERRQ(ierr);
// cell information
DM dmCell;
ierr = VecGetDM(cellgeom, &dmCell); CHKERRQ(ierr);
const PetscScalar *cgeom;
ierr = VecGetArrayRead(cellgeom, &cgeom); CHKERRQ(ierr);
FILE * fid = fopen("cells.txt","w");
for(PetscInt c=cStart; c<cEnd; ++c)
{
// cell properties like volume, centroid
PetscFVCellGeom *cg;
ierr = DMPlexPointLocalRead(dmCell, c, cgeom, &cg); CHKERRQ(ierr);
fprintf(fid, "%d %f %f %f\n", c-cStart+1, cg->volume,
cg->centroid[0], cg->centroid[1]);
}
fclose(fid);
ierr = VecRestoreArrayRead(cellgeom, &cgeom); CHKERRQ(ierr);
// face information
DM dmFace;
ierr = VecGetDM(facegeom, &dmFace); CHKERRQ(ierr);
const PetscScalar *fgeom;
ierr = VecGetArrayRead(facegeom, &fgeom); CHKERRQ(ierr);
fid = fopen("faces.txt","w");
for(PetscInt e=eStart; e<eEnd; ++e)
{
// face properties like area normal, centroid
PetscFVFaceGeom *fg;
ierr = DMPlexPointLocalRead(dmFace, e, fgeom, &fg); CHKERRQ(ierr);
fprintf(fid, "%d %f %f %f %f\n", e-eStart+1, fg->normal[0], fg->normal[1],
fg->centroid[0], fg->centroid[1]);
}
fclose(fid);
ierr = VecRestoreArrayRead(facegeom, &fgeom); CHKERRQ(ierr);
}
// create section with one variable in each cell
ierr = PetscSectionCreate(PetscObjectComm((PetscObject)dm), &s); CHKERRQ(ierr);
ierr = PetscSectionSetChart(s, pStart, pEnd); CHKERRQ(ierr);
for(PetscInt c=cStart; c<cEnd; ++c)
{
ierr = PetscSectionSetDof(s, c, 1); CHKERRQ(ierr);
}
ierr = PetscSectionSetUp(s); CHKERRQ(ierr);
// create vector to store solution
Vec lv, gv;
ierr = DMSetDefaultSection(dm, s); CHKERRQ(ierr);
ierr = DMGetLocalVector(dm, &lv); CHKERRQ(ierr);
ierr = DMGetGlobalVector(dm, &gv); CHKERRQ(ierr);
}
static PetscErrorCode TestVecClosure(DM dm, PetscBool useIndex, PetscBool useSpectral, AppCtx *user)
{
PetscSection s;
Vec v;
PetscInt numRuns, cStart, cEnd, c, i;
PetscScalar tmpArray[64];
PetscScalar *userArray = user->reuseArray ? tmpArray : NULL;
PetscReal maxTimePerRun = user->maxVecClosureTime;
PetscLogStage stage;
PetscLogEvent event;
PetscEventPerfInfo eventInfo;
PetscErrorCode ierr;
PetscFunctionBegin;
if (useIndex) {
if (useSpectral) {
ierr = PetscLogStageRegister("DMPlex Vector Closure with Index Test", &stage);CHKERRQ(ierr);
ierr = PetscLogEventRegister("VecClosureInd", PETSC_OBJECT_CLASSID, &event);CHKERRQ(ierr);
} else {
ierr = PetscLogStageRegister("DMPlex Vector Spectral Closure with Index Test", &stage);CHKERRQ(ierr);
ierr = PetscLogEventRegister("VecClosureSpecInd", PETSC_OBJECT_CLASSID, &event);CHKERRQ(ierr);
}
} else {
if (useSpectral) {
ierr = PetscLogStageRegister("DMPlex Vector Spectral Closure Test", &stage);CHKERRQ(ierr);
ierr = PetscLogEventRegister("VecClosureSpec", PETSC_OBJECT_CLASSID, &event);CHKERRQ(ierr);
} else {
ierr = PetscLogStageRegister("DMPlex Vector Closure Test", &stage);CHKERRQ(ierr);
ierr = PetscLogEventRegister("VecClosure", PETSC_OBJECT_CLASSID, &event);CHKERRQ(ierr);
}
}
ierr = PetscLogStagePush(stage);CHKERRQ(ierr);
ierr = DMPlexCreateSection(dm, user->dim, user->numFields, user->numComponents, user->numDof, 0, NULL, NULL, NULL, NULL, &s);CHKERRQ(ierr);
ierr = DMSetDefaultSection(dm, s);CHKERRQ(ierr);
if (useIndex) {ierr = DMPlexCreateClosureIndex(dm, s);CHKERRQ(ierr);}
if (useSpectral) {ierr = DMPlexCreateSpectralClosurePermutation(dm, s);CHKERRQ(ierr);}
ierr = PetscSectionDestroy(&s);CHKERRQ(ierr);
ierr = DMPlexGetHeightStratum(dm, 0, &cStart, &cEnd);CHKERRQ(ierr);
ierr = DMGetLocalVector(dm, &v);CHKERRQ(ierr);
ierr = PetscLogEventBegin(event,0,0,0,0);CHKERRQ(ierr);
for (i = 0; i < user->iterations; ++i) {
for (c = cStart; c < cEnd; ++c) {
PetscScalar *closure = userArray;
PetscInt closureSize = 64;
ierr = DMPlexVecGetClosure(dm, s, v, c, &closureSize, &closure);CHKERRQ(ierr);
if (!user->reuseArray) {ierr = DMPlexVecRestoreClosure(dm, s, v, c, &closureSize, &closure);CHKERRQ(ierr);}
}
}
ierr = PetscLogEventEnd(event,0,0,0,0);CHKERRQ(ierr);
ierr = DMRestoreLocalVector(dm, &v);CHKERRQ(ierr);
ierr = PetscLogStagePop();CHKERRQ(ierr);
ierr = PetscLogEventGetPerfInfo(stage, event, &eventInfo);CHKERRQ(ierr);
numRuns = (cEnd-cStart) * user->iterations;
if (eventInfo.count != 1) SETERRQ2(PETSC_COMM_SELF, PETSC_ERR_PLIB, "Number of event calls %d should be %d", eventInfo.count, 1);
if ((PetscInt) eventInfo.flops != 0) SETERRQ2(PETSC_COMM_SELF, PETSC_ERR_PLIB, "Number of event flops %d should be %d", (PetscInt) eventInfo.flops, 0);
if (eventInfo.time > maxTimePerRun * numRuns) {
const char *title = "VecClosures";
const char *titleIndex = "VecClosures with Index";
const char *titleSpec = "VecClosures Spectral";
const char *titleSpecIndex = "VecClosures Spectral with Index";
ierr = PetscPrintf(PETSC_COMM_SELF, "%s: %d Average time per vector closure: %gs standard: %gs\n", useIndex ? (useSpectral ? titleSpecIndex : titleIndex) : (useSpectral ? titleSpec : title), numRuns, eventInfo.time/numRuns, maxTimePerRun);
if (user->errors) SETERRQ2(PETSC_COMM_SELF, PETSC_ERR_PLIB, "Average time for vector closure %g > standard %g", eventInfo.time/numRuns, maxTimePerRun);
}
PetscFunctionReturn(0);
}
int main(int argc, char **argv)
{
DM dm, dmDist = NULL;
Vec u;
PetscSection section;
PetscViewer viewer;
PetscInt dim = 2, numFields, numBC, i;
PetscInt numComp[3];
PetscInt numDof[12];
PetscInt bcField[1];
IS bcPointIS[1];
PetscBool interpolate = PETSC_TRUE;
PetscErrorCode ierr;
ierr = PetscInitialize(&argc, &argv, NULL, help);CHKERRQ(ierr);
ierr = PetscOptionsGetInt(NULL, "-dim", &dim, NULL);CHKERRQ(ierr);
/* Create a mesh */
ierr = DMPlexCreateBoxMesh(PETSC_COMM_WORLD, dim, interpolate, &dm);CHKERRQ(ierr);
/* Distribute mesh over processes */
ierr = DMPlexDistribute(dm, 0, NULL, &dmDist);CHKERRQ(ierr);
if (dmDist) {ierr = DMDestroy(&dm);CHKERRQ(ierr); dm = dmDist;}
/* Create a scalar field u, a vector field v, and a surface vector field w */
numFields = 3;
numComp[0] = 1;
numComp[1] = dim;
numComp[2] = dim-1;
for (i = 0; i < numFields*(dim+1); ++i) numDof[i] = 0;
/* Let u be defined on vertices */
numDof[0*(dim+1)+0] = 1;
/* Let v be defined on cells */
numDof[1*(dim+1)+dim] = dim;
/* Let v be defined on faces */
numDof[2*(dim+1)+dim-1] = dim-1;
/* Setup boundary conditions */
numBC = 1;
/* Prescribe a Dirichlet condition on u on the boundary
Label "marker" is made by the mesh creation routine */
bcField[0] = 0;
ierr = DMPlexGetStratumIS(dm, "marker", 1, &bcPointIS[0]);CHKERRQ(ierr);
/* Create a PetscSection with this data layout */
ierr = DMPlexCreateSection(dm, dim, numFields, numComp, numDof, numBC, bcField, bcPointIS, NULL, §ion);CHKERRQ(ierr);
ierr = ISDestroy(&bcPointIS[0]);CHKERRQ(ierr);
/* Name the Field variables */
ierr = PetscSectionSetFieldName(section, 0, "u");CHKERRQ(ierr);
ierr = PetscSectionSetFieldName(section, 1, "v");CHKERRQ(ierr);
ierr = PetscSectionSetFieldName(section, 2, "w");CHKERRQ(ierr);
ierr = PetscSectionView(section, PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);
/* Tell the DM to use this data layout */
ierr = DMSetDefaultSection(dm, section);CHKERRQ(ierr);
/* Create a Vec with this layout and view it */
ierr = DMGetGlobalVector(dm, &u);CHKERRQ(ierr);
ierr = PetscViewerCreate(PETSC_COMM_WORLD, &viewer);CHKERRQ(ierr);
ierr = PetscViewerSetType(viewer, PETSCVIEWERVTK);CHKERRQ(ierr);
ierr = PetscViewerSetFormat(viewer, PETSC_VIEWER_ASCII_VTK);CHKERRQ(ierr);
ierr = PetscViewerFileSetName(viewer, "sol.vtk");CHKERRQ(ierr);
ierr = VecView(u, viewer);CHKERRQ(ierr);
ierr = PetscViewerDestroy(&viewer);CHKERRQ(ierr);
ierr = DMRestoreGlobalVector(dm, &u);CHKERRQ(ierr);
/* Cleanup */
ierr = PetscSectionDestroy(§ion);CHKERRQ(ierr);
ierr = DMDestroy(&dm);CHKERRQ(ierr);
ierr = PetscFinalize();
return 0;
}
int main(int argc, char **argv)
{
MPI_Comm comm;
DM dm;
Vec v, nv, rv, coord;
PetscBool test_read = PETSC_FALSE, verbose = PETSC_FALSE, flg;
PetscViewer hdf5Viewer;
PetscInt dim = 2;
PetscInt numFields = 1;
PetscInt numBC = 0;
PetscInt numComp[1] = {2};
PetscInt numDof[3] = {2, 0, 0};
PetscInt bcFields[1] = {0};
IS bcPoints[1] = {NULL};
PetscSection section;
PetscReal norm;
PetscErrorCode ierr;
ierr = PetscInitialize(&argc, &argv, (char *) 0, help);CHKERRQ(ierr);
comm = PETSC_COMM_WORLD;
ierr = PetscOptionsBegin(PETSC_COMM_WORLD,"","Test Options","none");CHKERRQ(ierr);
ierr = PetscOptionsBool("-test_read","Test reading from the HDF5 file","",PETSC_FALSE,&test_read,NULL);CHKERRQ(ierr);
ierr = PetscOptionsBool("-verbose","print the Vecs","",PETSC_FALSE,&verbose,NULL);CHKERRQ(ierr);
ierr = PetscOptionsInt("-dim","the dimension of the problem","",2,&dim,NULL);CHKERRQ(ierr);
ierr = PetscOptionsEnd();
ierr = DMPlexCreateBoxMesh(comm, dim, PETSC_TRUE, &dm);CHKERRQ(ierr);
ierr = DMGetDimension(dm, &dim);CHKERRQ(ierr);
numDof[0] = dim;
ierr = DMPlexCreateSection(dm, dim, numFields, numComp, numDof, numBC, bcFields, bcPoints, NULL, NULL, §ion);CHKERRQ(ierr);
ierr = DMSetDefaultSection(dm, section);CHKERRQ(ierr);
ierr = PetscSectionDestroy(§ion);CHKERRQ(ierr);
ierr = DMSetUseNatural(dm, PETSC_TRUE);CHKERRQ(ierr);
{
DM dmDist;
ierr = DMPlexDistribute(dm, 0, NULL, &dmDist);CHKERRQ(ierr);
if (dmDist) {
ierr = DMDestroy(&dm);CHKERRQ(ierr);
dm = dmDist;
}
}
ierr = DMCreateGlobalVector(dm, &v);CHKERRQ(ierr);
ierr = PetscObjectSetName((PetscObject) v, "V");CHKERRQ(ierr);
ierr = DMGetCoordinates(dm, &coord);CHKERRQ(ierr);
ierr = VecCopy(coord, v);CHKERRQ(ierr);
if (verbose) {
PetscInt size, bs;
ierr = VecGetSize(v, &size);CHKERRQ(ierr);
ierr = VecGetBlockSize(v, &bs);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD, "==== original V in global ordering. size==%d\tblock size=%d\n", size, bs);CHKERRQ(ierr);
ierr = VecView(v, PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);
}
ierr = DMCreateGlobalVector(dm, &nv);CHKERRQ(ierr);
ierr = PetscObjectSetName((PetscObject) nv, "NV");CHKERRQ(ierr);
ierr = DMPlexGlobalToNaturalBegin(dm, v, nv);CHKERRQ(ierr);
ierr = DMPlexGlobalToNaturalEnd(dm, v, nv);CHKERRQ(ierr);
if (verbose) {
PetscInt size, bs;
ierr = VecGetSize(nv, &size);CHKERRQ(ierr);
ierr = VecGetBlockSize(nv, &bs);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD, "==== V in natural ordering. size==%d\tblock size=%d\n", size, bs);CHKERRQ(ierr);
ierr = VecView(nv, PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);
}
ierr = VecViewFromOptions(v, NULL, "-global_vec_view");CHKERRQ(ierr);
if (test_read) {
ierr = DMCreateGlobalVector(dm, &rv);CHKERRQ(ierr);
ierr = PetscObjectSetName((PetscObject) rv, "V");CHKERRQ(ierr);
/* Test native read */
ierr = PetscViewerHDF5Open(comm, "V.h5", FILE_MODE_READ, &hdf5Viewer);CHKERRQ(ierr);
ierr = PetscViewerPushFormat(hdf5Viewer, PETSC_VIEWER_NATIVE);CHKERRQ(ierr);
ierr = VecLoad(rv, hdf5Viewer);CHKERRQ(ierr);
ierr = PetscViewerDestroy(&hdf5Viewer);CHKERRQ(ierr);
if (verbose) {
PetscInt size, bs;
ierr = VecGetSize(rv, &size);CHKERRQ(ierr);
ierr = VecGetBlockSize(rv, &bs);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD, "==== Vector from file. size==%d\tblock size=%d\n", size, bs);CHKERRQ(ierr);
ierr = VecView(rv, PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);
}
ierr = VecEqual(rv, v, &flg);CHKERRQ(ierr);
if (flg) {
ierr = PetscPrintf(PETSC_COMM_WORLD, "V and RV are equal\n");CHKERRQ(ierr);
} else {
ierr = PetscPrintf(PETSC_COMM_WORLD, "V and RV are not equal\n\n");CHKERRQ(ierr);
ierr = VecAXPY(rv, -1.0, v);CHKERRQ(ierr);
ierr = VecNorm(rv, NORM_INFINITY, &norm);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD, "diff norm is = %g\n", (double) norm);CHKERRQ(ierr);
ierr = VecView(rv, PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);
}
/* Test raw read */
ierr = PetscViewerHDF5Open(comm, "V.h5", FILE_MODE_READ, &hdf5Viewer);CHKERRQ(ierr);
ierr = VecLoad(rv, hdf5Viewer);CHKERRQ(ierr);
ierr = PetscViewerDestroy(&hdf5Viewer);CHKERRQ(ierr);
if (verbose) {
PetscInt size, bs;
ierr = VecGetSize(rv, &size);CHKERRQ(ierr);
ierr = VecGetBlockSize(rv, &bs);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD, "==== Vector from file. size==%d\tblock size=%d\n", size, bs);CHKERRQ(ierr);
ierr = VecView(rv, PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);
}
ierr = VecEqual(rv, nv, &flg);CHKERRQ(ierr);
if (flg) {
ierr = PetscPrintf(PETSC_COMM_WORLD, "NV and RV are equal\n");CHKERRQ(ierr);
} else {
ierr = PetscPrintf(PETSC_COMM_WORLD, "NV and RV are not equal\n\n");CHKERRQ(ierr);
ierr = VecAXPY(rv, -1.0, v);CHKERRQ(ierr);
ierr = VecNorm(rv, NORM_INFINITY, &norm);CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD, "diff norm is = %g\n", (double) norm);CHKERRQ(ierr);
ierr = VecView(rv, PETSC_VIEWER_STDOUT_WORLD);CHKERRQ(ierr);
}
ierr = VecDestroy(&rv);CHKERRQ(ierr);
}
ierr = VecDestroy(&nv);CHKERRQ(ierr);
ierr = VecDestroy(&v);CHKERRQ(ierr);
ierr = DMDestroy(&dm);CHKERRQ(ierr);
ierr = PetscFinalize();
return 0;
}
static PetscErrorCode DMPlexTSSetupGeometry(DM dm, PetscFV fvm, DMTS_Plex *dmplexts)
{
DM dmFace, dmCell;
DMLabel ghostLabel;
PetscSection sectionFace, sectionCell;
PetscSection coordSection;
Vec coordinates;
PetscReal minradius;
PetscScalar *fgeom, *cgeom;
PetscInt dim, cStart, cEnd, cEndInterior, c, fStart, fEnd, f;
PetscErrorCode ierr;
PetscFunctionBegin;
if (dmplexts->setupGeom) PetscFunctionReturn(0);
ierr = DMPlexGetDimension(dm, &dim);CHKERRQ(ierr);
ierr = DMGetCoordinateSection(dm, &coordSection);CHKERRQ(ierr);
ierr = DMGetCoordinatesLocal(dm, &coordinates);CHKERRQ(ierr);
/* Make cell centroids and volumes */
ierr = DMClone(dm, &dmCell);CHKERRQ(ierr);
ierr = DMSetCoordinateSection(dmCell, coordSection);CHKERRQ(ierr);
ierr = DMSetCoordinatesLocal(dmCell, coordinates);CHKERRQ(ierr);
ierr = PetscSectionCreate(PetscObjectComm((PetscObject) dm), §ionCell);CHKERRQ(ierr);
ierr = DMPlexGetHeightStratum(dm, 0, &cStart, &cEnd);CHKERRQ(ierr);
ierr = DMPlexGetHybridBounds(dm, &cEndInterior, NULL, NULL, NULL);CHKERRQ(ierr);
ierr = PetscSectionSetChart(sectionCell, cStart, cEnd);CHKERRQ(ierr);
for (c = cStart; c < cEnd; ++c) {ierr = PetscSectionSetDof(sectionCell, c, sizeof(CellGeom)/sizeof(PetscScalar));CHKERRQ(ierr);}
ierr = PetscSectionSetUp(sectionCell);CHKERRQ(ierr);
ierr = DMSetDefaultSection(dmCell, sectionCell);CHKERRQ(ierr);
ierr = PetscSectionDestroy(§ionCell);CHKERRQ(ierr);
ierr = DMCreateLocalVector(dmCell, &dmplexts->cellgeom);CHKERRQ(ierr);
ierr = VecGetArray(dmplexts->cellgeom, &cgeom);CHKERRQ(ierr);
for (c = cStart; c < cEndInterior; ++c) {
CellGeom *cg;
ierr = DMPlexPointLocalRef(dmCell, c, cgeom, &cg);CHKERRQ(ierr);
ierr = PetscMemzero(cg, sizeof(*cg));CHKERRQ(ierr);
ierr = DMPlexComputeCellGeometryFVM(dmCell, c, &cg->volume, cg->centroid, NULL);CHKERRQ(ierr);
}
/* Compute face normals and minimum cell radius */
ierr = DMClone(dm, &dmFace);CHKERRQ(ierr);
ierr = PetscSectionCreate(PetscObjectComm((PetscObject) dm), §ionFace);CHKERRQ(ierr);
ierr = DMPlexGetHeightStratum(dm, 1, &fStart, &fEnd);CHKERRQ(ierr);
ierr = PetscSectionSetChart(sectionFace, fStart, fEnd);CHKERRQ(ierr);
for (f = fStart; f < fEnd; ++f) {ierr = PetscSectionSetDof(sectionFace, f, sizeof(FaceGeom)/sizeof(PetscScalar));CHKERRQ(ierr);}
ierr = PetscSectionSetUp(sectionFace);CHKERRQ(ierr);
ierr = DMSetDefaultSection(dmFace, sectionFace);CHKERRQ(ierr);
ierr = PetscSectionDestroy(§ionFace);CHKERRQ(ierr);
ierr = DMCreateLocalVector(dmFace, &dmplexts->facegeom);CHKERRQ(ierr);
ierr = VecGetArray(dmplexts->facegeom, &fgeom);CHKERRQ(ierr);
ierr = DMPlexGetLabel(dm, "ghost", &ghostLabel);CHKERRQ(ierr);
minradius = PETSC_MAX_REAL;
for (f = fStart; f < fEnd; ++f) {
FaceGeom *fg;
PetscReal area;
PetscInt ghost, d;
ierr = DMLabelGetValue(ghostLabel, f, &ghost);CHKERRQ(ierr);
if (ghost >= 0) continue;
ierr = DMPlexPointLocalRef(dmFace, f, fgeom, &fg);CHKERRQ(ierr);
ierr = DMPlexComputeCellGeometryFVM(dm, f, &area, fg->centroid, fg->normal);CHKERRQ(ierr);
for (d = 0; d < dim; ++d) fg->normal[d] *= area;
/* Flip face orientation if necessary to match ordering in support, and Update minimum radius */
{
CellGeom *cL, *cR;
const PetscInt *cells;
PetscReal *lcentroid, *rcentroid;
PetscReal v[3];
ierr = DMPlexGetSupport(dm, f, &cells);CHKERRQ(ierr);
ierr = DMPlexPointLocalRead(dmCell, cells[0], cgeom, &cL);CHKERRQ(ierr);
ierr = DMPlexPointLocalRead(dmCell, cells[1], cgeom, &cR);CHKERRQ(ierr);
lcentroid = cells[0] >= cEndInterior ? fg->centroid : cL->centroid;
rcentroid = cells[1] >= cEndInterior ? fg->centroid : cR->centroid;
WaxpyD(dim, -1, lcentroid, rcentroid, v);
if (DotRealD(dim, fg->normal, v) < 0) {
for (d = 0; d < dim; ++d) fg->normal[d] = -fg->normal[d];
}
if (DotRealD(dim, fg->normal, v) <= 0) {
if (dim == 2) SETERRQ5(PETSC_COMM_SELF,PETSC_ERR_PLIB,"Direction for face %d could not be fixed, normal (%g,%g) v (%g,%g)", f, (double) fg->normal[0], (double) fg->normal[1], (double) v[0], (double) v[1]);
if (dim == 3) SETERRQ7(PETSC_COMM_SELF,PETSC_ERR_PLIB,"Direction for face %d could not be fixed, normal (%g,%g,%g) v (%g,%g,%g)", f, (double) fg->normal[0], (double) fg->normal[1], (double) fg->normal[2], (double) v[0], (double) v[1], (double) v[2]);
SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_PLIB,"Direction for face %d could not be fixed", f);
}
if (cells[0] < cEndInterior) {
WaxpyD(dim, -1, fg->centroid, cL->centroid, v);
minradius = PetscMin(minradius, NormD(dim, v));
}
if (cells[1] < cEndInterior) {
WaxpyD(dim, -1, fg->centroid, cR->centroid, v);
minradius = PetscMin(minradius, NormD(dim, v));
}
}
}
ierr = MPI_Allreduce(&minradius, &dmplexts->minradius, 1, MPIU_REAL, MPI_MIN, PetscObjectComm((PetscObject)dm));CHKERRQ(ierr);
/* Compute centroids of ghost cells */
for (c = cEndInterior; c < cEnd; ++c) {
FaceGeom *fg;
const PetscInt *cone, *support;
PetscInt coneSize, supportSize, s;
ierr = DMPlexGetConeSize(dmCell, c, &coneSize);CHKERRQ(ierr);
if (coneSize != 1) SETERRQ2(PETSC_COMM_SELF, PETSC_ERR_ARG_WRONG, "Ghost cell %d has cone size %d != 1", c, coneSize);
ierr = DMPlexGetCone(dmCell, c, &cone);CHKERRQ(ierr);
ierr = DMPlexGetSupportSize(dmCell, cone[0], &supportSize);CHKERRQ(ierr);
if (supportSize != 2) SETERRQ2(PETSC_COMM_SELF, PETSC_ERR_ARG_WRONG, "Face %d has support size %d != 1", cone[0], supportSize);
ierr = DMPlexGetSupport(dmCell, cone[0], &support);CHKERRQ(ierr);
ierr = DMPlexPointLocalRef(dmFace, cone[0], fgeom, &fg);CHKERRQ(ierr);
for (s = 0; s < 2; ++s) {
/* Reflect ghost centroid across plane of face */
if (support[s] == c) {
const CellGeom *ci;
CellGeom *cg;
PetscReal c2f[3], a;
ierr = DMPlexPointLocalRead(dmCell, support[(s+1)%2], cgeom, &ci);CHKERRQ(ierr);
WaxpyD(dim, -1, ci->centroid, fg->centroid, c2f); /* cell to face centroid */
a = DotRealD(dim, c2f, fg->normal)/DotRealD(dim, fg->normal, fg->normal);
ierr = DMPlexPointLocalRef(dmCell, support[s], cgeom, &cg);CHKERRQ(ierr);
WaxpyD(dim, 2*a, fg->normal, ci->centroid, cg->centroid);
cg->volume = ci->volume;
}
}
}
ierr = VecRestoreArray(dmplexts->facegeom, &fgeom);CHKERRQ(ierr);
ierr = VecRestoreArray(dmplexts->cellgeom, &cgeom);CHKERRQ(ierr);
ierr = DMDestroy(&dmCell);CHKERRQ(ierr);
ierr = DMDestroy(&dmFace);CHKERRQ(ierr);
dmplexts->setupGeom = PETSC_TRUE;
PetscFunctionReturn(0);
}
/*@
DMPlexPermute - Reorder the mesh according to the input permutation
Collective on DM
Input Parameter:
+ dm - The DMPlex object
- perm - The point permutation, perm[old point number] = new point number
Output Parameter:
. pdm - The permuted DM
Level: intermediate
.keywords: mesh
.seealso: MatPermute()
@*/
PetscErrorCode DMPlexPermute(DM dm, IS perm, DM *pdm)
{
DM_Plex *plex = (DM_Plex *) dm->data, *plexNew;
PetscSection section, sectionNew;
PetscInt dim;
PetscErrorCode ierr;
PetscFunctionBegin;
PetscValidHeaderSpecific(dm, DM_CLASSID, 1);
PetscValidHeaderSpecific(perm, IS_CLASSID, 2);
PetscValidPointer(pdm, 3);
ierr = DMCreate(PetscObjectComm((PetscObject) dm), pdm);CHKERRQ(ierr);
ierr = DMSetType(*pdm, DMPLEX);CHKERRQ(ierr);
ierr = DMGetDimension(dm, &dim);CHKERRQ(ierr);
ierr = DMSetDimension(*pdm, dim);CHKERRQ(ierr);
ierr = DMGetDefaultSection(dm, §ion);CHKERRQ(ierr);
if (section) {
ierr = PetscSectionPermute(section, perm, §ionNew);CHKERRQ(ierr);
ierr = DMSetDefaultSection(*pdm, sectionNew);CHKERRQ(ierr);
ierr = PetscSectionDestroy(§ionNew);CHKERRQ(ierr);
}
plexNew = (DM_Plex *) (*pdm)->data;
/* Ignore ltogmap, ltogmapb */
/* Ignore sf, defaultSF */
/* Ignore globalVertexNumbers, globalCellNumbers */
/* Remap coordinates */
{
DM cdm, cdmNew;
PetscSection csection, csectionNew;
Vec coordinates, coordinatesNew;
PetscScalar *coords, *coordsNew;
const PetscInt *pperm;
PetscInt pStart, pEnd, p;
const char *name;
ierr = DMGetCoordinateDM(dm, &cdm);CHKERRQ(ierr);
ierr = DMGetDefaultSection(cdm, &csection);CHKERRQ(ierr);
ierr = PetscSectionPermute(csection, perm, &csectionNew);CHKERRQ(ierr);
ierr = DMGetCoordinatesLocal(dm, &coordinates);CHKERRQ(ierr);
ierr = VecDuplicate(coordinates, &coordinatesNew);CHKERRQ(ierr);
ierr = PetscObjectGetName((PetscObject)coordinates,&name);CHKERRQ(ierr);
ierr = PetscObjectSetName((PetscObject)coordinatesNew,name);CHKERRQ(ierr);
ierr = VecGetArray(coordinates, &coords);CHKERRQ(ierr);
ierr = VecGetArray(coordinatesNew, &coordsNew);CHKERRQ(ierr);
ierr = PetscSectionGetChart(csectionNew, &pStart, &pEnd);CHKERRQ(ierr);
ierr = ISGetIndices(perm, &pperm);CHKERRQ(ierr);
for (p = pStart; p < pEnd; ++p) {
PetscInt dof, off, offNew, d;
ierr = PetscSectionGetDof(csectionNew, p, &dof);CHKERRQ(ierr);
ierr = PetscSectionGetOffset(csection, p, &off);CHKERRQ(ierr);
ierr = PetscSectionGetOffset(csectionNew, pperm[p], &offNew);CHKERRQ(ierr);
for (d = 0; d < dof; ++d) coordsNew[offNew+d] = coords[off+d];
}
ierr = ISRestoreIndices(perm, &pperm);CHKERRQ(ierr);
ierr = VecRestoreArray(coordinates, &coords);CHKERRQ(ierr);
ierr = VecRestoreArray(coordinatesNew, &coordsNew);CHKERRQ(ierr);
ierr = DMGetCoordinateDM(*pdm, &cdmNew);CHKERRQ(ierr);
ierr = DMSetDefaultSection(cdmNew, csectionNew);CHKERRQ(ierr);
ierr = DMSetCoordinatesLocal(*pdm, coordinatesNew);CHKERRQ(ierr);
ierr = PetscSectionDestroy(&csectionNew);CHKERRQ(ierr);
ierr = VecDestroy(&coordinatesNew);CHKERRQ(ierr);
}
/* Reorder labels */
{
PetscInt numLabels, l;
DMLabel label, labelNew;
ierr = DMGetNumLabels(dm, &numLabels);CHKERRQ(ierr);
for (l = numLabels-1; l >= 0; --l) {
ierr = DMGetLabelByNum(dm, l, &label);CHKERRQ(ierr);
ierr = DMLabelPermute(label, perm, &labelNew);CHKERRQ(ierr);
ierr = DMAddLabel(*pdm, labelNew);CHKERRQ(ierr);
}
if (plex->subpointMap) {ierr = DMLabelPermute(plex->subpointMap, perm, &plexNew->subpointMap);CHKERRQ(ierr);}
}
/* Reorder topology */
{
const PetscInt *pperm;
PetscInt maxConeSize, maxSupportSize, n, pStart, pEnd, p;
ierr = DMPlexGetMaxSizes(dm, &maxConeSize, &maxSupportSize);CHKERRQ(ierr);
plexNew->maxConeSize = maxConeSize;
plexNew->maxSupportSize = maxSupportSize;
ierr = PetscSectionDestroy(&plexNew->coneSection);CHKERRQ(ierr);
ierr = PetscSectionPermute(plex->coneSection, perm, &plexNew->coneSection);CHKERRQ(ierr);
ierr = PetscSectionGetStorageSize(plexNew->coneSection, &n);CHKERRQ(ierr);
ierr = PetscMalloc1(n, &plexNew->cones);CHKERRQ(ierr);
ierr = PetscMalloc1(n, &plexNew->coneOrientations);CHKERRQ(ierr);
ierr = ISGetIndices(perm, &pperm);CHKERRQ(ierr);
ierr = PetscSectionGetChart(plex->coneSection, &pStart, &pEnd);CHKERRQ(ierr);
for (p = pStart; p < pEnd; ++p) {
PetscInt dof, off, offNew, d;
ierr = PetscSectionGetDof(plexNew->coneSection, pperm[p], &dof);CHKERRQ(ierr);
ierr = PetscSectionGetOffset(plex->coneSection, p, &off);CHKERRQ(ierr);
ierr = PetscSectionGetOffset(plexNew->coneSection, pperm[p], &offNew);CHKERRQ(ierr);
for (d = 0; d < dof; ++d) {
plexNew->cones[offNew+d] = pperm[plex->cones[off+d]];
plexNew->coneOrientations[offNew+d] = plex->coneOrientations[off+d];
}
}
ierr = PetscSectionDestroy(&plexNew->supportSection);CHKERRQ(ierr);
ierr = PetscSectionPermute(plex->supportSection, perm, &plexNew->supportSection);CHKERRQ(ierr);
ierr = PetscSectionGetStorageSize(plexNew->supportSection, &n);CHKERRQ(ierr);
ierr = PetscMalloc1(n, &plexNew->supports);CHKERRQ(ierr);
ierr = PetscSectionGetChart(plex->supportSection, &pStart, &pEnd);CHKERRQ(ierr);
for (p = pStart; p < pEnd; ++p) {
PetscInt dof, off, offNew, d;
ierr = PetscSectionGetDof(plexNew->supportSection, pperm[p], &dof);CHKERRQ(ierr);
ierr = PetscSectionGetOffset(plex->supportSection, p, &off);CHKERRQ(ierr);
ierr = PetscSectionGetOffset(plexNew->supportSection, pperm[p], &offNew);CHKERRQ(ierr);
for (d = 0; d < dof; ++d) {
plexNew->supports[offNew+d] = pperm[plex->supports[off+d]];
}
}
ierr = ISRestoreIndices(perm, &pperm);CHKERRQ(ierr);
}
PetscFunctionReturn(0);
}
void test(DM mesh) {
const int dim = 2;
const int field_count = 1;
int components[field_count];
int dof[field_count*(dim+1)];
// Field 0 - temperature
components[0] = 1;
dof[0*(dim+1) + 0] = 1; // vertices
dof[0*(dim+1) + 1] = 0; // faces
// Field 1 - pressure
components[1] = 1;
dof[1*(dim+1) + 0] = 64; // vertices
dof[1*(dim+1) + 1] = 0; // faces
PetscSection section;
DMPlexCreateSection(mesh,
dim, // Spatial dimension
field_count, // Number of fields
components, // Component count for each field
dof, // DoF for each field component
0, // Number of boundary conditions
NULL, // BC Field
NULL, // BC Points
§ion);
DMSetDefaultSection(mesh, section);
// Temperature
// Create a global vector
Vec temperature = NULL;
DMCreateGlobalVector(mesh, &temperature);
// Get a temporary local vector & a pointer to its data
Vec localTemp = NULL;
DMGetLocalVector(mesh, &localTemp);
PetscScalar * data = NULL;
VecGetArray(localTemp, &data);
// Loop over points in the section
int start, end;
DMGetDefaultSection(mesh, §ion);
PetscSectionGetChart(section, &start, &end);
for (int point=start; point<end; ++point) {
// Get the size & offset of field 0
int dof, offset;
PetscSectionGetFieldDof(section, point, 0, &dof);
PetscSectionGetFieldOffset(section, point, 0, &offset);
// Set values
for (int d=0; d<dof; ++d){
data[offset+d] = point * 100 + d;
}
}
VecRestoreArray(localTemp, &data);
// Broadcast values
DMLocalToGlobalBegin(mesh, localTemp, INSERT_VALUES, temperature);
DMLocalToGlobalEnd(mesh, localTemp, INSERT_VALUES, temperature);
// Now each node should have all temperature values
// Free the temp vector
DMRestoreLocalVector(mesh,&localTemp);
}
