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: }