Actual source code: partQuery.c

  1: #ifdef PETSC_RCS_HEADER
  2: static char vcid[] = "$Id: partQuery.c,v 1.6 2000/01/31 17:37:32 knepley Exp $";
  3: #endif

  5: /*
  6:      Defines the interface to the partition query functions
  7: */

 9:  #include src/mesh/meshimpl.h

 11: /*-------------------------------------------- Partition Query Functions ---------------------------------------------*/
 12: /*@
 13:   PartitionGetDimension - This function returns the dimension of the Partition.

 15:   Not collective

 17:   Input Parameter:
 18: . part - The partition

 20:   Output Parameter:
 21: . dim  - The partition dimension

 23:   Level: intermediate

 25: .keywords: Partition, dimension
 26: .seealso: MeshGetDimension()
 27: @*/
 28: int PartitionGetDimension(Partition part, int *dim)
 29: {
 30:   Mesh mesh;

 36:   PartitionGetMesh(part, &mesh);
 37:   MeshGetDimension(mesh, dim);
 38:   return(0);
 39: }

 41: /*@
 42:   PartitionGetMesh - Returns the Mesh object for this Partition.

 44:   Not collective

 46:   Input Parameter:
 47: . part - The partition

 49:   Output Parameter:
 50: . mesh - The mesh

 52:   Level: intermediate

 54: .keywords: Mesh, Partition, get
 55: .seealso: MeshGetPartition()
 56: @*/
 57: int PartitionGetMesh(Partition part, Mesh *mesh)
 58: {
 62:   *mesh = part->mesh;
 63:   return(0);
 64: }

 66: /*--------------------------------------------- Element Query Functions ----------------------------------------------*/
 67: /*@
 68:   PartitionGetTotalElements - Gets the number of elements in the mesh.

 70:   Not collective

 72:   Input Parameter:
 73: . part - The partition

 75:   Output Parameter:
 76: . size - The number of elements in the mesh

 78:   Level: intermediate

 80: .keywords: partition, element
 81: .seealso: PartitionGetStartElement(), PartitionGetEndElement()
 82: @*/
 83: int PartitionGetTotalElements(Partition part, int *size)
 84: {
 88:   *size = part->numElements;
 89:   return(0);
 90: }

 92: /*@
 93:   PartitionGetStartElement - Gets the first element in this domain.

 95:   Not collective

 97:   Input Parameter:
 98: . part - The partition

100:   Output Parameter:
101: . elem - The first element in this domain

103:   Level: intermediate

105: .keywords: partition, element
106: .seealso: PartitionGetEndElement(), PartitionGetNumElements()
107: @*/
108: int PartitionGetStartElement(Partition part, int *elem)
109: {
113:   *elem = part->firstElement[part->rank];
114:   return(0);
115: }

117: /*@
118:   PartitionGetEndElement - Gets the first element in the next domain.

120:   Not collective

122:   Input Parameter:
123: . part - The partition

125:   Output Parameter:
126: . elem - The first element in the next domain

128:   Level: intermediate

130: .keywords: partition, element
131: .seealso: PartitionGetStartElement(), PartitionGetNumElements()
132: @*/
133: int PartitionGetEndElement(Partition part, int *elem)
134: {
138:   *elem = part->firstElement[part->rank+1];
139:   return(0);
140: }

142: /*@
143:   PartitionGetNumElements - Gets the number of elements in this domain.

145:   Not collective

147:   Input Parameter:
148: . part - The partition

150:   Output Parameter:
151: . size - The number of elements in this domain

153:   Level: intermediate

155: .keywords: partition, element
156: .seealso: PartitionGetStartElement(), PartitionGetEndElement()
157: @*/
158: int PartitionGetNumElements(Partition part, int *size)
159: {
163:   *size = part->firstElement[part->rank+1] - part->firstElement[part->rank];
164:   return(0);
165: }

