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: static int MeshView_Triangular_1D_File(Mesh mesh, PetscViewer viewer) {
 10:   Mesh_Triangular *tri = (Mesh_Triangular *) mesh->data;
 11:   Partition        p   = mesh->part;
 12:   FILE            *fd;
 13:   int              i, j, d;
 14:   int              ierr;

 17:   PetscViewerASCIIPrintf(viewer, "Mesh Object:n");
 18:   if (mesh->isPeriodic == PETSC_FALSE) {
 19:     PetscViewerASCIIPrintf(viewer, "  Triangular 1D grid withn");
 20:   } else {
 21:     PetscViewerASCIIPrintf(viewer, "  Periodic Triangular 1D grid withn");
 22:   }
 23:   if (mesh->numBd == 1) {
 24:     PetscViewerASCIIPrintf(viewer, "    %d closed boundaryn", mesh->numBd);
 25:   } else {
 26:     PetscViewerASCIIPrintf(viewer, "    %d closed boundariesn", mesh->numBd);
 27:   }
 28:   for(i = 0; i < mesh->numBd; i++) {
 29:     PetscViewerASCIIPrintf(viewer, "      Boundary %d: %d nodesn", tri->bdMarkers[i], tri->bdBegin[i+1] - tri->bdBegin[i]);
 30:   }
 31:   PetscViewerASCIIPrintf(viewer, "      Total boundary nodes: %dn", mesh->numBdNodes);
 32:   PetscViewerASCIIGetPointer(viewer, &fd);
 33:   PetscSynchronizedFPrintf(mesh->comm, fd, "  Local graph %d: %d nodesn", p->rank, mesh->numNodes);
 34:   for(i = 0; i < mesh->numNodes; i++) {
 35:     PetscSynchronizedFPrintf(mesh->comm, fd, "    %d", i);
 36:     for(d = 0; d < mesh->dim; d++) {
 37:       PetscSynchronizedFPrintf(mesh->comm, fd, " %g", tri->nodes[i*mesh->dim+d]);
 38:     }
 39:     PetscSynchronizedFPrintf(mesh->comm, fd, " %dn", tri->markers[i]);
 40:   }
 41:   PetscSynchronizedFlush(mesh->comm);
 42:   PetscSynchronizedFPrintf(mesh->comm, fd, "  Local graph %d: %d edges with %d nodes per edgen",
 43:                            p->rank, mesh->numEdges, mesh->numCorners);
 44:   for(i = 0; i < mesh->numEdges; i++) {
 45:     PetscSynchronizedFPrintf(mesh->comm, fd, "    %d", i);
 46:     for(j = 0; j < mesh->numCorners; j++) PetscSynchronizedFPrintf(mesh->comm, fd, " %d", tri->edges[i*mesh->numCorners+j]);
 47:     PetscSynchronizedFPrintf(mesh->comm, fd, "n");
 48:   }
 49:   PetscSynchronizedFPrintf(mesh->comm, fd, "  Local dual graph %d: %d edges with %d neighbors per edgen",
 50:                            p->rank, mesh->numEdges, 2);
 51:   for(i = 0; i < mesh->numEdges; i++) {
 52:     PetscSynchronizedFPrintf(mesh->comm, fd, "    %d %d %dn", i, tri->neighbors[i*2], tri->neighbors[i*2+1]);
 53:   }
 54:   PetscSynchronizedFlush(mesh->comm);
 55: 
 56:   if (mesh->partitioned) {
 57:     PartitionView(mesh->part, viewer);
 58:   }
 59:   return(0);
 60: }

 62: static int MeshView_Triangular_1D_Draw_Element(Mesh mesh, PetscDraw draw, int edge, int color) {
 63:   Mesh_Triangular *tri         = (Mesh_Triangular *) mesh->data;
 64:   int              numCorners  = mesh->numCorners;
 65:   int              numElements = mesh->numEdges;
 66:   int             *elements    = tri->edges;
 67:   double          *nodes       = tri->nodes;
 68:   int             *markers     = tri->markers;
 69:   int              node, corner;
 70:   int              ierr;

 73:   if (numCorners == 2) {
 74:     MeshDrawLine(mesh, draw, nodes[elements[edge*2]],   0.0, nodes[elements[edge*2+1]], 0.0, color);
 75:   } else if (numCorners == 3) {
 76:     MeshDrawLine(mesh, draw, nodes[elements[edge*3]],   0.0, nodes[elements[edge*3+2]], 0.0, color);
 77:     MeshDrawLine(mesh, draw, nodes[elements[edge*3+2]], 0.0, nodes[elements[edge*3+1]], 0.0, color);
 78:   } else {
 79:     SETERRQ1(PETSC_ERR_SUP, "Invalid number of corners %d", numCorners);
 80:   }
 81:   for(corner = 0; corner < numCorners; corner++) {
 82:     node = elements[edge*numCorners+corner];
 83:     if (corner >= 2) {
 84:       PetscDrawPointSetSize(draw, 0.0);
 85:     } else {
 86:       PetscDrawPointSetSize(draw, (1.0/numElements)/10.0);
 87:     }
 88:     if (markers[node] == 0) {
 89:       PetscDrawPoint(draw, nodes[node], 0.0, PETSC_DRAW_BLACK);
 90:     } else {
 91:       PetscDrawPoint(draw, nodes[node], 0.0, PETSC_DRAW_RED);
 92:     }
 93:   }
 94:   PetscDrawPointSetSize(draw, 0.0);
 95:   return(0);
 96: }

 98: static int MeshView_Triangular_1D_Draw_Mesh(Mesh mesh, PetscDraw draw) {
 99:   int numElements = mesh->numEdges;
100:   int hElement    = mesh->highlightElement;
101:   int color, rank;
102:   int elem;

106:   MPI_Comm_rank(mesh->comm, &rank);
107:   for(elem = 0; elem < numElements; elem++) {
108:     if (hElement == elem) {
109:       color = PETSC_DRAW_RED;
110:     } else {
111:       color = PETSC_DRAW_RED + rank + 2;
112:     }
113:     MeshView_Triangular_1D_Draw_Element(mesh, draw, elem, color);
114:   }
115:   return(0);
116: }

