Date: 2025-03-29T05:58:21+00:00

Actual source code: plexpreallocate.c

      1: #include <petsc/private/dmpleximpl.h>
      2: #include <petsc/private/isimpl.h>
      3: #include <petscsf.h>
      4: #include <petscds.h>

      6: /* get adjacencies due to point-to-point constraints that can't be found with DMPlexGetAdjacency() */
      7: static PetscErrorCode DMPlexComputeAnchorAdjacencies(DM dm, PetscBool useCone, PetscBool useClosure, PetscSection *anchorSectionAdj, PetscInt *anchorAdj[])
      8: {
      9:   PetscInt     pStart, pEnd;
     10:   PetscSection section, sectionGlobal, adjSec, aSec;
     11:   IS           aIS;

     13:   PetscFunctionBegin;
     14:   PetscCall(DMGetLocalSection(dm, &section));
     15:   PetscCall(DMGetGlobalSection(dm, &sectionGlobal));
     16:   PetscCall(PetscSectionCreate(PetscObjectComm((PetscObject)section), &adjSec));
     17:   PetscCall(PetscSectionGetChart(section, &pStart, &pEnd));
     18:   PetscCall(PetscSectionSetChart(adjSec, pStart, pEnd));

     20:   PetscCall(DMPlexGetAnchors(dm, &aSec, &aIS));
     21:   if (aSec) {
     22:     const PetscInt *anchors;
     23:     PetscInt        p, q, a, aSize, *offsets, aStart, aEnd, *inverse, iSize, *adj, adjSize;
     24:     PetscInt       *tmpAdjP = NULL, *tmpAdjQ = NULL;
     25:     PetscSection    inverseSec;

     27:     /* invert the constraint-to-anchor map */
     28:     PetscCall(PetscSectionCreate(PetscObjectComm((PetscObject)aSec), &inverseSec));
     29:     PetscCall(PetscSectionSetChart(inverseSec, pStart, pEnd));
     30:     PetscCall(ISGetLocalSize(aIS, &aSize));
     31:     PetscCall(ISGetIndices(aIS, &anchors));

     33:     for (p = 0; p < aSize; p++) {
     34:       PetscInt a = anchors[p];

     36:       PetscCall(PetscSectionAddDof(inverseSec, a, 1));
     37:     }
     38:     PetscCall(PetscSectionSetUp(inverseSec));
     39:     PetscCall(PetscSectionGetStorageSize(inverseSec, &iSize));
     40:     PetscCall(PetscMalloc1(iSize, &inverse));
     41:     PetscCall(PetscCalloc1(pEnd - pStart, &offsets));
     42:     PetscCall(PetscSectionGetChart(aSec, &aStart, &aEnd));
     43:     for (p = aStart; p < aEnd; p++) {
     44:       PetscInt dof, off;

     46:       PetscCall(PetscSectionGetDof(aSec, p, &dof));
     47:       PetscCall(PetscSectionGetOffset(aSec, p, &off));

     49:       for (q = 0; q < dof; q++) {
     50:         PetscInt iOff;

     52:         a = anchors[off + q];
     53:         PetscCall(PetscSectionGetOffset(inverseSec, a, &iOff));
     54:         inverse[iOff + offsets[a - pStart]++] = p;
     55:       }
     56:     }
     57:     PetscCall(ISRestoreIndices(aIS, &anchors));
     58:     PetscCall(PetscFree(offsets));

     60:     /* construct anchorAdj and adjSec
     61:      *
     62:      * loop over anchors:
     63:      *   construct anchor adjacency
     64:      *   loop over constrained:
     65:      *     construct constrained adjacency
     66:      *     if not in anchor adjacency, add to dofs
     67:      * setup adjSec, allocate anchorAdj
     68:      * loop over anchors:
     69:      *   construct anchor adjacency
     70:      *   loop over constrained:
     71:      *     construct constrained adjacency
     72:      *     if not in anchor adjacency
     73:      *       if not already in list, put in list
     74:      *   sort, unique, reduce dof count
     75:      * optional: compactify
     76:      */
     77:     for (p = pStart; p < pEnd; p++) {
     78:       PetscInt iDof, iOff, i, r, s, numAdjP = PETSC_DETERMINE;

     80:       PetscCall(PetscSectionGetDof(inverseSec, p, &iDof));
     81:       if (!iDof) continue;
     82:       PetscCall(PetscSectionGetOffset(inverseSec, p, &iOff));
     83:       PetscCall(DMPlexGetAdjacency_Internal(dm, p, useCone, useClosure, PETSC_TRUE, &numAdjP, &tmpAdjP));
     84:       for (i = 0; i < iDof; i++) {
     85:         PetscInt iNew = 0, qAdj, qAdjDof, qAdjCDof, numAdjQ = PETSC_DETERMINE;

     87:         q = inverse[iOff + i];
     88:         PetscCall(DMPlexGetAdjacency_Internal(dm, q, useCone, useClosure, PETSC_TRUE, &numAdjQ, &tmpAdjQ));
     89:         for (r = 0; r < numAdjQ; r++) {
     90:           qAdj = tmpAdjQ[r];
     91:           if ((qAdj < pStart) || (qAdj >= pEnd)) continue;
     92:           for (s = 0; s < numAdjP; s++) {
     93:             if (qAdj == tmpAdjP[s]) break;
     94:           }
     95:           if (s < numAdjP) continue;
     96:           PetscCall(PetscSectionGetDof(section, qAdj, &qAdjDof));
     97:           PetscCall(PetscSectionGetConstraintDof(section, qAdj, &qAdjCDof));
     98:           iNew += qAdjDof - qAdjCDof;
     99:         }
    100:         PetscCall(PetscSectionAddDof(adjSec, p, iNew));
    101:       }
    102:     }

    104:     PetscCall(PetscSectionSetUp(adjSec));
    105:     PetscCall(PetscSectionGetStorageSize(adjSec, &adjSize));
    106:     PetscCall(PetscMalloc1(adjSize, &adj));

    108:     for (p = pStart; p < pEnd; p++) {
    109:       PetscInt iDof, iOff, i, r, s, aOff, aOffOrig, aDof, numAdjP = PETSC_DETERMINE;

    111:       PetscCall(PetscSectionGetDof(inverseSec, p, &iDof));
    112:       if (!iDof) continue;
    113:       PetscCall(PetscSectionGetOffset(inverseSec, p, &iOff));
    114:       PetscCall(DMPlexGetAdjacency_Internal(dm, p, useCone, useClosure, PETSC_TRUE, &numAdjP, &tmpAdjP));
    115:       PetscCall(PetscSectionGetDof(adjSec, p, &aDof));
    116:       PetscCall(PetscSectionGetOffset(adjSec, p, &aOff));
    117:       aOffOrig = aOff;
    118:       for (i = 0; i < iDof; i++) {
    119:         PetscInt qAdj, qAdjDof, qAdjCDof, qAdjOff, nd, numAdjQ = PETSC_DETERMINE;

    121:         q = inverse[iOff + i];
    122:         PetscCall(DMPlexGetAdjacency_Internal(dm, q, useCone, useClosure, PETSC_TRUE, &numAdjQ, &tmpAdjQ));
    123:         for (r = 0; r < numAdjQ; r++) {
    124:           qAdj = tmpAdjQ[r];
    125:           if ((qAdj < pStart) || (qAdj >= pEnd)) continue;
    126:           for (s = 0; s < numAdjP; s++) {
    127:             if (qAdj == tmpAdjP[s]) break;
    128:           }
    129:           if (s < numAdjP) continue;
    130:           PetscCall(PetscSectionGetDof(section, qAdj, &qAdjDof));
    131:           PetscCall(PetscSectionGetConstraintDof(section, qAdj, &qAdjCDof));
    132:           PetscCall(PetscSectionGetOffset(sectionGlobal, qAdj, &qAdjOff));
    133:           for (nd = 0; nd < qAdjDof - qAdjCDof; ++nd) adj[aOff++] = (qAdjOff < 0 ? -(qAdjOff + 1) : qAdjOff) + nd;
    134:         }
    135:       }
    136:       PetscCall(PetscSortRemoveDupsInt(&aDof, PetscSafePointerPlusOffset(adj, aOffOrig)));
    137:       PetscCall(PetscSectionSetDof(adjSec, p, aDof));
    138:     }
    139:     *anchorAdj = adj;

    141:     /* clean up */
    142:     PetscCall(PetscSectionDestroy(&inverseSec));
    143:     PetscCall(PetscFree(inverse));
    144:     PetscCall(PetscFree(tmpAdjP));
    145:     PetscCall(PetscFree(tmpAdjQ));
    146:   } else {
    147:     *anchorAdj = NULL;
    148:     PetscCall(PetscSectionSetUp(adjSec));
    149:   }
    150:   *anchorSectionAdj = adjSec;
    151:   PetscFunctionReturn(PETSC_SUCCESS);
    152: }

    154: static PetscErrorCode DMPlexCreateAdjacencySection_Static(DM dm, PetscInt bs, PetscSF sfDof, PetscBool useCone, PetscBool useClosure, PetscBool useAnchors, PetscSection *sA, PetscInt **colIdx)
    155: {
    156:   MPI_Comm           comm;
    157:   PetscMPIInt        size;
    158:   PetscBool          doCommLocal, doComm, debug = PETSC_FALSE;
    159:   PetscSF            sf, sfAdj;
    160:   PetscSection       section, sectionGlobal, leafSectionAdj, rootSectionAdj, sectionAdj, anchorSectionAdj;
    161:   PetscInt           nroots, nleaves, l, p, r;
    162:   const PetscInt    *leaves;
    163:   const PetscSFNode *remotes;
    164:   PetscInt           dim, pStart, pEnd, numDof, globalOffStart, globalOffEnd, numCols;
    165:   PetscInt          *tmpAdj = NULL, *adj, *rootAdj, *anchorAdj = NULL, *cols, *remoteOffsets;
    166:   PetscInt           adjSize;

    168:   PetscFunctionBegin;
    169:   PetscCall(PetscObjectGetComm((PetscObject)dm, &comm));
    170:   PetscCall(PetscOptionsGetBool(NULL, NULL, "-dm_view_preallocation", &debug, NULL));
    171:   PetscCallMPI(MPI_Comm_size(comm, &size));
    172:   PetscCall(DMGetDimension(dm, &dim));
    173:   PetscCall(DMGetPointSF(dm, &sf));
    174:   PetscCall(DMGetLocalSection(dm, &section));
    175:   PetscCall(DMGetGlobalSection(dm, &sectionGlobal));
    176:   PetscCall(PetscSFGetGraph(sf, &nroots, NULL, NULL, NULL));
    177:   doCommLocal = (size > 1) && (nroots >= 0) ? PETSC_TRUE : PETSC_FALSE;
    178:   PetscCallMPI(MPIU_Allreduce(&doCommLocal, &doComm, 1, MPIU_BOOL, MPI_LAND, comm));
    179:   /* Create section for dof adjacency (dof ==> # adj dof) */
    180:   PetscCall(PetscSectionGetChart(section, &pStart, &pEnd));
    181:   PetscCall(PetscSectionGetStorageSize(section, &numDof));
    182:   PetscCall(PetscSectionCreate(comm, &leafSectionAdj));
    183:   PetscCall(PetscSectionSetChart(leafSectionAdj, 0, numDof));
    184:   PetscCall(PetscSectionCreate(comm, &rootSectionAdj));
    185:   PetscCall(PetscSectionSetChart(rootSectionAdj, 0, numDof));
    186:   /*   Fill in the ghost dofs on the interface */
    187:   PetscCall(PetscSFGetGraph(sf, NULL, &nleaves, &leaves, &remotes));
    188:   /*
    189:    section        - maps points to (# dofs, local dofs)
    190:    sectionGlobal  - maps points to (# dofs, global dofs)
    191:    leafSectionAdj - maps unowned local dofs to # adj dofs
    192:    rootSectionAdj - maps   owned local dofs to # adj dofs
    193:    adj            - adj global dofs indexed by leafSectionAdj
    194:    rootAdj        - adj global dofs indexed by rootSectionAdj
    195:    sf    - describes shared points across procs
    196:    sfDof - describes shared dofs across procs
    197:    sfAdj - describes shared adjacent dofs across procs
    198:    ** The bootstrapping process involves six rounds with similar structure of visiting neighbors of each point.
    199:   (0). If there are point-to-point constraints, add the adjacencies of constrained points to anchors in anchorAdj
    200:        (This is done in DMPlexComputeAnchorAdjacencies())
    201:     1. Visit unowned points on interface, count adjacencies placing in leafSectionAdj
    202:        Reduce those counts to rootSectionAdj (now redundantly counting some interface points)
    203:     2. Visit owned points on interface, count adjacencies placing in rootSectionAdj
    204:        Create sfAdj connecting rootSectionAdj and leafSectionAdj
    205:     3. Visit unowned points on interface, write adjacencies to adj
    206:        Gather adj to rootAdj (note that there is redundancy in rootAdj when multiple procs find the same adjacencies)
    207:     4. Visit owned points on interface, write adjacencies to rootAdj
    208:        Remove redundancy in rootAdj
    209:    ** The last two traversals use transitive closure
    210:     5. Visit all owned points in the subdomain, count dofs for each point (sectionAdj)
    211:        Allocate memory addressed by sectionAdj (cols)
    212:     6. Visit all owned points in the subdomain, insert dof adjacencies into cols
    213:    ** Knowing all the column adjacencies, check ownership and sum into dnz and onz
    214:   */
    215:   PetscCall(DMPlexComputeAnchorAdjacencies(dm, useCone, useClosure, &anchorSectionAdj, &anchorAdj));
    216:   for (l = 0; l < nleaves; ++l) {
    217:     PetscInt dof, off, d, q, anDof;
    218:     PetscInt p = leaves[l], numAdj = PETSC_DETERMINE;

    220:     if ((p < pStart) || (p >= pEnd)) continue;
    221:     PetscCall(PetscSectionGetDof(section, p, &dof));
    222:     PetscCall(PetscSectionGetOffset(section, p, &off));
    223:     PetscCall(DMPlexGetAdjacency_Internal(dm, p, useCone, useClosure, useAnchors, &numAdj, &tmpAdj));
    224:     for (q = 0; q < numAdj; ++q) {
    225:       const PetscInt padj = tmpAdj[q];
    226:       PetscInt       ndof, ncdof;

    228:       if ((padj < pStart) || (padj >= pEnd)) continue;
    229:       PetscCall(PetscSectionGetDof(section, padj, &ndof));
    230:       PetscCall(PetscSectionGetConstraintDof(section, padj, &ncdof));
    231:       for (d = off; d < off + dof; ++d) PetscCall(PetscSectionAddDof(leafSectionAdj, d, ndof - ncdof));
    232:     }
    233:     PetscCall(PetscSectionGetDof(anchorSectionAdj, p, &anDof));
    234:     if (anDof) {
    235:       for (d = off; d < off + dof; ++d) PetscCall(PetscSectionAddDof(leafSectionAdj, d, anDof));
    236:     }
    237:   }
    238:   PetscCall(PetscSectionSetUp(leafSectionAdj));
    239:   if (debug) {
    240:     PetscCall(PetscPrintf(comm, "Adjacency Section for Preallocation on Leaves:\n"));
    241:     PetscCall(PetscSectionView(leafSectionAdj, NULL));
    242:   }
    243:   /* Get maximum remote adjacency sizes for owned dofs on interface (roots) */
    244:   if (doComm) {
    245:     PetscCall(PetscSFReduceBegin(sfDof, MPIU_INT, leafSectionAdj->atlasDof, rootSectionAdj->atlasDof, MPI_SUM));
    246:     PetscCall(PetscSFReduceEnd(sfDof, MPIU_INT, leafSectionAdj->atlasDof, rootSectionAdj->atlasDof, MPI_SUM));
    247:     PetscCall(PetscSectionInvalidateMaxDof_Internal(rootSectionAdj));
    248:   }
    249:   if (debug) {
    250:     PetscCall(PetscPrintf(comm, "Adjacency Section for Preallocation on Roots:\n"));
    251:     PetscCall(PetscSectionView(rootSectionAdj, NULL));
    252:   }
    253:   /* Add in local adjacency sizes for owned dofs on interface (roots) */
    254:   for (p = pStart; p < pEnd; ++p) {
    255:     PetscInt numAdj = PETSC_DETERMINE, adof, dof, off, d, q, anDof;

    257:     PetscCall(PetscSectionGetDof(section, p, &dof));
    258:     PetscCall(PetscSectionGetOffset(section, p, &off));
    259:     if (!dof) continue;
    260:     PetscCall(PetscSectionGetDof(rootSectionAdj, off, &adof));
    261:     if (adof <= 0) continue;
    262:     PetscCall(DMPlexGetAdjacency_Internal(dm, p, useCone, useClosure, useAnchors, &numAdj, &tmpAdj));
    263:     for (q = 0; q < numAdj; ++q) {
    264:       const PetscInt padj = tmpAdj[q];
    265:       PetscInt       ndof, ncdof;

    267:       if ((padj < pStart) || (padj >= pEnd)) continue;
    268:       PetscCall(PetscSectionGetDof(section, padj, &ndof));
    269:       PetscCall(PetscSectionGetConstraintDof(section, padj, &ncdof));
    270:       for (d = off; d < off + dof; ++d) PetscCall(PetscSectionAddDof(rootSectionAdj, d, ndof - ncdof));
    271:     }
    272:     PetscCall(PetscSectionGetDof(anchorSectionAdj, p, &anDof));
    273:     if (anDof) {
    274:       for (d = off; d < off + dof; ++d) PetscCall(PetscSectionAddDof(rootSectionAdj, d, anDof));
    275:     }
    276:   }
    277:   PetscCall(PetscSectionSetUp(rootSectionAdj));
    278:   if (debug) {
    279:     PetscCall(PetscPrintf(comm, "Adjacency Section for Preallocation on Roots after local additions:\n"));
    280:     PetscCall(PetscSectionView(rootSectionAdj, NULL));
    281:   }
    282:   /* Create adj SF based on dof SF */
    283:   PetscCall(PetscSFCreateRemoteOffsets(sfDof, rootSectionAdj, leafSectionAdj, &remoteOffsets));
    284:   PetscCall(PetscSFCreateSectionSF(sfDof, rootSectionAdj, remoteOffsets, leafSectionAdj, &sfAdj));
    285:   PetscCall(PetscFree(remoteOffsets));
    286:   if (debug && size > 1) {
    287:     PetscCall(PetscPrintf(comm, "Adjacency SF for Preallocation:\n"));
    288:     PetscCall(PetscSFView(sfAdj, NULL));
    289:   }
    290:   /* Create leaf adjacency */
    291:   PetscCall(PetscSectionSetUp(leafSectionAdj));
    292:   PetscCall(PetscSectionGetStorageSize(leafSectionAdj, &adjSize));
    293:   PetscCall(PetscCalloc1(adjSize, &adj));
    294:   for (l = 0; l < nleaves; ++l) {
    295:     PetscInt dof, off, d, q, anDof, anOff;
    296:     PetscInt p = leaves[l], numAdj = PETSC_DETERMINE;

    298:     if ((p < pStart) || (p >= pEnd)) continue;
    299:     PetscCall(PetscSectionGetDof(section, p, &dof));
    300:     PetscCall(PetscSectionGetOffset(section, p, &off));
    301:     PetscCall(DMPlexGetAdjacency_Internal(dm, p, useCone, useClosure, useAnchors, &numAdj, &tmpAdj));
    302:     PetscCall(PetscSectionGetDof(anchorSectionAdj, p, &anDof));
    303:     PetscCall(PetscSectionGetOffset(anchorSectionAdj, p, &anOff));
    304:     for (d = off; d < off + dof; ++d) {
    305:       PetscInt aoff, i = 0;

    307:       PetscCall(PetscSectionGetOffset(leafSectionAdj, d, &aoff));
    308:       for (q = 0; q < numAdj; ++q) {
    309:         const PetscInt padj = tmpAdj[q];
    310:         PetscInt       ndof, ncdof, ngoff, nd;

    312:         if ((padj < pStart) || (padj >= pEnd)) continue;
    313:         PetscCall(PetscSectionGetDof(section, padj, &ndof));
    314:         PetscCall(PetscSectionGetConstraintDof(section, padj, &ncdof));
    315:         PetscCall(PetscSectionGetOffset(sectionGlobal, padj, &ngoff));
    316:         for (nd = 0; nd < ndof - ncdof; ++nd) {
    317:           adj[aoff + i] = (ngoff < 0 ? -(ngoff + 1) : ngoff) + nd;
    318:           ++i;
    319:         }
    320:       }
    321:       for (q = 0; q < anDof; q++) {
    322:         adj[aoff + i] = anchorAdj[anOff + q];
    323:         ++i;
    324:       }
    325:     }
    326:   }
    327:   /* Debugging */
    328:   if (debug) {
    329:     IS tmp;
    330:     PetscCall(PetscPrintf(comm, "Leaf adjacency indices\n"));
    331:     PetscCall(ISCreateGeneral(comm, adjSize, adj, PETSC_USE_POINTER, &tmp));
    332:     PetscCall(ISView(tmp, NULL));
    333:     PetscCall(ISDestroy(&tmp));
    334:   }
    335:   /* Gather adjacent indices to root */
    336:   PetscCall(PetscSectionGetStorageSize(rootSectionAdj, &adjSize));
    337:   PetscCall(PetscMalloc1(adjSize, &rootAdj));
    338:   for (r = 0; r < adjSize; ++r) rootAdj[r] = -1;
    339:   if (doComm) {
    340:     const PetscInt *indegree;
    341:     PetscInt       *remoteadj, radjsize = 0;

    343:     PetscCall(PetscSFComputeDegreeBegin(sfAdj, &indegree));
    344:     PetscCall(PetscSFComputeDegreeEnd(sfAdj, &indegree));
    345:     for (p = 0; p < adjSize; ++p) radjsize += indegree[p];
    346:     PetscCall(PetscMalloc1(radjsize, &remoteadj));
    347:     PetscCall(PetscSFGatherBegin(sfAdj, MPIU_INT, adj, remoteadj));
    348:     PetscCall(PetscSFGatherEnd(sfAdj, MPIU_INT, adj, remoteadj));
    349:     for (p = 0, l = 0, r = 0; p < adjSize; ++p, l = PetscMax(p, l + indegree[p - 1])) {
    350:       PetscInt s;
    351:       for (s = 0; s < indegree[p]; ++s, ++r) rootAdj[l + s] = remoteadj[r];
    352:     }
    353:     PetscCheck(r == radjsize, PETSC_COMM_SELF, PETSC_ERR_PLIB, "Inconsistency in communication %" PetscInt_FMT " != %" PetscInt_FMT, r, radjsize);
    354:     PetscCheck(l == adjSize, PETSC_COMM_SELF, PETSC_ERR_PLIB, "Inconsistency in communication %" PetscInt_FMT " != %" PetscInt_FMT, l, adjSize);
    355:     PetscCall(PetscFree(remoteadj));
    356:   }
    357:   PetscCall(PetscSFDestroy(&sfAdj));
    358:   PetscCall(PetscFree(adj));
    359:   /* Debugging */
    360:   if (debug) {
    361:     IS tmp;
    362:     PetscCall(PetscPrintf(comm, "Root adjacency indices after gather\n"));
    363:     PetscCall(ISCreateGeneral(comm, adjSize, rootAdj, PETSC_USE_POINTER, &tmp));
    364:     PetscCall(ISView(tmp, NULL));
    365:     PetscCall(ISDestroy(&tmp));
    366:   }
    367:   /* Add in local adjacency indices for owned dofs on interface (roots) */
    368:   for (p = pStart; p < pEnd; ++p) {
    369:     PetscInt numAdj = PETSC_DETERMINE, adof, dof, off, d, q, anDof, anOff;

    371:     PetscCall(PetscSectionGetDof(section, p, &dof));
    372:     PetscCall(PetscSectionGetOffset(section, p, &off));
    373:     if (!dof) continue;
    374:     PetscCall(PetscSectionGetDof(rootSectionAdj, off, &adof));
    375:     if (adof <= 0) continue;
    376:     PetscCall(DMPlexGetAdjacency_Internal(dm, p, useCone, useClosure, useAnchors, &numAdj, &tmpAdj));
    377:     PetscCall(PetscSectionGetDof(anchorSectionAdj, p, &anDof));
    378:     PetscCall(PetscSectionGetOffset(anchorSectionAdj, p, &anOff));
    379:     for (d = off; d < off + dof; ++d) {
    380:       PetscInt adof, aoff, i;

    382:       PetscCall(PetscSectionGetDof(rootSectionAdj, d, &adof));
    383:       PetscCall(PetscSectionGetOffset(rootSectionAdj, d, &aoff));
    384:       i = adof - 1;
    385:       for (q = 0; q < anDof; q++) {
    386:         rootAdj[aoff + i] = anchorAdj[anOff + q];
    387:         --i;
    388:       }
    389:       for (q = 0; q < numAdj; ++q) {
    390:         const PetscInt padj = tmpAdj[q];
    391:         PetscInt       ndof, ncdof, ngoff, nd;

    393:         if ((padj < pStart) || (padj >= pEnd)) continue;
    394:         PetscCall(PetscSectionGetDof(section, padj, &ndof));
    395:         PetscCall(PetscSectionGetConstraintDof(section, padj, &ncdof));
    396:         PetscCall(PetscSectionGetOffset(sectionGlobal, padj, &ngoff));
    397:         for (nd = 0; nd < ndof - ncdof; ++nd) {
    398:           rootAdj[aoff + i] = ngoff < 0 ? -(ngoff + 1) + nd : ngoff + nd;
    399:           --i;
    400:         }
    401:       }
    402:     }
    403:   }
    404:   /* Debugging */
    405:   if (debug) {
    406:     IS tmp;
    407:     PetscCall(PetscPrintf(comm, "Root adjacency indices\n"));
    408:     PetscCall(ISCreateGeneral(comm, adjSize, rootAdj, PETSC_USE_POINTER, &tmp));
    409:     PetscCall(ISView(tmp, NULL));
    410:     PetscCall(ISDestroy(&tmp));
    411:   }
    412:   /* Compress indices */
    413:   PetscCall(PetscSectionSetUp(rootSectionAdj));
    414:   for (p = pStart; p < pEnd; ++p) {
    415:     PetscInt dof, cdof, off, d;
    416:     PetscInt adof, aoff;

    418:     PetscCall(PetscSectionGetDof(section, p, &dof));
    419:     PetscCall(PetscSectionGetConstraintDof(section, p, &cdof));
    420:     PetscCall(PetscSectionGetOffset(section, p, &off));
    421:     if (!dof) continue;
    422:     PetscCall(PetscSectionGetDof(rootSectionAdj, off, &adof));
    423:     if (adof <= 0) continue;
    424:     for (d = off; d < off + dof - cdof; ++d) {
    425:       PetscCall(PetscSectionGetDof(rootSectionAdj, d, &adof));
    426:       PetscCall(PetscSectionGetOffset(rootSectionAdj, d, &aoff));
    427:       PetscCall(PetscSortRemoveDupsInt(&adof, &rootAdj[aoff]));
    428:       PetscCall(PetscSectionSetDof(rootSectionAdj, d, adof));
    429:     }
    430:   }
    431:   /* Debugging */
    432:   if (debug) {
    433:     IS tmp;
    434:     PetscCall(PetscPrintf(comm, "Adjacency Section for Preallocation on Roots after compression:\n"));
    435:     PetscCall(PetscSectionView(rootSectionAdj, NULL));
    436:     PetscCall(PetscPrintf(comm, "Root adjacency indices after compression\n"));
    437:     PetscCall(ISCreateGeneral(comm, adjSize, rootAdj, PETSC_USE_POINTER, &tmp));
    438:     PetscCall(ISView(tmp, NULL));
    439:     PetscCall(ISDestroy(&tmp));
    440:   }
    441:   /* Build adjacency section: Maps global indices to sets of adjacent global indices */
    442:   PetscCall(PetscSectionGetOffsetRange(sectionGlobal, &globalOffStart, &globalOffEnd));
    443:   PetscCall(PetscSectionCreate(comm, &sectionAdj));
    444:   PetscCall(PetscSectionSetChart(sectionAdj, globalOffStart, globalOffEnd));
    445:   for (p = pStart; p < pEnd; ++p) {
    446:     PetscInt  numAdj = PETSC_DETERMINE, dof, cdof, off, goff, d, q, anDof;
    447:     PetscBool found  = PETSC_TRUE;

    449:     PetscCall(PetscSectionGetDof(section, p, &dof));
    450:     PetscCall(PetscSectionGetConstraintDof(section, p, &cdof));
    451:     PetscCall(PetscSectionGetOffset(section, p, &off));
    452:     PetscCall(PetscSectionGetOffset(sectionGlobal, p, &goff));
    453:     for (d = 0; d < dof - cdof; ++d) {
    454:       PetscInt ldof, rdof;

    456:       PetscCall(PetscSectionGetDof(leafSectionAdj, off + d, &ldof));
    457:       PetscCall(PetscSectionGetDof(rootSectionAdj, off + d, &rdof));
    458:       if (ldof > 0) {
    459:         /* We do not own this point */
    460:       } else if (rdof > 0) {
    461:         PetscCall(PetscSectionSetDof(sectionAdj, goff + d, rdof));
    462:       } else {
    463:         found = PETSC_FALSE;
    464:       }
    465:     }
    466:     if (found) continue;
    467:     PetscCall(PetscSectionGetDof(section, p, &dof));
    468:     PetscCall(PetscSectionGetOffset(sectionGlobal, p, &goff));
    469:     PetscCall(DMPlexGetAdjacency_Internal(dm, p, useCone, useClosure, useAnchors, &numAdj, &tmpAdj));
    470:     for (q = 0; q < numAdj; ++q) {
    471:       const PetscInt padj = tmpAdj[q];
    472:       PetscInt       ndof, ncdof, noff;

    474:       if ((padj < pStart) || (padj >= pEnd)) continue;
    475:       PetscCall(PetscSectionGetDof(section, padj, &ndof));
    476:       PetscCall(PetscSectionGetConstraintDof(section, padj, &ncdof));
    477:       PetscCall(PetscSectionGetOffset(section, padj, &noff));
    478:       for (d = goff; d < goff + dof - cdof; ++d) PetscCall(PetscSectionAddDof(sectionAdj, d, ndof - ncdof));
    479:     }
    480:     PetscCall(PetscSectionGetDof(anchorSectionAdj, p, &anDof));
    481:     if (anDof) {
    482:       for (d = goff; d < goff + dof - cdof; ++d) PetscCall(PetscSectionAddDof(sectionAdj, d, anDof));
    483:     }
    484:   }
    485:   PetscCall(PetscSectionSetUp(sectionAdj));
    486:   if (debug) {
    487:     PetscCall(PetscPrintf(comm, "Adjacency Section for Preallocation:\n"));
    488:     PetscCall(PetscSectionView(sectionAdj, NULL));
    489:   }
    490:   /* Get adjacent indices */
    491:   PetscCall(PetscSectionGetStorageSize(sectionAdj, &numCols));
    492:   PetscCall(PetscMalloc1(numCols, &cols));
    493:   for (p = pStart; p < pEnd; ++p) {
    494:     PetscInt  numAdj = PETSC_DETERMINE, dof, cdof, off, goff, d, q, anDof, anOff;
    495:     PetscBool found  = PETSC_TRUE;

    497:     PetscCall(PetscSectionGetDof(section, p, &dof));
    498:     PetscCall(PetscSectionGetConstraintDof(section, p, &cdof));
    499:     PetscCall(PetscSectionGetOffset(section, p, &off));
    500:     PetscCall(PetscSectionGetOffset(sectionGlobal, p, &goff));
    501:     for (d = 0; d < dof - cdof; ++d) {
    502:       PetscInt ldof, rdof;

    504:       PetscCall(PetscSectionGetDof(leafSectionAdj, off + d, &ldof));
    505:       PetscCall(PetscSectionGetDof(rootSectionAdj, off + d, &rdof));
    506:       if (ldof > 0) {
    507:         /* We do not own this point */
    508:       } else if (rdof > 0) {
    509:         PetscInt aoff, roff;

    511:         PetscCall(PetscSectionGetOffset(sectionAdj, goff + d, &aoff));
    512:         PetscCall(PetscSectionGetOffset(rootSectionAdj, off + d, &roff));
    513:         PetscCall(PetscArraycpy(&cols[aoff], &rootAdj[roff], rdof));
    514:       } else {
    515:         found = PETSC_FALSE;
    516:       }
    517:     }
    518:     if (found) continue;
    519:     PetscCall(DMPlexGetAdjacency_Internal(dm, p, useCone, useClosure, useAnchors, &numAdj, &tmpAdj));
    520:     PetscCall(PetscSectionGetDof(anchorSectionAdj, p, &anDof));
    521:     PetscCall(PetscSectionGetOffset(anchorSectionAdj, p, &anOff));
    522:     for (d = goff; d < goff + dof - cdof; ++d) {
    523:       PetscInt adof, aoff, i = 0;

    525:       PetscCall(PetscSectionGetDof(sectionAdj, d, &adof));
    526:       PetscCall(PetscSectionGetOffset(sectionAdj, d, &aoff));
    527:       for (q = 0; q < numAdj; ++q) {
    528:         const PetscInt  padj = tmpAdj[q];
    529:         PetscInt        ndof, ncdof, ngoff, nd;
    530:         const PetscInt *ncind;

    532:         /* Adjacent points may not be in the section chart */
    533:         if ((padj < pStart) || (padj >= pEnd)) continue;
    534:         PetscCall(PetscSectionGetDof(section, padj, &ndof));
    535:         PetscCall(PetscSectionGetConstraintDof(section, padj, &ncdof));
    536:         PetscCall(PetscSectionGetConstraintIndices(section, padj, &ncind));
    537:         PetscCall(PetscSectionGetOffset(sectionGlobal, padj, &ngoff));
    538:         for (nd = 0; nd < ndof - ncdof; ++nd, ++i) cols[aoff + i] = ngoff < 0 ? -(ngoff + 1) + nd : ngoff + nd;
    539:       }
    540:       for (q = 0; q < anDof; q++, i++) cols[aoff + i] = anchorAdj[anOff + q];
    541:       PetscCheck(i == adof, PETSC_COMM_SELF, PETSC_ERR_PLIB, "Invalid number of entries %" PetscInt_FMT " != %" PetscInt_FMT " for dof %" PetscInt_FMT " (point %" PetscInt_FMT ")", i, adof, d, p);
    542:     }
    543:   }
    544:   PetscCall(PetscSectionDestroy(&anchorSectionAdj));
    545:   PetscCall(PetscSectionDestroy(&leafSectionAdj));
    546:   PetscCall(PetscSectionDestroy(&rootSectionAdj));
    547:   PetscCall(PetscFree(anchorAdj));
    548:   PetscCall(PetscFree(rootAdj));
    549:   PetscCall(PetscFree(tmpAdj));
    550:   /* Debugging */
    551:   if (debug) {
    552:     IS tmp;
    553:     PetscCall(PetscPrintf(comm, "Column indices\n"));
    554:     PetscCall(ISCreateGeneral(comm, numCols, cols, PETSC_USE_POINTER, &tmp));
    555:     PetscCall(ISView(tmp, NULL));
    556:     PetscCall(ISDestroy(&tmp));
    557:   }

    559:   *sA     = sectionAdj;
    560:   *colIdx = cols;
    561:   PetscFunctionReturn(PETSC_SUCCESS);
    562: }

    564: static PetscErrorCode DMPlexUpdateAllocation_Static(DM dm, PetscLayout rLayout, PetscInt bs, PetscInt f, PetscSection sectionAdj, const PetscInt cols[], PetscInt dnz[], PetscInt onz[], PetscInt dnzu[], PetscInt onzu[])
    565: {
    566:   PetscSection section;
    567:   PetscInt     rStart, rEnd, r, pStart, pEnd, p;

    569:   PetscFunctionBegin;
    570:   /* This loop needs to change to a loop over points, then field dofs, which means we need to look both sections */
    571:   PetscCall(PetscLayoutGetRange(rLayout, &rStart, &rEnd));
    572:   PetscCheck((rStart % bs) == 0 && (rEnd % bs) == 0, PetscObjectComm((PetscObject)rLayout), PETSC_ERR_ARG_WRONG, "Invalid layout [%" PetscInt_FMT ", %" PetscInt_FMT ") for matrix, must be divisible by block size %" PetscInt_FMT, rStart, rEnd, bs);
    573:   if (f >= 0 && bs == 1) {
    574:     PetscCall(DMGetLocalSection(dm, &section));
    575:     PetscCall(PetscSectionGetChart(section, &pStart, &pEnd));
    576:     for (p = pStart; p < pEnd; ++p) {
    577:       PetscInt rS, rE;

    579:       PetscCall(DMGetGlobalFieldOffset_Private(dm, p, f, &rS, &rE));
    580:       for (r = rS; r < rE; ++r) {
    581:         PetscInt numCols, cStart, c;

    583:         PetscCall(PetscSectionGetDof(sectionAdj, r, &numCols));
    584:         PetscCall(PetscSectionGetOffset(sectionAdj, r, &cStart));
    585:         for (c = cStart; c < cStart + numCols; ++c) {
    586:           if ((cols[c] >= rStart) && (cols[c] < rEnd)) {
    587:             ++dnz[r - rStart];
    588:             if (cols[c] >= r) ++dnzu[r - rStart];
    589:           } else {
    590:             ++onz[r - rStart];
    591:             if (cols[c] >= r) ++onzu[r - rStart];
    592:           }
    593:         }
    594:       }
    595:     }
    596:   } else {
    597:     /* Only loop over blocks of rows */
    598:     for (r = rStart / bs; r < rEnd / bs; ++r) {
    599:       const PetscInt row = r * bs;
    600:       PetscInt       numCols, cStart, c;

    602:       PetscCall(PetscSectionGetDof(sectionAdj, row, &numCols));
    603:       PetscCall(PetscSectionGetOffset(sectionAdj, row, &cStart));
    604:       for (c = cStart; c < cStart + numCols; ++c) {
    605:         if ((cols[c] >= rStart) && (cols[c] < rEnd)) {
    606:           ++dnz[r - rStart / bs];
    607:           if (cols[c] >= row) ++dnzu[r - rStart / bs];
    608:         } else {
    609:           ++onz[r - rStart / bs];
    610:           if (cols[c] >= row) ++onzu[r - rStart / bs];
    611:         }
    612:       }
    613:     }
    614:     for (r = 0; r < (rEnd - rStart) / bs; ++r) {
    615:       dnz[r] /= bs;
    616:       onz[r] /= bs;
    617:       dnzu[r] /= bs;
    618:       onzu[r] /= bs;
    619:     }
    620:   }
    621:   PetscFunctionReturn(PETSC_SUCCESS);
    622: }

    624: static PetscErrorCode DMPlexFillMatrix_Static(DM dm, PetscLayout rLayout, PetscInt bs, PetscInt f, PetscSection sectionAdj, const PetscInt cols[], Mat A)
    625: {
    626:   PetscSection section;
    627:   PetscScalar *values;
    628:   PetscInt     rStart, rEnd, r, pStart, pEnd, p, len, maxRowLen = 0;

    630:   PetscFunctionBegin;
    631:   PetscCall(PetscLayoutGetRange(rLayout, &rStart, &rEnd));
    632:   for (r = rStart; r < rEnd; ++r) {
    633:     PetscCall(PetscSectionGetDof(sectionAdj, r, &len));
    634:     maxRowLen = PetscMax(maxRowLen, len);
    635:   }
    636:   PetscCall(PetscCalloc1(maxRowLen, &values));
    637:   if (f >= 0 && bs == 1) {
    638:     PetscCall(DMGetLocalSection(dm, &section));
    639:     PetscCall(PetscSectionGetChart(section, &pStart, &pEnd));
    640:     for (p = pStart; p < pEnd; ++p) {
    641:       PetscInt rS, rE;

    643:       PetscCall(DMGetGlobalFieldOffset_Private(dm, p, f, &rS, &rE));
    644:       for (r = rS; r < rE; ++r) {
    645:         PetscInt numCols, cStart;

    647:         PetscCall(PetscSectionGetDof(sectionAdj, r, &numCols));
    648:         PetscCall(PetscSectionGetOffset(sectionAdj, r, &cStart));
    649:         PetscCall(MatSetValues(A, 1, &r, numCols, &cols[cStart], values, INSERT_VALUES));
    650:       }
    651:     }
    652:   } else {
    653:     for (r = rStart; r < rEnd; ++r) {
    654:       PetscInt numCols, cStart;

    656:       PetscCall(PetscSectionGetDof(sectionAdj, r, &numCols));
    657:       PetscCall(PetscSectionGetOffset(sectionAdj, r, &cStart));
    658:       PetscCall(MatSetValues(A, 1, &r, numCols, &cols[cStart], values, INSERT_VALUES));
    659:     }
    660:   }
    661:   PetscCall(PetscFree(values));
    662:   PetscFunctionReturn(PETSC_SUCCESS);
    663: }

    665: /*@
    666:   DMPlexPreallocateOperator - Calculate the matrix nonzero pattern based upon the information in the `DM`,
    667:   the `PetscDS` it contains, and the default `PetscSection`.

    669:   Collective

    671:   Input Parameters:
    672: + dm         - The `DMPLEX`
    673: . bs         - The matrix blocksize
    674: . dnz        - An array to hold the number of nonzeros in the diagonal block
    675: . onz        - An array to hold the number of nonzeros in the off-diagonal block
    676: . dnzu       - An array to hold the number of nonzeros in the upper triangle of the diagonal block
    677: . onzu       - An array to hold the number of nonzeros in the upper triangle of the off-diagonal block
    678: - fillMatrix - If `PETSC_TRUE`, fill the matrix with zeros

    680:   Output Parameter:
    681: . A - The preallocated matrix

    683:   Level: advanced

    685: .seealso: [](ch_unstructured), `DM`, `DMPLEX`, `DMCreateMatrix()`
    686: @*/
    687: PetscErrorCode DMPlexPreallocateOperator(DM dm, PetscInt bs, PetscInt dnz[], PetscInt onz[], PetscInt dnzu[], PetscInt onzu[], Mat A, PetscBool fillMatrix)
    688: {
    689:   MPI_Comm     comm;
    690:   MatType      mtype;
    691:   PetscSF      sf, sfDof;
    692:   PetscSection section;
    693:   PetscInt    *remoteOffsets;
    694:   PetscSection sectionAdj[4] = {NULL, NULL, NULL, NULL};
    695:   PetscInt    *cols[4]       = {NULL, NULL, NULL, NULL};
    696:   PetscBool    useCone, useClosure;
    697:   PetscInt     Nf, f, idx, locRows;
    698:   PetscLayout  rLayout;
    699:   PetscBool    isSymBlock, isSymSeqBlock, isSymMPIBlock, debug = PETSC_FALSE;
    700:   PetscMPIInt  size;

    702:   PetscFunctionBegin;
    705:   if (dnz) PetscAssertPointer(dnz, 3);
    706:   if (onz) PetscAssertPointer(onz, 4);
    707:   if (dnzu) PetscAssertPointer(dnzu, 5);
    708:   if (onzu) PetscAssertPointer(onzu, 6);
    709:   PetscCall(DMGetPointSF(dm, &sf));
    710:   PetscCall(DMGetLocalSection(dm, &section));
    711:   PetscCall(PetscOptionsGetBool(NULL, NULL, "-dm_view_preallocation", &debug, NULL));
    712:   PetscCall(PetscObjectGetComm((PetscObject)dm, &comm));
    713:   PetscCallMPI(MPI_Comm_size(comm, &size));
    714:   PetscCall(PetscLogEventBegin(DMPLEX_Preallocate, dm, 0, 0, 0));
    715:   /* Create dof SF based on point SF */
    716:   if (debug) {
    717:     PetscSection section, sectionGlobal;
    718:     PetscSF      sf;

    720:     PetscCall(DMGetPointSF(dm, &sf));
    721:     PetscCall(DMGetLocalSection(dm, &section));
    722:     PetscCall(DMGetGlobalSection(dm, &sectionGlobal));
    723:     PetscCall(PetscPrintf(comm, "Input Section for Preallocation:\n"));
    724:     PetscCall(PetscSectionView(section, NULL));
    725:     PetscCall(PetscPrintf(comm, "Input Global Section for Preallocation:\n"));
    726:     PetscCall(PetscSectionView(sectionGlobal, NULL));
    727:     if (size > 1) {
    728:       PetscCall(PetscPrintf(comm, "Input SF for Preallocation:\n"));
    729:       PetscCall(PetscSFView(sf, NULL));
    730:     }
    731:   }
    732:   PetscCall(PetscSFCreateRemoteOffsets(sf, section, section, &remoteOffsets));
    733:   PetscCall(PetscSFCreateSectionSF(sf, section, remoteOffsets, section, &sfDof));
    734:   PetscCall(PetscFree(remoteOffsets));
    735:   if (debug && size > 1) {
    736:     PetscCall(PetscPrintf(comm, "Dof SF for Preallocation:\n"));
    737:     PetscCall(PetscSFView(sfDof, NULL));
    738:   }
    739:   /* Create allocation vectors from adjacency graph */
    740:   PetscCall(MatGetLocalSize(A, &locRows, NULL));
    741:   PetscCall(PetscLayoutCreate(comm, &rLayout));
    742:   PetscCall(PetscLayoutSetLocalSize(rLayout, locRows));
    743:   PetscCall(PetscLayoutSetBlockSize(rLayout, 1));
    744:   PetscCall(PetscLayoutSetUp(rLayout));
    745:   /* There are 4 types of adjacency */
    746:   PetscCall(PetscSectionGetNumFields(section, &Nf));
    747:   if (Nf < 1 || bs > 1) {
    748:     PetscCall(DMGetBasicAdjacency(dm, &useCone, &useClosure));
    749:     idx = (useCone ? 1 : 0) + (useClosure ? 2 : 0);
    750:     PetscCall(DMPlexCreateAdjacencySection_Static(dm, bs, sfDof, useCone, useClosure, PETSC_TRUE, &sectionAdj[idx], &cols[idx]));
    751:     PetscCall(DMPlexUpdateAllocation_Static(dm, rLayout, bs, -1, sectionAdj[idx], cols[idx], dnz, onz, dnzu, onzu));
    752:   } else {
    753:     for (f = 0; f < Nf; ++f) {
    754:       PetscCall(DMGetAdjacency(dm, f, &useCone, &useClosure));
    755:       idx = (useCone ? 1 : 0) + (useClosure ? 2 : 0);
    756:       if (!sectionAdj[idx]) PetscCall(DMPlexCreateAdjacencySection_Static(dm, bs, sfDof, useCone, useClosure, PETSC_TRUE, &sectionAdj[idx], &cols[idx]));
    757:       PetscCall(DMPlexUpdateAllocation_Static(dm, rLayout, bs, f, sectionAdj[idx], cols[idx], dnz, onz, dnzu, onzu));
    758:     }
    759:   }
    760:   PetscCall(PetscSFDestroy(&sfDof));
    761:   /* Set matrix pattern */
    762:   PetscCall(MatXAIJSetPreallocation(A, bs, dnz, onz, dnzu, onzu));
    763:   PetscCall(MatSetOption(A, MAT_NEW_NONZERO_ALLOCATION_ERR, PETSC_TRUE));
    764:   /* Check for symmetric storage */
    765:   PetscCall(MatGetType(A, &mtype));
    766:   PetscCall(PetscStrcmp(mtype, MATSBAIJ, &isSymBlock));
    767:   PetscCall(PetscStrcmp(mtype, MATSEQSBAIJ, &isSymSeqBlock));
    768:   PetscCall(PetscStrcmp(mtype, MATMPISBAIJ, &isSymMPIBlock));
    769:   if (isSymBlock || isSymSeqBlock || isSymMPIBlock) PetscCall(MatSetOption(A, MAT_IGNORE_LOWER_TRIANGULAR, PETSC_TRUE));
    770:   /* Fill matrix with zeros */
    771:   if (fillMatrix) {
    772:     if (Nf < 1 || bs > 1) {
    773:       PetscCall(DMGetBasicAdjacency(dm, &useCone, &useClosure));
    774:       idx = (useCone ? 1 : 0) + (useClosure ? 2 : 0);
    775:       PetscCall(DMPlexFillMatrix_Static(dm, rLayout, bs, -1, sectionAdj[idx], cols[idx], A));
    776:     } else {
    777:       for (f = 0; f < Nf; ++f) {
    778:         PetscCall(DMGetAdjacency(dm, f, &useCone, &useClosure));
    779:         idx = (useCone ? 1 : 0) + (useClosure ? 2 : 0);
    780:         PetscCall(DMPlexFillMatrix_Static(dm, rLayout, bs, f, sectionAdj[idx], cols[idx], A));
    781:       }
    782:     }
    783:     PetscCall(MatAssemblyBegin(A, MAT_FINAL_ASSEMBLY));
    784:     PetscCall(MatAssemblyEnd(A, MAT_FINAL_ASSEMBLY));
    785:   }
    786:   PetscCall(PetscLayoutDestroy(&rLayout));
    787:   for (idx = 0; idx < 4; ++idx) {
    788:     PetscCall(PetscSectionDestroy(&sectionAdj[idx]));
    789:     PetscCall(PetscFree(cols[idx]));
    790:   }
    791:   PetscCall(PetscLogEventEnd(DMPLEX_Preallocate, dm, 0, 0, 0));
    792:   PetscFunctionReturn(PETSC_SUCCESS);
    793: }

    795: #if 0
    796: PetscErrorCode DMPlexPreallocateOperator_2(DM dm, PetscInt bs, PetscSection section, PetscSection sectionGlobal, PetscInt dnz[], PetscInt onz[], PetscInt dnzu[], PetscInt onzu[], Mat A, PetscBool fillMatrix)
    797: {
    798:   PetscInt       *tmpClosure,*tmpAdj,*visits;
    799:   PetscInt        c,cStart,cEnd,pStart,pEnd;

    801:   PetscFunctionBegin;
    802:   PetscCall(DMGetDimension(dm, &dim));
    803:   PetscCall(DMPlexGetDepth(dm, &depth));
    804:   PetscCall(DMPlexGetMaxSizes(dm, &maxConeSize, &maxSupportSize));

    806:   maxClosureSize = 2*PetscMax(PetscPowInt(mesh->maxConeSize,depth+1),PetscPowInt(mesh->maxSupportSize,depth+1));

    808:   PetscCall(PetscSectionGetChart(section, &pStart, &pEnd));
    809:   npoints = pEnd - pStart;

    811:   PetscCall(PetscMalloc3(maxClosureSize,&tmpClosure,npoints,&lvisits,npoints,&visits));
    812:   PetscCall(PetscArrayzero(lvisits,pEnd-pStart));
    813:   PetscCall(PetscArrayzero(visits,pEnd-pStart));
    814:   PetscCall(DMPlexGetHeightStratum(dm, 0, &cStart, &cEnd));
    815:   for (c=cStart; c<cEnd; c++) {
    816:     PetscInt *support = tmpClosure;
    817:     PetscCall(DMPlexGetTransitiveClosure(dm, c, PETSC_FALSE, &supportSize, (PetscInt**)&support));
    818:     for (p=0; p<supportSize; p++) lvisits[support[p]]++;
    819:   }
    820:   PetscCall(PetscSFReduceBegin(sf,MPIU_INT,lvisits,visits,MPI_SUM));
    821:   PetscCall(PetscSFReduceEnd  (sf,MPIU_INT,lvisits,visits,MPI_SUM));
    822:   PetscCall(PetscSFBcastBegin(sf,MPIU_INT,visits,lvisits,MPI_REPLACE));
    823:   PetscCall(PetscSFBcastEnd  (sf,MPIU_INT,visits,lvisits));

    825:   PetscCall(PetscSFGetRootRanks());

    827:   PetscCall(PetscMalloc2(maxClosureSize*maxClosureSize,&cellmat,npoints,&owner));
    828:   for (c=cStart; c<cEnd; c++) {
    829:     PetscCall(PetscArrayzero(cellmat,maxClosureSize*maxClosureSize));
    830:     /*
    831:      Depth-first walk of transitive closure.
    832:      At each leaf frame f of transitive closure that we see, add 1/visits[f] to each pair (p,q) not marked as done in cellmat.
    833:      This contribution is added to dnz if owning ranks of p and q match, to onz otherwise.
    834:      */
    835:   }

    837:   PetscCall(PetscSFReduceBegin(sf,MPIU_INT,ldnz,dnz,MPI_SUM));
    838:   PetscCall(PetscSFReduceEnd  (sf,MPIU_INT,lonz,onz,MPI_SUM));
    839:   PetscFunctionReturn(PETSC_SUCCESS);
    840: }
    841: #endif