167: /*@
168:   PartitionGetNumOverlapElements - Gets the number of elements and ghost elements for this domain.

170:   Not collective

172:   Input Parameter:
173: . part - The partition

175:   Output Parameter:
176: . size - The number of elements and ghost element for this domain

178:   Level: intermediate

180: .keywords: partition, element
181: .seealso: PartitionGetStartElement(), PartitionGetEndElement()
182: @*/
183: int PartitionGetNumOverlapElements(Partition part, int *size)
184: {
188:   *size = part->numOverlapElements;
189:   return(0);
190: }

192: static int PartitionGhostElementIndex_Private(Partition p, int elem, int *gElem)
193: {
194:   int low, high, mid;

197:   /* Use bisection since the array is assumed to be sorted */
198:   low  = 0;
199:   high = p->numOverlapElements - (p->firstElement[p->rank+1] - p->firstElement[p->rank]) - 1;
200:   while (low <= high) {
201:     mid = (low + high)/2;
202:     if (elem == p->ghostElements[mid]) {
203:       *gElem = mid;
204:       return(0);
205:     } else if (elem < p->ghostElements[mid]) {
206:       high = mid - 1;
207:     } else {
208:       low  = mid + 1;
209:     }
210:   }
211:   /* We indicate elements which are not local and also not ghost by -2 */
212:   *gElem = -2;
213:   return(0);
214: }

216: /*@
217:   PartitionGlobalToLocalElementIndex - Returns the local element number
218:   corresponding to the global element number.

220:   Not collective

222:   Input Parameters:
223: + part    - The partition
224: - elem    - The canonical global element number

226:   Output Parameter:
227: . locElem - The local element number

229:   Level: intermediate

231: .keywords: partition, local, global
232: .seealso PartitionLocalToGlobalElementIndex()
233: @*/
234: int PartitionGlobalToLocalElementIndex(Partition part, int elem, int *locElem)
235: {
236:   int numLocElements;
237:   int gElem; /* The local ghost element number */

243:   numLocElements = part->firstElement[part->rank+1] - part->firstElement[part->rank];
244:   if (elem < 0) {
245:     *locElem = elem;
246:     return(0);
247:   }
248:   /* Check for ghost element */
249:   if ((elem < part->firstElement[part->rank]) || (elem >= part->firstElement[part->rank+1])) {
250:     /* Search for canonical number */
251:     PartitionGhostElementIndex_Private(part, elem, &gElem);
252:     if (gElem < 0) {
253:       *locElem = gElem;
254:     } else {
255:       *locElem = numLocElements + gElem;
256:     }
257:   } else {
258:     *locElem = elem - part->firstElement[part->rank];
259:   }
260:   return(0);
261: }

263: /*@
264:   PartitionLocalToGlobalElementIndex - Returns the global element number
265:   corresponding to the local element number.

267:   Not collective

269:   Input Parameters:
270: + part    - The partition
271: - locElem - The canonical local element number

273:   Output Parameter:
274: . elem    - The global element number

276:   Level: intermediate

278: .keywords: partition, local, global
279: .seealso: PartitionGlobalToLocalElementIndex()
280: @*/
281: int PartitionLocalToGlobalElementIndex(Partition part, int locElem, int *elem)
282: {
283:   int numLocElements;

288:   numLocElements = part->firstElement[part->rank+1] - part->firstElement[part->rank];
289:   if (locElem < 0) {
290:     *elem = locElem;
291:     return(0);
292:   } else if (locElem < numLocElements) {
293:     *elem = locElem + part->firstElement[part->rank];
294:   } else if (locElem < part->numOverlapElements) {
295:     *elem = part->ghostElements[locElem - numLocElements];
296:   } else {
297:     SETERRQ(PETSC_ERR_ARG_WRONG, "Invalid local element index (too large)");
298:   }
299:   return(0);
300: }

