Actual source code: drawreg.c
petsc-3.5.0 2014-06-30
2: /*
3: Provides the registration process for PETSc PetscDraw routines
4: */
5: #include <petsc-private/drawimpl.h> /*I "petscdraw.h" I*/
6: #include <petscviewer.h> /*I "petscviewer.h" I*/
7: #if defined(PETSC_HAVE_SAWS)
8: #include <petscviewersaws.h>
9: #endif
11: /*
12: Contains the list of registered PetscDraw routines
13: */
14: PetscFunctionList PetscDrawList = 0;
18: /*@C
19: PetscDrawView - Prints the PetscDraw data structure.
21: Collective on PetscDraw
23: Input Parameters:
24: + indraw - the PetscDraw context
25: - viewer - visualization context
27: Options Database Keys:
28: . -draw_view - print the ksp data structure at the end of a PetscDrawSetFromOptions() call
30: Note:
31: The available visualization contexts include
32: + PETSC_VIEWER_STDOUT_SELF - standard output (default)
33: - PETSC_VIEWER_STDOUT_WORLD - synchronized standard
34: output where only the first processor opens
35: the file. All other processors send their
36: data to the first processor to print.
38: The user can open an alternative visualization context with
39: PetscViewerASCIIOpen() - output to a specified file.
41: Level: beginner
43: .keywords: PetscDraw, view
45: .seealso: PCView(), PetscViewerASCIIOpen()
46: @*/
47: PetscErrorCode PetscDrawView(PetscDraw indraw,PetscViewer viewer)
48: {
50: PetscBool isdraw;
51: #if defined(PETSC_HAVE_SAWS)
52: PetscBool isams;
53: #endif
57: if (!viewer) viewer = PETSC_VIEWER_STDOUT_(PetscObjectComm((PetscObject)indraw));
61: PetscObjectPrintClassNamePrefixType((PetscObject)indraw,viewer);
62: PetscObjectTypeCompare((PetscObject)viewer,PETSCVIEWERDRAW,&isdraw);
63: #if defined(PETSC_HAVE_SAWS)
64: PetscObjectTypeCompare((PetscObject)viewer,PETSCVIEWERSAWS,&isams);
65: #endif
66: if (isdraw) {
67: PetscDraw draw;
68: char str[36];
69: PetscReal x,y,bottom,h;
71: PetscViewerDrawGetDraw(viewer,0,&draw);
72: PetscDrawGetCurrentPoint(draw,&x,&y);
73: PetscStrcpy(str,"PetscDraw: ");
74: PetscStrcat(str,((PetscObject)indraw)->type_name);
75: PetscDrawBoxedString(draw,x,y,PETSC_DRAW_RED,PETSC_DRAW_BLACK,str,NULL,&h);
76: bottom = y - h;
77: PetscDrawPushCurrentPoint(draw,x,bottom);
78: #if defined(PETSC_HAVE_SAWS)
79: } else if (isams) {
80: PetscMPIInt rank;
82: PetscObjectName((PetscObject)indraw);
83: MPI_Comm_rank(PETSC_COMM_WORLD,&rank);
84: if (!((PetscObject)indraw)->amsmem && !rank) {
85: PetscObjectViewSAWs((PetscObject)indraw,viewer);
86: }
87: #endif
88: } else if (indraw->ops->view) {
89: (*indraw->ops->view)(indraw,viewer);
90: }
91: return(0);
92: }
96: /*@C
97: PetscDrawCreate - Creates a graphics context.
99: Collective on MPI_Comm
101: Input Parameter:
102: + comm - MPI communicator
103: . display - X display when using X windows
104: . title - optional title added to top of window
105: . x,y - coordinates of lower left corner of window or PETSC_DECIDE
106: - w, h - width and height of window or PETSC_DECIDE or PETSC_DRAW_HALF_SIZE, PETSC_DRAW_FULL_SIZE,
107: or PETSC_DRAW_THIRD_SIZE or PETSC_DRAW_QUARTER_SIZE
109: Output Parameter:
110: . draw - location to put the PetscDraw context
112: Level: beginner
114: Concepts: graphics^creating context
115: Concepts: drawing^creating context
117: .seealso: PetscDrawSetFromOptions(), PetscDrawDestroy(), PetscDrawSetType()
118: @*/
119: PetscErrorCode PetscDrawCreate(MPI_Comm comm,const char display[],const char title[],int x,int y,int w,int h,PetscDraw *indraw)
120: {
121: PetscDraw draw;
123: PetscReal dpause;
124: PetscBool flag;
127: PetscDrawInitializePackage();
128: *indraw = 0;
129: PetscHeaderCreate(draw,_p_PetscDraw,struct _PetscDrawOps,PETSC_DRAW_CLASSID,"Draw","Graphics","Draw",comm,PetscDrawDestroy,PetscDrawView);
131: draw->data = 0;
132: PetscStrallocpy(title,&draw->title);
133: PetscStrallocpy(display,&draw->display);
134: draw->x = x;
135: draw->y = y;
136: draw->w = w;
137: draw->h = h;
138: draw->pause = 0.0;
139: draw->coor_xl = 0.0;
140: draw->coor_xr = 1.0;
141: draw->coor_yl = 0.0;
142: draw->coor_yr = 1.0;
143: draw->port_xl = 0.0;
144: draw->port_xr = 1.0;
145: draw->port_yl = 0.0;
146: draw->port_yr = 1.0;
147: draw->popup = 0;
149: PetscOptionsGetReal(NULL,"-draw_pause",&dpause,&flag);
150: if (flag) draw->pause = dpause;
151: draw->savefilename = NULL;
152: draw->savefilemovie = PETSC_FALSE;
153: draw->savefilecount = -1;
155: PetscDrawSetCurrentPoint(draw,.5,.9);
157: draw->boundbox_xl = .5;
158: draw->boundbox_xr = .5;
159: draw->boundbox_yl = .9;
160: draw->boundbox_yr = .9;
162: *indraw = draw;
163: return(0);
164: }
168: /*@C
169: PetscDrawSetType - Builds graphics object for a particular implementation
171: Collective on PetscDraw
173: Input Parameter:
174: + draw - the graphics context
175: - type - for example, PETSC_DRAW_X
177: Options Database Command:
178: . -draw_type <type> - Sets the type; use -help for a list
179: of available methods (for instance, x)
181: Level: intermediate
183: Notes:
184: See "petsc/include/petscdraw.h" for available methods (for instance,
185: PETSC_DRAW_X)
187: Concepts: drawing^X windows
188: Concepts: X windows^graphics
189: Concepts: drawing^Microsoft Windows
191: .seealso: PetscDrawSetFromOptions(), PetscDrawCreate(), PetscDrawDestroy()
192: @*/
193: PetscErrorCode PetscDrawSetType(PetscDraw draw,PetscDrawType type)
194: {
195: PetscErrorCode ierr,(*r)(PetscDraw);
196: PetscBool match;
197: PetscBool flg=PETSC_FALSE;
203: PetscObjectTypeCompare((PetscObject)draw,type,&match);
204: if (match) return(0);
206: /* User requests no graphics */
207: PetscOptionsHasName(NULL,"-nox",&flg);
209: /*
210: This is not ideal, but it allows codes to continue to run if X graphics
211: was requested but is not installed on this machine. Mostly this is for
212: testing.
213: */
214: #if !defined(PETSC_HAVE_X)
215: if (!flg) {
216: PetscStrcmp(type,PETSC_DRAW_X,&match);
217: if (match) {
218: PetscBool dontwarn = PETSC_TRUE;
219: flg = PETSC_TRUE;
220: PetscOptionsHasName(NULL,"-nox_warning",&dontwarn);
221: if (!dontwarn) (*PetscErrorPrintf)("PETSc installed without X windows on this machine\nproceeding without graphics\n");
222: }
223: }
224: #endif
225: if (flg) type = PETSC_DRAW_NULL;
227: if (draw->data) {
228: /* destroy the old private PetscDraw context */
229: (*draw->ops->destroy)(draw);
230: draw->ops->destroy = NULL;
231: draw->data = 0;
232: }
234: PetscFunctionListFind(PetscDrawList,type,&r);
235: if (!r) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_ARG_UNKNOWN_TYPE,"Unknown PetscDraw type given: %s",type);
236: PetscObjectChangeTypeName((PetscObject)draw,type);
237: draw->data = 0;
238: (*r)(draw);
239: return(0);
240: }
244: /*@C
245: PetscDrawGetType - Gets the PetscDraw type as a string from the PetscDraw object.
247: Not Collective
249: Input Parameter:
250: . draw - Krylov context
252: Output Parameters:
253: . name - name of PetscDraw method
255: Level: advanced
257: @*/
258: PetscErrorCode PetscDrawGetType(PetscDraw draw,PetscDrawType *type)
259: {
263: *type = ((PetscObject)draw)->type_name;
264: return(0);
265: }
269: /*@C
270: PetscDrawRegister - Adds a method to the graphics package.
272: Not Collective
274: Input Parameters:
275: + name_solver - name of a new user-defined graphics class
276: - routine_create - routine to create method context
278: Level: developer
280: Notes:
281: PetscDrawRegister() may be called multiple times to add several user-defined graphics classes
283: Sample usage:
284: .vb
285: PetscDrawRegister("my_draw_type", MyDrawCreate);
286: .ve
288: Then, your specific graphics package can be chosen with the procedural interface via
289: $ PetscDrawSetType(ksp,"my_draw_type")
290: or at runtime via the option
291: $ -draw_type my_draw_type
293: Concepts: graphics^registering new draw classes
294: Concepts: PetscDraw^registering new draw classes
296: .seealso: PetscDrawRegisterAll(), PetscDrawRegisterDestroy()
297: @*/
298: PetscErrorCode PetscDrawRegister(const char *sname,PetscErrorCode (*function)(PetscDraw))
299: {
303: PetscFunctionListAdd(&PetscDrawList,sname,function);
304: return(0);
305: }
309: /*@
310: PetscDrawSetFromOptions - Sets the graphics type from the options database.
311: Defaults to a PETSc X windows graphics.
313: Collective on PetscDraw
315: Input Parameter:
316: . draw - the graphics context
318: Options Database Keys:
319: + -nox - do not use X graphics (ignore graphics calls, but run program correctly)
320: . -nox_warning - when X windows support is not installed this prevents the warning message from being printed
321: . -draw_pause <pause amount> -- -1 indicates wait for mouse input, -2 indicates pause when window is to be destroyed
322: . -draw_save [optional filename] - (X windows only) saves each image before it is cleared to a file
323: . -draw_save_final_image [optional filename] - (X windows only) saves the final image displayed in a window
324: . -draw_save_movie - converts image files to a movie at the end of the run. See PetscDrawSetSave()
325: . -draw_save_on_flush - saves an image on each flush in addition to each clear
326: - -draw_save_single_file - saves each new image in the same file, normally each new image is saved in a new file with filename_%d
328: Level: intermediate
330: Notes:
331: Must be called after PetscDrawCreate() before the PetscDraw is used.
333: Concepts: drawing^setting options
334: Concepts: graphics^setting options
336: .seealso: PetscDrawCreate(), PetscDrawSetType(), PetscDrawSetSave(), PetscDrawSetSaveFinalImage()
338: @*/
339: PetscErrorCode PetscDrawSetFromOptions(PetscDraw draw)
340: {
341: PetscErrorCode ierr;
342: PetscBool flg,nox;
343: char vtype[256];
344: const char *def;
345: PetscReal dpause;
346: #if !defined(PETSC_USE_WINDOWS_GRAPHICS) && !defined(PETSC_HAVE_X)
347: PetscBool warn;
348: #endif
353: if (!PetscDrawList) {
354: PetscDrawRegisterAll();
355: }
357: if (((PetscObject)draw)->type_name) def = ((PetscObject)draw)->type_name;
358: else {
359: PetscOptionsHasName(NULL,"-nox",&nox);
360: def = PETSC_DRAW_NULL;
361: #if defined(PETSC_USE_WINDOWS_GRAPHICS)
362: if (!nox) def = PETSC_DRAW_WIN32;
363: #elif defined(PETSC_HAVE_X)
364: if (!nox) def = PETSC_DRAW_X;
365: #elif defined(PETSC_HAVE_GLUT)
366: if (!nox) def = PETSC_DRAW_GLUT;
367: #elif defined(PETSC_HAVE_OPENGLES)
368: if (!nox) def = PETSC_DRAW_OPENGLES;
369: #else
370: PetscOptionsHasName(NULL,"-nox_warning",&warn);
371: if (!nox && !warn) (*PetscErrorPrintf)("PETSc installed without X windows, Microsoft Graphics, OpenGL ES, or GLUT/OpenGL on this machine\nproceeding without graphics\n");
372: #endif
373: }
374: PetscObjectOptionsBegin((PetscObject)draw);
375: PetscOptionsFList("-draw_type","Type of graphical output","PetscDrawSetType",PetscDrawList,def,vtype,256,&flg);
376: if (flg) {
377: PetscDrawSetType(draw,vtype);
378: } else if (!((PetscObject)draw)->type_name) {
379: PetscDrawSetType(draw,def);
380: }
381: PetscOptionsName("-nox","Run without graphics","None",&nox);
382: #if defined(PETSC_HAVE_X)
383: {
384: char filename[PETSC_MAX_PATH_LEN];
385: PetscBool save,movie = PETSC_FALSE;
386: PetscOptionsBool("-draw_save_movie","Make a movie from the images saved (X Windows only)","PetscDrawSetSave",movie,&movie,NULL);
387: PetscOptionsBool("-draw_save_single_file","Each new image replaces previous image in file","PetscDrawSetSave",draw->savesinglefile,&draw->savesinglefile,NULL);
388: PetscOptionsString("-draw_save","Save graphics to file (X Windows only)","PetscDrawSetSave",filename,filename,PETSC_MAX_PATH_LEN,&save);
389: if (save) {
390: PetscDrawSetSave(draw,filename,movie);
391: }
392: PetscOptionsString("-draw_save_final_image","Save graphics to file (X Windows only)","PetscDrawSetSaveFinalImage",filename,filename,PETSC_MAX_PATH_LEN,&save);
393: if (save) {
394: PetscDrawSetSaveFinalImage(draw,filename);
395: }
396: PetscOptionsBool("-draw_save_on_flush","Save graphics to file (X Windows only) on each flush","PetscDrawSetSave",draw->saveonflush,&draw->saveonflush,NULL);
397: }
398: #endif
399: PetscOptionsGetReal(NULL,"-draw_pause",&dpause,&flg);
400: if (flg) draw->pause = dpause;
402: /* process any options handlers added with PetscObjectAddOptionsHandler() */
403: PetscObjectProcessOptionsHandlers((PetscObject)draw);
405: PetscDrawViewFromOptions(draw,NULL,"-draw_view");
406: PetscOptionsEnd();
407: return(0);
408: }
412: /*@C
413: PetscDrawSetSave - Saves images produced in a PetscDraw into a file as a Gif file using AfterImage
415: Collective on PetscDraw
417: Input Parameter:
418: + draw - the graphics context
419: . filename - name of the file, if NULL uses name of draw object
420: - movie - produce a movie of all the images
422: Options Database Command:
423: + -draw_save <filename>
424: - -draw_save_movie
426: Level: intermediate
428: Concepts: X windows^graphics
430: Notes: You should call this BEFORE calling PetscDrawClear() and creating your image.
432: Requires that PETSc be configured with the option --with-afterimage to save the images and ffmpeg must be in your path to make the movie
434: If X windows generates an error message about X_CreateWindow() failing then Afterimage was installed without X windows. Reinstall Afterimage using the
435: ./configure flags --x-includes=/pathtoXincludes --x-libraries=/pathtoXlibraries For example under Mac OS X Mountain Lion --x-includes=/opt/X11/include -x-libraries=/opt/X11/lib
438: .seealso: PetscDrawSetFromOptions(), PetscDrawCreate(), PetscDrawDestroy(), PetscDrawSetSaveFinalImage()
439: @*/
440: PetscErrorCode PetscDrawSetSave(PetscDraw draw,const char *filename,PetscBool movie)
441: {
446: PetscFree(draw->savefilename);
448: draw->savefilemovie = movie;
449: if (filename && filename[0]) {
450: PetscStrallocpy(filename,&draw->savefilename);
451: } else {
452: const char *name;
453: PetscObjectGetName((PetscObject)draw,&name);
454: PetscStrallocpy(name,&draw->savefilename);
455: }
456: if (draw->ops->setsave) {
457: (*draw->ops->setsave)(draw,draw->savefilename);
458: }
459: return(0);
460: }
464: /*@C
465: PetscDrawSetSaveFinalImage - Saves the finale image produced in a PetscDraw into a file as a Gif file using AfterImage
467: Collective on PetscDraw
469: Input Parameter:
470: + draw - the graphics context
471: - filename - name of the file, if NULL uses name of draw object
473: Options Database Command:
474: . -draw_save_final_image <filename>
476: Level: intermediate
478: Concepts: X windows^graphics
480: Notes: You should call this BEFORE calling PetscDrawClear() and creating your image.
482: Requires that PETSc be configured with the option --with-afterimage to save the images and ffmpeg must be in your path to make the movie
484: If X windows generates an error message about X_CreateWindow() failing then Afterimage was installed without X windows. Reinstall Afterimage using the
485: ./configure flags --x-includes=/pathtoXincludes --x-libraries=/pathtoXlibraries For example under Mac OS X Mountain Lion --x-includes=/opt/X11/include -x-libraries=/opt/X11/lib
488: .seealso: PetscDrawSetFromOptions(), PetscDrawCreate(), PetscDrawDestroy(), PetscDrawSetSave()
489: @*/
490: PetscErrorCode PetscDrawSetSaveFinalImage(PetscDraw draw,const char *filename)
491: {
496: PetscFree(draw->savefinalfilename);
498: if (filename && filename[0]) {
499: PetscStrallocpy(filename,&draw->savefinalfilename);
500: } else {
501: const char *name;
502: PetscObjectGetName((PetscObject)draw,&name);
503: PetscStrallocpy(name,&draw->savefinalfilename);
504: }
505: return(0);
506: }