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 with\n");
 22:   } else {
 23:     PetscViewerASCIIPrintf(viewer, "  Periodic Triangular 1D grid with\n");
 24:   }
 25:   if (mesh->numBd == 1) {
 26:     PetscViewerASCIIPrintf(viewer, "    %d closed boundary\n", mesh->numBd);
 27:   } else {
 28:     PetscViewerASCIIPrintf(viewer, "    %d closed boundaries\n", mesh->numBd);
 29:   }
 30:   for(i = 0; i < mesh->numBd; i++) {
 31:     PetscViewerASCIIPrintf(viewer, "      Boundary %d: %d nodes\n", tri->bdMarkers[i], tri->bdBegin[i+1] - tri->bdBegin[i]);
 32:   }
 33:   PetscViewerASCIIPrintf(viewer, "      Total boundary nodes: %d\n", mesh->numBdNodes);
 34:   PetscViewerASCIIGetPointer(viewer, &fd);
 35:   PetscSynchronizedFPrintf(mesh->comm, fd, "  Local graph %d: %d nodes\n", 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, " %d\n", tri->markers[i]);
 42:   }
 43:   PetscSynchronizedFlush(mesh->comm);
 44:   PetscSynchronizedFPrintf(mesh->comm, fd, "  Local graph %d: %d edges with %d nodes per edge\n",
 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 edge\n",
 52:                            p->rank, mesh->numEdges, 2);
 53:   for(i = 0; i < mesh->numEdges; i++) {
 54:     PetscSynchronizedFPrintf(mesh->comm, fd, "    %d %d %d\n", 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: }