302: /*@
303:   PartitionGetElementOrdering - This function gets the AO which was used to reorder the mesh elements
304:   during partitioning.

306:   Not collective

308:   Input Parameter:
309: . part  - The partition

311:   Output Parameter:
312: . order - The element ordering, or PETSC_NULL if none exists

314:   Level: intermediate

316: .keywords: Partition, element, ordering, AO
317: .seealso: MeshGetNodeOrdering()
318: @*/
319: int PartitionGetElementOrdering(Partition part, AO *order)
320: {
324:   *order = part->ordering;
325:   return(0);
326: }

328: /*----------------------------------------------- Node Query Functions -----------------------------------------------*/
329: /*@
330:   PartitionGetTotalNodes - Gets the number of nodes in the mesh.

332:   Not collective

334:   Input Parameter:
335: . part - The partition

337:   Output Parameter:
338: . size - The number of nodes in the mesh

340:   Level: intermediate

342: .keywords: partition, node
343: .seealso: PartitionGetStartNode(), PartitionGetEndNode(), PartitionGetTotalElements()
344: @*/
345: int PartitionGetTotalNodes(Partition part, int *size)
346: {

352:   if (part->ops->gettotalnodes == PETSC_NULL) {
353:     SETERRQ(PETSC_ERR_SUP, "Not implemented for this partition type");
354:   }
355:   (*part->ops->gettotalnodes)(part, size);
356:   return(0);
357: }

359: /*@
360:   PartitionGetStartNode - Gets the first node in this domain.

362:   Not collective

364:   Input Parameter:
365: . part - The partition

367:   Output Parameter:
368: . node - The first node in this domain

370:   Level: intermediate

372: .keywords: partition, node
373: .seealso: PartitionGetEndNode(), PartitionGetNumNodes(), PartitionGetStartElement()
374: @*/
375: int PartitionGetStartNode(Partition part, int *node)
376: {

382:   if (part->ops->getstartnode == PETSC_NULL) {
383:     SETERRQ(PETSC_ERR_SUP, "Not implemented for this partition type");
384:   }
385:   (*part->ops->getstartnode)(part, node);
386:   return(0);
387: }

389: /*@
390:   PartitionGetEndNode - Gets the first node in the next domain.

392:   Not collective

394:   Input Parameter:
395: . part - The partition

397:   Output Parameter:
398: . node - The first node in the next domain

400:   Level: intermediate

402: .keywords: partition, node
403: .seealso: PartitionGetStartNode(), PartitionGetNumNodes(), PartitionGetEndElement()
404: @*/
405: int PartitionGetEndNode(Partition part, int *node)
406: {

412:   if (part->ops->getendnode == PETSC_NULL) {
413:     SETERRQ(PETSC_ERR_SUP, "Not implemented for this partition type");
414:   }
415:   (*part->ops->getendnode)(part, node);
416:   return(0);
417: }

419: /*@
420:   PartitionGetNumNodes - Gets the number of nodes in this domain.

422:   Not collective

424:   Input Parameter:
425: . part - The partition

427:   Output Parameter:
428: . size - The number of nodes in this domain

430:   Level: intermediate

432: .keywords: partition, node
433: .seealso: PartitionGetStartNode(), PartitionGetEndNode(), PartitionGetNumElements()
434: @*/
435: int PartitionGetNumNodes(Partition part, int *size)
436: {

442:   if (part->ops->getnumnodes == PETSC_NULL) {
443:     SETERRQ(PETSC_ERR_SUP, "Not implemented for this partition type");
444:   }
445:   (*part->ops->getnumnodes)(part, size);
446:   return(0);
447: }

449: /*@
450:   PartitionGetNumOverlapNodes - Gets the number of nodes and ghost nodes for this domain.

452:   Not collective

454:   Input Parameter:
455: . part - The partition

457:   Output Parameter:
458: . size - The number of nodes and ghost nodes this domain

460:   Level: intermediate

462: .keywords: partition, node
463: .seealso: PartitionGetStartNode(), PartitionGetEndNode(), PartitionGetNumOverlapElements()
464: @*/
465: int PartitionGetNumOverlapNodes(Partition part, int *size)
466: {

472:   if (part->ops->getnumoverlapnodes == PETSC_NULL) {
473:     SETERRQ(PETSC_ERR_SUP, "Not implemented for this partition type");
474:   }
475:   (*part->ops->getnumoverlapnodes)(part, size);
476:   return(0);
477: }