118: /*
119:   Remember that this function sets the coordinates for the window.
120: */
121: static int MeshView_DrawStatusLine_Private(Mesh mesh, PetscDraw draw, double startX, double startY, double endX,
122:                                            double endY, double offX, double offY) {
123:   Partition part = mesh->part;
124:   MPI_Comm  comm;
125:   char      statusLine[1024];
126:   PetscReal textWidth, textHeight;
127:   int       hElement, rank;
128:   int       ierr;

131:   PetscObjectGetComm((PetscObject) mesh, &comm);
132:   MPI_Comm_rank(comm, &rank);
133:   MeshGetHighlightElement(mesh, &hElement);
134:   PartitionLocalToGlobalElementIndex(part, hElement, &hElement);
135:   sprintf(statusLine, "Element %d Proc: %d", hElement, rank);
136:   PetscDrawStringGetSize(draw, &textWidth, &textHeight);
137:   PetscDrawSetCoordinates(draw, startX-offX, startY-offY-textHeight, endX+offX, endY+offY);
138:   if (hElement >= 0) {
139:     PetscDrawString(draw, startX-offX, startY-offY-textHeight, PETSC_DRAW_BLACK, statusLine);
140:   }
141:   return(0);
142: }

144: static int MeshView_Triangular_1D_Draw(Mesh mesh, PetscViewer v) {
145:   double          startX = mesh->startX;
146:   double          endX   = mesh->endX;
147:   double          sizeX  = mesh->sizeX;
148:   double          sizeY  = sizeX/3.0;
149:   double          startY = 0.0;
150:   double          endY   = startY + sizeY;
151:   double          offX, offY;
152:   PetscDraw       draw;
153:   PetscTruth      isnull;
154:   PetscDrawButton button;
155:   int             pause, hElement;
156:   PetscReal       xc, yc, scale;
157:   int             xsize, ysize;
158:   int             ierr;

161:   PetscViewerDrawGetDraw(v, 0, &draw);
162:   PetscDrawIsNull(draw, &isnull);
163:   if (isnull) return(0);
164:   if (sizeX > sizeY) {
165:     ysize = 300;
166:     if (sizeY > 0.0) {
167:       xsize = ysize * (int) (sizeX/sizeY);
168:     } else {
169:       return(0);
170:     }
171:   } else {
172:     xsize = 300;
173:     if (sizeX > 0.0) {
174:       ysize = xsize * (int) (sizeY/sizeX);
175:     } else {
176:       return(0);
177:     }
178:   }
179:   if ((xsize == 0) || (ysize == 0)) return(0);
180:   offX = 0.02*sizeX;
181:   offY = 0.02*sizeY;
182:   PetscDrawResizeWindow(draw, xsize, ysize);
183:   MeshView_DrawStatusLine_Private(mesh, draw, startX, startY, endX, endY, offX, offY);
184:   MeshView_Triangular_1D_Draw_Mesh(mesh, draw);
185:   PetscDrawGetPause(draw, &pause);
186:   if (pause >= 0) {
187:     PetscSleep(pause);
188:     return(0);
189:   }

191:   /* Allow the mesh to zoom or shrink */
192:   PetscDrawCheckResizedWindow(draw);
193:   PetscDrawSynchronizedGetMouseButton(draw, &button, &xc, &yc, 0, 0);
194:   while (button != BUTTON_RIGHT) {
195:     PetscDrawSynchronizedClear(draw);
196:     switch (button)
197:     {
198:     case BUTTON_LEFT:
199:       scale = 0.5;
200:       break;
201:     case BUTTON_CENTER:
202:       scale = 2.0;
203:       break;
204:     case BUTTON_LEFT_SHIFT:
205:       scale = 1.0;
206:       MeshLocatePoint(mesh, xc, yc, 0.0, &hElement);
207:       MeshSetHighlightElement(mesh, hElement);
208:       break;
209:     default:
210:       scale = 1.0;
211:       break;
212:     }
213:     if (scale != 1.0) {
214:       startX = scale*(startX + sizeX - xc) + xc - sizeX*scale;
215:       endX   = scale*(endX   - sizeX - xc) + xc + sizeX*scale;
216:       startY = scale*(startY + sizeY - yc) + yc - sizeY*scale;
217:       endY   = scale*(endY   - sizeY - yc) + yc + sizeY*scale;
218:       sizeX *= scale;
219:       sizeY *= scale;
220:       offX  *= scale;
221:       offY  *= scale;
222:     }

224:     MeshView_DrawStatusLine_Private(mesh, draw, startX, startY, endX, endY, offX, offY);
225:     MeshView_Triangular_1D_Draw_Mesh(mesh, draw);
226:     PetscDrawCheckResizedWindow(draw);
227:     PetscDrawSynchronizedGetMouseButton(draw, &button, &xc, &yc, 0, 0);
228:   }

230:   return(0);
231: }

233: int MeshView_Triangular_1D(Mesh mesh, PetscViewer viewer) {
234:   PetscTruth isascii, isdraw;
235:   int        ierr;

238:   PetscTypeCompare((PetscObject) viewer, PETSC_VIEWER_ASCII, &isascii);
239:   PetscTypeCompare((PetscObject) viewer, PETSC_VIEWER_DRAW,  &isdraw);
240:   if (isascii == PETSC_TRUE) {
241:     MeshView_Triangular_1D_File(mesh, viewer);
242:   } else if (isdraw == PETSC_TRUE) {
243:     MeshView_Triangular_1D_Draw(mesh, viewer);
244:   }

246:   return(0);
247: }