Actual source code: tri1dView.c
1: #ifdef PETSC_RCS_HEADER
2: static char vcid[] = "$Id: tri1dView.c,v 1.4 2000/10/17 13:48:56 knepley Exp $";
3: #endif
5: /* Viewers for 1d triangular grids */
6: #include "src/mesh/impls/triangular/1d/1dimpl.h" /*I "mesh.h" I*/
7: #include "tri1dView.h"
9: #undef __FUNCT__
11: static int MeshView_Triangular_1D_File(Mesh mesh, PetscViewer viewer) {
12: Mesh_Triangular *tri = (Mesh_Triangular *) mesh->data;
13: Partition p = mesh->part;
14: FILE *fd;
15: int i, j, d;
16: int ierr;
19: PetscViewerASCIIPrintf(viewer, "Mesh Object:n");
20: if (mesh->isPeriodic == PETSC_FALSE) {
21: PetscViewerASCIIPrintf(viewer, " Triangular 1D grid withn");
22: } else {
23: PetscViewerASCIIPrintf(viewer, " Periodic Triangular 1D grid withn");
24: }
25: if (mesh->numBd == 1) {
26: PetscViewerASCIIPrintf(viewer, " %d closed boundaryn", mesh->numBd);
27: } else {
28: PetscViewerASCIIPrintf(viewer, " %d closed boundariesn", mesh->numBd);
29: }
30: for(i = 0; i < mesh->numBd; i++) {
31: PetscViewerASCIIPrintf(viewer, " Boundary %d: %d nodesn", tri->bdMarkers[i], tri->bdBegin[i+1] - tri->bdBegin[i]);
32: }
33: PetscViewerASCIIPrintf(viewer, " Total boundary nodes: %dn", mesh->numBdNodes);
34: PetscViewerASCIIGetPointer(viewer, &fd);
35: PetscSynchronizedFPrintf(mesh->comm, fd, " Local graph %d: %d nodesn", p->rank, mesh->numNodes);
36: for(i = 0; i < mesh->numNodes; i++) {
37: PetscSynchronizedFPrintf(mesh->comm, fd, " %d", i);
38: for(d = 0; d < mesh->dim; d++) {
39: PetscSynchronizedFPrintf(mesh->comm, fd, " %g", tri->nodes[i*mesh->dim+d]);
40: }
41: PetscSynchronizedFPrintf(mesh->comm, fd, " %dn", tri->markers[i]);
42: }
43: PetscSynchronizedFlush(mesh->comm);
44: PetscSynchronizedFPrintf(mesh->comm, fd, " Local graph %d: %d edges with %d nodes per edgen",
45: p->rank, mesh->numEdges, mesh->numCorners);
46: for(i = 0; i < mesh->numEdges; i++) {
47: PetscSynchronizedFPrintf(mesh->comm, fd, " %d", i);
48: for(j = 0; j < mesh->numCorners; j++) PetscSynchronizedFPrintf(mesh->comm, fd, " %d", tri->edges[i*mesh->numCorners+j]);
49: PetscSynchronizedFPrintf(mesh->comm, fd, "n");
50: }
51: PetscSynchronizedFPrintf(mesh->comm, fd, " Local dual graph %d: %d edges with %d neighbors per edgen",
52: p->rank, mesh->numEdges, 2);
53: for(i = 0; i < mesh->numEdges; i++) {
54: PetscSynchronizedFPrintf(mesh->comm, fd, " %d %d %dn", i, tri->neighbors[i*2], tri->neighbors[i*2+1]);
55: }
56: PetscSynchronizedFlush(mesh->comm);
57:
58: if (mesh->partitioned) {
59: PartitionView(mesh->part, viewer);
60: }
61: return(0);
62: }
64: #undef __FUNCT__
66: static int MeshView_Triangular_1D_Draw_Element(Mesh mesh, PetscDraw draw, int edge, int color) {
67: Mesh_Triangular *tri = (Mesh_Triangular *) mesh->data;
68: int numCorners = mesh->numCorners;
69: int numElements = mesh->numEdges;
70: int *elements = tri->edges;
71: double *nodes = tri->nodes;
72: int *markers = tri->markers;
73: int node, corner;
74: int ierr;
77: if (numCorners == 2) {
78: MeshDrawLine(mesh, draw, nodes[elements[edge*2]], 0.0, nodes[elements[edge*2+1]], 0.0, color);
79: } else if (numCorners == 3) {
80: MeshDrawLine(mesh, draw, nodes[elements[edge*3]], 0.0, nodes[elements[edge*3+2]], 0.0, color);
81: MeshDrawLine(mesh, draw, nodes[elements[edge*3+2]], 0.0, nodes[elements[edge*3+1]], 0.0, color);
82: } else {
83: SETERRQ1(PETSC_ERR_SUP, "Invalid number of corners %d", numCorners);
84: }
85: for(corner = 0; corner < numCorners; corner++) {
86: node = elements[edge*numCorners+corner];
87: if (corner >= 2) {
88: PetscDrawPointSetSize(draw, 0.0);
89: } else {
90: PetscDrawPointSetSize(draw, (1.0/numElements)/10.0);
91: }
92: if (markers[node] == 0) {
93: PetscDrawPoint(draw, nodes[node], 0.0, PETSC_DRAW_BLACK);
94: } else {
95: PetscDrawPoint(draw, nodes[node], 0.0, PETSC_DRAW_RED);
96: }
97: }
98: PetscDrawPointSetSize(draw, 0.0);
99: return(0);
100: }
102: #undef __FUNCT__
104: static int MeshView_Triangular_1D_Draw_Mesh(Mesh mesh, PetscDraw draw) {
105: int numElements = mesh->numEdges;
106: int hElement = mesh->highlightElement;
107: int color, rank;
108: int elem;
112: MPI_Comm_rank(mesh->comm, &rank);
113: for(elem = 0; elem < numElements; elem++) {
114: if (hElement == elem) {
115: color = PETSC_DRAW_RED;
116: } else {
117: color = PETSC_DRAW_RED + rank + 2;
118: }
119: MeshView_Triangular_1D_Draw_Element(mesh, draw, elem, color);
120: }
121: return(0);
122: }
124: #undef __FUNCT__
126: /*
127: Remember that this function sets the coordinates for the window.
128: */
129: static int MeshView_DrawStatusLine_Private(Mesh mesh, PetscDraw draw, double startX, double startY, double endX,
130: double endY, double offX, double offY) {
131: Partition part = mesh->part;
132: MPI_Comm comm;
133: char statusLine[1024];
134: PetscReal textWidth, textHeight;
135: int hElement, rank;
136: int ierr;
139: PetscObjectGetComm((PetscObject) mesh, &comm);
140: MPI_Comm_rank(comm, &rank);
141: MeshGetHighlightElement(mesh, &hElement);
142: PartitionLocalToGlobalElementIndex(part, hElement, &hElement);
143: sprintf(statusLine, "Element %d Proc: %d", hElement, rank);
144: PetscDrawStringGetSize(draw, &textWidth, &textHeight);
145: PetscDrawSetCoordinates(draw, startX-offX, startY-offY-textHeight, endX+offX, endY+offY);
146: if (hElement >= 0) {
147: PetscDrawString(draw, startX-offX, startY-offY-textHeight, PETSC_DRAW_BLACK, statusLine);
148: }
149: return(0);
150: }
152: #undef __FUNCT__
154: static int MeshView_Triangular_1D_Draw(Mesh mesh, PetscViewer v) {
155: double startX = mesh->startX;
156: double endX = mesh->endX;
157: double sizeX = mesh->sizeX;
158: double sizeY = sizeX/3.0;
159: double startY = 0.0;
160: double endY = startY + sizeY;
161: double offX, offY;
162: PetscDraw draw;
163: PetscTruth isnull;
164: PetscDrawButton button;
165: int pause, hElement;
166: PetscReal xc, yc, scale;
167: int xsize, ysize;
168: int ierr;
171: PetscViewerDrawGetDraw(v, 0, &draw);
172: PetscDrawIsNull(draw, &isnull);
173: if (isnull) return(0);
174: if (sizeX > sizeY) {
175: ysize = 300;
176: if (sizeY > 0.0) {
177: xsize = ysize * (int) (sizeX/sizeY);
178: } else {
179: return(0);
180: }
181: } else {
182: xsize = 300;
183: if (sizeX > 0.0) {
184: ysize = xsize * (int) (sizeY/sizeX);
185: } else {
186: return(0);
187: }
188: }
189: if ((xsize == 0) || (ysize == 0)) return(0);
190: offX = 0.02*sizeX;
191: offY = 0.02*sizeY;
192: PetscDrawResizeWindow(draw, xsize, ysize);
193: MeshView_DrawStatusLine_Private(mesh, draw, startX, startY, endX, endY, offX, offY);
194: MeshView_Triangular_1D_Draw_Mesh(mesh, draw);
195: PetscDrawGetPause(draw, &pause);
196: if (pause >= 0) {
197: PetscSleep(pause);
198: return(0);
199: }
201: /* Allow the mesh to zoom or shrink */
202: PetscDrawCheckResizedWindow(draw);
203: PetscDrawSynchronizedGetMouseButton(draw, &button, &xc, &yc, 0, 0);
204: while (button != BUTTON_RIGHT) {
205: PetscDrawSynchronizedClear(draw);
206: switch (button)
207: {
208: case BUTTON_LEFT:
209: scale = 0.5;
210: break;
211: case BUTTON_CENTER:
212: scale = 2.0;
213: break;
214: case BUTTON_LEFT_SHIFT:
215: scale = 1.0;
216: MeshLocatePoint(mesh, xc, yc, 0.0, &hElement);
217: MeshSetHighlightElement(mesh, hElement);
218: break;
219: default:
220: scale = 1.0;
221: break;
222: }
223: if (scale != 1.0) {
224: startX = scale*(startX + sizeX - xc) + xc - sizeX*scale;
225: endX = scale*(endX - sizeX - xc) + xc + sizeX*scale;
226: startY = scale*(startY + sizeY - yc) + yc - sizeY*scale;
227: endY = scale*(endY - sizeY - yc) + yc + sizeY*scale;
228: sizeX *= scale;
229: sizeY *= scale;
230: offX *= scale;
231: offY *= scale;
232: }
234: MeshView_DrawStatusLine_Private(mesh, draw, startX, startY, endX, endY, offX, offY);
235: MeshView_Triangular_1D_Draw_Mesh(mesh, draw);
236: PetscDrawCheckResizedWindow(draw);
237: PetscDrawSynchronizedGetMouseButton(draw, &button, &xc, &yc, 0, 0);
238: }
240: return(0);
241: }
243: #undef __FUNCT__
245: int MeshView_Triangular_1D(Mesh mesh, PetscViewer viewer) {
246: PetscTruth isascii, isdraw;
247: int ierr;
250: PetscTypeCompare((PetscObject) viewer, PETSC_VIEWER_ASCII, &isascii);
251: PetscTypeCompare((PetscObject) viewer, PETSC_VIEWER_DRAW, &isdraw);
252: if (isascii == PETSC_TRUE) {
253: MeshView_Triangular_1D_File(mesh, viewer);
254: } else if (isdraw == PETSC_TRUE) {
255: MeshView_Triangular_1D_Draw(mesh, viewer);
256: }
258: return(0);
259: }