479: /*@
480:   PartitionGlobalToLocalNodeIndex - Returns the local node number
481:   corresponding to the global node number.

483:   Not collective

485:   Input Parameters:
486: + part    - The partition
487: - node    - The canonical global node number

489:   Output Parameter:
490: . locNode - The local node number

492:   Level: intermediate

494: .keywords: partition, local, global
495: .seealso: PartitionLocalToGlobalNodeIndex(), PartitionGlobalToLocalElementIndex()
496: @*/
497: int PartitionGlobalToLocalNodeIndex(Partition part, int node, int *locNode)
498: {

504:   if (part->ops->globaltolocalnodeindex == PETSC_NULL) {
505:     SETERRQ(PETSC_ERR_SUP, "Not implemented for this partition type");
506:   }
507:   (*part->ops->globaltolocalnodeindex)(part, node, locNode);
508:   return(0);
509: }

511: /*@
512:   PartitionLocalToGlobalNodeIndex - Returns the global node number
513:   corresponding to the local node number.

515:   Not collective

517:   Input Parameters:
518: + part    - The partition
519: - locNode - The canonical local node number

521:   Output Parameter:
522: . node    - The global node number

524:   Level: intermediate

526: .keywords: partition, local, global
527: .seealso: PartitionGlobalToLocalNodeIndex(), PartitionLocalToGlobalElementIndex()
528: @*/
529: int PartitionLocalToGlobalNodeIndex(Partition part, int locNode, int *node)
530: {

536:   if (part->ops->localtoglobalnodeindex == PETSC_NULL) {
537:     SETERRQ(PETSC_ERR_SUP, "Not implemented for this partition type");
538:   }
539:   (*part->ops->localtoglobalnodeindex)(part, locNode, node);
540:   return(0);
541: }

543: /*@
544:   PartitionGlobalToGhostNodeIndex - Returns the ghost node number
545:   corresponding to the global node number.

547:   Not collective

549:   Input Parameters:
550: + part      - The partition
551: - node      - The canonical global node number

553:   Output Parameters:
554: + ghostNode - The ghost node number (0..numGhosts)
555: - ghostProc - The processor on which the node resides

557:   Level: intermediate

559: .keywords: partition, ghost, global
560: .seealso: PartitionGhostToGlobalNodeIndex(), PartitionGlobalToLocalElementIndex()
561: @*/
562: int PartitionGlobalToGhostNodeIndex(Partition part, int node, int *ghostNode, int *ghostProc)
563: {

569:   if (part->ops->globaltoghostnodeindex == PETSC_NULL) {
570:     SETERRQ(PETSC_ERR_SUP, "Not implemented for this partition type");
571:   }
572:   (*part->ops->globaltoghostnodeindex)(part, node, ghostNode, ghostProc);
573:   return(0);
574: }

576: /*@
577:   PartitionGhostToGlobalNodeIndex - Returns the global node number
578:   corresponding to the ghost node number.

580:   Not collective

582:   Input Parameters:
583: + part      - The partition
584: - ghostNode - The canonical ghost node number (0..numGhosts)

586:   Output Parameters:
587: + node      - The global node number
588: - ghostProc - The processor on which the node resides

590:   Level: intermediate

592: .keywords: partition, ghost, global
593: .seealso: PartitionGlobalToGhostNodeIndex(), PartitionLocalToGlobalElementIndex()
594: @*/
595: int PartitionGhostToGlobalNodeIndex(Partition part, int ghostNode, int *node, int *ghostProc)
596: {

602:   if (part->ops->ghosttoglobalnodeindex == PETSC_NULL) {
603:     SETERRQ(PETSC_ERR_SUP, "Not implemented for this partition type");
604:   }
605:   (*part->ops->ghosttoglobalnodeindex)(part, ghostNode, node, ghostProc);
606:   return(0);
607: }

609: /*@
610:   PartitionGetNodeOrdering - This function gets the AO which was used to reorder the mesh nodes
611:   during partitioning.

613:   Not collective

615:   Input Parameter:
616: . part  - The partition

618:   Output Parameter:
619: . order - The node ordering, or PETSC_NULL if none exists

621:   Level: intermediate

623: .keywords: Partition, node, ordering, AO
624: .seealso: MeshGetNodeOrdering()
625: @*/
626: int PartitionGetNodeOrdering(Partition part, AO *order)
627: {

633:   (*part->ops->getnodeordering)(part, order);
634:   return(0);
635: }

637: /*----------------------------------------------- Face Query Functions -----------------------------------------------*/
638: /*@
639:   PartitionGetTotalFaces - Gets the number of faces in the mesh.

641:   Not collective

643:   Input Parameter:
644: . part - The partition

646:   Output Parameter:
647: . size - The number of faces in the mesh

649:   Level: intermediate

651: .keywords: partition, face
652: .seealso: PartitionGetStartFace(), PartitionGetEndFace(), PartitionGetTotalElements()
653: @*/
654: int PartitionGetTotalFaces(Partition part, int *size)
655: {

661:   if (part->ops->gettotalfaces == PETSC_NULL) {
662:     SETERRQ(PETSC_ERR_SUP, "Not implemented for this partition type");
663:   }
664:   (*part->ops->gettotalfaces)(part, size);
665:   return(0);
666: }

668: /*@
669:   PartitionGetStartFace - Gets the first face in this domain.

671:   Not collective

673:   Input Parameter:
674: . part - The partition

676:   Output Parameter:
677: . face - The first face in this domain

679:   Level: intermediate

681: .keywords: partition, face
682: .seealso: PartitionGetEndFace(), PartitionGetNumFaces(), PartitionGetStartElement()
683: @*/
684: int PartitionGetStartFace(Partition part, int *face)
685: {

691:   if (part->ops->getstartface == PETSC_NULL) {
692:     SETERRQ(PETSC_ERR_SUP, "Not implemented for this partition type");
693:   }
694:   (*part->ops->getstartface)(part, face);
695:   return(0);
696: }

698: /*@
699:   PartitionGetEndFace - Gets the first face in the next domain.

701:   Not collective

703:   Input Parameter:
704: . part - The partition

706:   Output Parameter:
707: . face - The first face in the next domain

709:   Level: intermediate

711: .keywords: partition, face
712: .seealso: PartitionGetStartFace(), PartitionGetNumFaces(), PartitionGetEndElement()
713: @*/
714: int PartitionGetEndFace(Partition part, int *face)
715: {

721:   if (part->ops->getendface == PETSC_NULL) {
722:     SETERRQ(PETSC_ERR_SUP, "Not implemented for this partition type");
723:   }
724:   (*part->ops->getendface)(part, face);
725:   return(0);
726: }

728: /*@
729:   PartitionGetNumFaces - Gets the number of faces in this domain.

731:   Not collective

733:   Input Parameter:
734: . part - The partition

736:   Output Parameter:
737: . size - The number of faces in this domain

739:   Level: intermediate

741: .keywords: partition, face
742: .seealso: PartitionGetStartFace(), PartitionGetEndFace(), PartitionGetNumElements()
743: @*/
744: int PartitionGetNumFaces(Partition part, int *size)
745: {

751:   if (part->ops->getnumfaces == PETSC_NULL) {
752:     SETERRQ(PETSC_ERR_SUP, "Not implemented for this partition type");
753:   }
754:   (*part->ops->getnumfaces)(part, size);
755:   return(0);
756: }

758: /*@
759:   PartitionGetNumOverlapFaces - Gets the number of faces and ghost faces this domain.

761:   Not collective

763:   Input Parameter:
764: . part - The partition

766:   Output Parameter:
767: . size - The number of faces and ghost faces this domain

769:   Level: intermediate

771: .keywords: partition, face
772: .seealso: PartitionGetStartFace(), PartitionGetEndFace(), PartitionGetNumOverlapElements()
773: @*/
774: int PartitionGetNumOverlapFaces(Partition part, int *size)
775: {

781:   if (part->ops->getnumoverlapfaces == PETSC_NULL) {
782:     SETERRQ(PETSC_ERR_SUP, "Not implemented for this partition type");
783:   }
784:   (*part->ops->getnumoverlapfaces)(part, size);
785:   return(0);
786: }

788: /*@
789:   PartitionGlobalToLocalFaceIndex - Returns the local face number
790:   corresponding to the global face number.

792:   Not collective

794:   Input Parameters:
795: + part    - The partition
796: - face    - The canonical global face number

798:   Output Parameter:
799: . locFace - The local face number

801:   Level: intermediate

803: .keywords: partition, local, global
804: .seealso: PartitionLocalToGlobalFaceIndex(), PartitionGlobalToLocalElementIndex()
805: @*/
806: int PartitionGlobalToLocalFaceIndex(Partition part, int face, int *locFace)
807: {

813:   if (part->ops->globaltolocalfaceindex == PETSC_NULL) {
814:     SETERRQ(PETSC_ERR_SUP, "Not implemented for this partition type");
815:   }
816:   (*part->ops->globaltolocalfaceindex)(part, face, locFace);
817:   return(0);
818: }

820: /*@
821:   PartitionLocalToGlobalFaceIndex - Returns the global face number
822:   corresponding to the local face number.

824:   Not collective

826:   Input Parameters:
827: + part    - The partition
828: - locFace - The canonical local face number

830:   Output Parameter:
831: . face    - The global face number

833:   Level: intermediate

835: .keywords: partition, local, global
836: .seealso: PartitionGlobalToLocalNodeIndex(), PartitionLocalToGlobalElementIndex()
837: @*/
838: int PartitionLocalToGlobalFaceIndex(Partition part, int locFace, int *face)
839: {

845:   if (part->ops->localtoglobalfaceindex == PETSC_NULL) {
846:     SETERRQ(PETSC_ERR_SUP, "Not implemented for this partition type");
847:   }
848:   (*part->ops->localtoglobalfaceindex)(part, locFace, face);
849:   return(0);
850: }

852: /*@
853:   PartitionGetFaceOrdering - This function gets the AO which was used to reorder the mesh faces
854:   during partitioning.

856:   Not collective

858:   Input Parameter:
859: . part  - The partition

861:   Output Parameter:
862: . order - The face ordering, or PETSC_NULL if none exists

864:   Level: intermediate

866: .keywords: Partition, face, ordering, AO
867: .seealso: MeshGetNodeOrdering()
868: @*/
869: int PartitionGetFaceOrdering(Partition part, AO *order)
870: {

876:   (*part->ops->getfaceordering)(part, order);
877:   return(0);
878: }

880: /*----------------------------------------------- Edge Query Functions -----------------------------------------------*/
881: /*@
882:   PartitionGetTotalEdges - Gets the number of edges in the mesh.

884:   Not collective

886:   Input Parameter:
887: . part - The partition

889:   Output Parameter:
890: . size - The number of edges in the mesh

892:   Level: intermediate

894: .keywords: partition, edge
895: .seealso: PartitionGetStartEdge(), PartitionGetEndEdge(), PartitionGetTotalElements()
896: @*/
897: int PartitionGetTotalEdges(Partition part, int *size)
898: {

904:   if (part->ops->gettotaledges == PETSC_NULL) {
905:     SETERRQ(PETSC_ERR_SUP, "Not implemented for this partition type");
906:   }
907:   (*part->ops->gettotaledges)(part, size);
908:   return(0);
909: }

911: /*@
912:   PartitionGetStartEdge - Gets the first edge in this domain.

914:   Not collective

916:   Input Parameter:
917: . part - The partition

919:   Output Parameter:
920: . edge - The first edge in this domain

922:   Level: intermediate

924: .keywords: partition, edge
925: .seealso: PartitionGetEndEdge(), PartitionGetNumEdges(), PartitionGetStartElement()
926: @*/
927: int PartitionGetStartEdge(Partition part, int *edge)
928: {

934:   if (part->ops->getstartedge == PETSC_NULL) {
935:     SETERRQ(PETSC_ERR_SUP, "Not implemented for this partition type");
936:   }
937:   (*part->ops->getstartedge)(part, edge);
938:   return(0);
939: }

941: /*@
942:   PartitionGetEndEdge - Gets the first edge in the next domain.

944:   Not collective

946:   Input Parameter:
947: . part - The partition

949:   Output Parameter:
950: . edge - The first edge in the next domain

952:   Level: intermediate

954: .keywords: partition, edge
955: .seealso: PartitionGetStartEdge(), PartitionGetNumEdges(), PartitionGetEndElement()
956: @*/
957: int PartitionGetEndEdge(Partition part, int *edge)
958: {

964:   if (part->ops->getendedge == PETSC_NULL) {
965:     SETERRQ(PETSC_ERR_SUP, "Not implemented for this partition type");
966:   }
967:   (*part->ops->getendedge)(part, edge);
968:   return(0);
969: }

971: /*@
972:   PartitionGetNumEdges - Gets the number of edges in this domain.

974:   Not collective

976:   Input Parameter:
977: . part - The partition

979:   Output Parameter:
980: . size - The number of edges in this domain

982:   Level: intermediate

984: .keywords: partition, edge
985: .seealso: PartitionGetStartEdge(), PartitionGetEndEdge(), PartitionGetNumElements()
986: @*/
987: int PartitionGetNumEdges(Partition part, int *size)
988: {

994:   if (part->ops->getnumedges == PETSC_NULL) {
995:     SETERRQ(PETSC_ERR_SUP, "Not implemented for this partition type");
996:   }
997:   (*part->ops->getnumedges)(part, size);
998:   return(0);
999: }

1001: /*@
1002:   PartitionGetNumOverlapEdges - Gets the number of edges and ghost edges this domain.

1004:   Not collective

1006:   Input Parameter:
1007: . part - The partition

1009:   Output Parameter:
1010: . size - The number of edges and ghost edges this domain

1012:   Level: intermediate

1014: .keywords: partition, edge
1015: .seealso: PartitionGetStartEdge(), PartitionGetEndEdge(), PartitionGetNumOverlapElements()
1016: @*/
1017: int PartitionGetNumOverlapEdges(Partition part, int *size)
1018: {

1024:   if (part->ops->getnumoverlapedges == PETSC_NULL) {
1025:     SETERRQ(PETSC_ERR_SUP, "Not implemented for this partition type");
1026:   }
1027:   (*part->ops->getnumoverlapedges)(part, size);
1028:   return(0);
1029: }

1031: /*@
1032:   PartitionGetEdgeOrdering - This function gets the AO which was used to reorder the mesh edges
1033:   during partitioning.

1035:   Not collective

1037:   Input Parameter:
1038: . part  - The partition

1040:   Output Parameter:
1041: . order - The edge ordering, or PETSC_NULL if none exists

1043:   Level: intermediate

1045: .keywords: Partition, edge, ordering, AO
1046: .seealso: MeshGetNodeOrdering()
1047: @*/
1048: int PartitionGetEdgeOrdering(Partition part, AO *order)
1049: {

1055:   (*part->ops->getedgeordering)(part, order);
1056:   return(0);
1057: }