Actual source code: drawreg.c
petsc-3.7.1 2016-05-15
Report Typos and Errors

      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:    See PetscDrawSetFromOptions() for options database keys

     29:    Note:
     30:    The available visualization contexts include
     31: +     PETSC_VIEWER_STDOUT_SELF - standard output (default)
     32: -     PETSC_VIEWER_STDOUT_WORLD - synchronized standard
     33:          output where only the first processor opens
     34:          the file.  All other processors send their
     35:          data to the first processor to print.

     37:    The user can open an alternative visualization context with
     38:    PetscViewerASCIIOpen() - output to a specified file.

     40:    Level: beginner

     42: .keywords: PetscDraw, view

     44: .seealso: PCView(), PetscViewerASCIIOpen()
     45: @*/
     46: PetscErrorCode  PetscDrawView(PetscDraw indraw,PetscViewer viewer)
     47: {
     49:   PetscBool      isdraw;
     50: #if defined(PETSC_HAVE_SAWS)
     51:   PetscBool      issaws;
     52: #endif

     56:   if (!viewer) {
     57:     PetscViewerASCIIGetStdout(PetscObjectComm((PetscObject)indraw),&viewer);
     58:   }

     62:   PetscObjectPrintClassNamePrefixType((PetscObject)indraw,viewer);
     63:   PetscObjectTypeCompare((PetscObject)viewer,PETSCVIEWERDRAW,&isdraw);
     64: #if defined(PETSC_HAVE_SAWS)
     65:   PetscObjectTypeCompare((PetscObject)viewer,PETSCVIEWERSAWS,&issaws);
     66: #endif
     67:   if (isdraw) {
     68:     PetscDraw draw;
     69:     char      str[36];
     70:     PetscReal x,y,bottom,h;

     72:     PetscViewerDrawGetDraw(viewer,0,&draw);
     73:     PetscDrawGetCurrentPoint(draw,&x,&y);
     74:     PetscStrcpy(str,"PetscDraw: ");
     75:     PetscStrcat(str,((PetscObject)indraw)->type_name);
     76:     PetscDrawStringBoxed(draw,x,y,PETSC_DRAW_RED,PETSC_DRAW_BLACK,str,NULL,&h);
     77:     bottom = y - h;
     78:     PetscDrawPushCurrentPoint(draw,x,bottom);
     79: #if defined(PETSC_HAVE_SAWS)
     80:   } else if (issaws) {
     81:     PetscMPIInt rank;

     83:     PetscObjectName((PetscObject)indraw);
     84:     MPI_Comm_rank(PETSC_COMM_WORLD,&rank);
     85:     if (!((PetscObject)indraw)->amsmem && !rank) {
     86:       PetscObjectViewSAWs((PetscObject)indraw,viewer);
     87:     }
     88: #endif
     89:   } else if (indraw->ops->view) {
     90:     (*indraw->ops->view)(indraw,viewer);
     91:   }
     92:   return(0);
     93: }

     97: /*@C
     98:    PetscDrawCreate - Creates a graphics context.

    100:    Collective on MPI_Comm

    102:    Input Parameter:
    103: +  comm - MPI communicator
    104: .  display - X display when using X windows
    105: .  title - optional title added to top of window
    106: .  x,y - coordinates of lower left corner of window or PETSC_DECIDE
    107: -  w, h - width and height of window or PETSC_DECIDE or PETSC_DRAW_HALF_SIZE, PETSC_DRAW_FULL_SIZE,
    108:           or PETSC_DRAW_THIRD_SIZE or PETSC_DRAW_QUARTER_SIZE

    110:    Output Parameter:
    111: .  draw - location to put the PetscDraw context

    113:    Level: beginner

    115:    Concepts: graphics^creating context
    116:    Concepts: drawing^creating context

    118: .seealso: PetscDrawSetFromOptions(), PetscDrawDestroy(), PetscDrawSetType()
    119: @*/
    120: PetscErrorCode  PetscDrawCreate(MPI_Comm comm,const char display[],const char title[],int x,int y,int w,int h,PetscDraw *indraw)
    121: {
    122:   PetscDraw      draw;
    124:   PetscReal      dpause = 0.0;
    125:   PetscBool      flag;

    128:   PetscDrawInitializePackage();
    129:   *indraw = 0;
    130:   PetscHeaderCreate(draw,PETSC_DRAW_CLASSID,"Draw","Graphics","Draw",comm,PetscDrawDestroy,PetscDrawView);

    132:   draw->data    = NULL;
    133:   PetscStrallocpy(display,&draw->display);
    134:   PetscStrallocpy(title,&draw->title);
    135:   draw->x       = x;
    136:   draw->y       = y;
    137:   draw->w       = w;
    138:   draw->h       = h;
    139:   draw->pause   = 0.0;
    140:   draw->coor_xl = 0.0;
    141:   draw->coor_xr = 1.0;
    142:   draw->coor_yl = 0.0;
    143:   draw->coor_yr = 1.0;
    144:   draw->port_xl = 0.0;
    145:   draw->port_xr = 1.0;
    146:   draw->port_yl = 0.0;
    147:   draw->port_yr = 1.0;
    148:   draw->popup   = NULL;

    150:   PetscOptionsGetReal(NULL,NULL,"-draw_pause",&dpause,&flag);
    151:   if (flag) draw->pause = dpause;

    153:   draw->savefilename   = NULL;
    154:   draw->saveimageext   = NULL;
    155:   draw->savemovieext   = NULL;
    156:   draw->savefilecount  = 0;
    157:   draw->savesinglefile = PETSC_FALSE;
    158:   draw->savemoviefps   = PETSC_DECIDE;

    160:   PetscDrawSetCurrentPoint(draw,.5,.9);

    162:   draw->boundbox_xl  = .5;
    163:   draw->boundbox_xr  = .5;
    164:   draw->boundbox_yl  = .9;
    165:   draw->boundbox_yr  = .9;

    167:   *indraw = draw;
    168:   return(0);
    169: }

    173: /*@C
    174:    PetscDrawSetType - Builds graphics object for a particular implementation

    176:    Collective on PetscDraw

    178:    Input Parameter:
    179: +  draw      - the graphics context
    180: -  type      - for example, PETSC_DRAW_X

    182:    Options Database Command:
    183: .  -draw_type  <type> - Sets the type; use -help for a list of available methods (for instance, x)

    185:    See PetscDrawSetFromOptions for additional options database keys

    187:    Level: intermediate

    189:    Notes:
    190:    See "petsc/include/petscdraw.h" for available methods (for instance,
    191:    PETSC_DRAW_X)

    193:    Concepts: drawing^X windows
    194:    Concepts: X windows^graphics
    195:    Concepts: drawing^Microsoft Windows

    197: .seealso: PetscDrawSetFromOptions(), PetscDrawCreate(), PetscDrawDestroy()
    198: @*/
    199: PetscErrorCode  PetscDrawSetType(PetscDraw draw,PetscDrawType type)
    200: {
    201:   PetscErrorCode ierr,(*r)(PetscDraw);
    202:   PetscBool      match;
    203:   PetscBool      flg=PETSC_FALSE;

    209:   PetscObjectTypeCompare((PetscObject)draw,type,&match);
    210:   if (match) return(0);

    212:   /*  User requests no graphics */
    213:   PetscOptionsHasName(((PetscObject)draw)->options,NULL,"-nox",&flg);

    215:   /*
    216:      This is not ideal, but it allows codes to continue to run if X graphics
    217:    was requested but is not installed on this machine. Mostly this is for
    218:    testing.
    219:    */
    220: #if !defined(PETSC_HAVE_X)
    221:   if (!flg) {
    222:     PetscStrcmp(type,PETSC_DRAW_X,&match);
    223:     if (match) {
    224:       PetscBool dontwarn = PETSC_TRUE;
    225:       flg  = PETSC_TRUE;
    226:       PetscOptionsHasName(NULL,NULL,"-nox_warning",&dontwarn);
    227:       if (!dontwarn) (*PetscErrorPrintf)("PETSc installed without X windows on this machine\nproceeding without graphics\n");
    228:     }
    229:   }
    230: #endif
    231:   if (flg) type = PETSC_DRAW_NULL;

    233:    PetscFunctionListFind(PetscDrawList,type,&r);
    234:   if (!r) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_ARG_UNKNOWN_TYPE,"Unknown PetscDraw type given: %s",type);
    235:   if (draw->ops->destroy) {(*draw->ops->destroy)(draw);}
    236:   PetscMemzero(draw->ops,sizeof(struct _PetscDrawOps));
    237:   PetscObjectChangeTypeName((PetscObject)draw,type);
    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: /*@C
    310:    PetscDrawSetOptionsPrefix - Sets the prefix used for searching for all
    311:    PetscDraw options in the database.

    313:    Logically Collective on PetscDraw

    315:    Input Parameter:
    316: +  draw - the draw context
    317: -  prefix - the prefix to prepend to all option names

    319:    Level: advanced

    321: .keywords: PetscDraw, set, options, prefix, database

    323: .seealso: PetscDrawSetFromOptions()
    324: @*/
    325: PetscErrorCode  PetscDrawSetOptionsPrefix(PetscDraw draw,const char prefix[])
    326: {

    331:   PetscObjectSetOptionsPrefix((PetscObject)draw,prefix);
    332:   return(0);
    333: }

    337: /*@
    338:    PetscDrawSetFromOptions - Sets the graphics type from the options database.
    339:       Defaults to a PETSc X windows graphics.

    341:    Collective on PetscDraw

    343:    Input Parameter:
    344: .     draw - the graphics context

    346:    Options Database Keys:
    347: +   -nox - do not use X graphics (ignore graphics calls, but run program correctly)
    348: .   -nox_warning - when X windows support is not installed this prevents the warning message from being printed
    349: .   -draw_pause <pause amount> -- -1 indicates wait for mouse input, -2 indicates pause when window is to be destroyed
    350: .   -draw_marker_type - <x,point>
    351: .   -draw_save [optional filename] - (X windows only) saves each image before it is cleared to a file
    352: .   -draw_save_final_image [optional filename] - (X windows only) saves the final image displayed in a window
    353: .   -draw_save_movie - converts image files to a movie  at the end of the run. See PetscDrawSetSave()
    354: .   -draw_save_single_file - saves each new image in the same file, normally each new image is saved in a new file with 'filename/filename_%d.ext'
    355: .   -draw_save_on_clear - saves an image on each clear, mainly for debugging
    356: -   -draw_save_on_flush - saves an image on each flush, mainly for debugging

    358:    Level: intermediate

    360:    Notes: Must be called after PetscDrawCreate() before the PetscDraw is used.

    362:    Concepts: drawing^setting options
    363:    Concepts: graphics^setting options

    365: .seealso: PetscDrawCreate(), PetscDrawSetType(), PetscDrawSetSave(), PetscDrawSetSaveFinalImage()

    367: @*/
    368: PetscErrorCode  PetscDrawSetFromOptions(PetscDraw draw)
    369: {
    370:   PetscErrorCode    ierr;
    371:   PetscBool         flg,nox;
    372:   char              vtype[256];
    373:   const char        *def;
    374: #if !defined(PETSC_USE_WINDOWS_GRAPHICS) && !defined(PETSC_HAVE_X)
    375:   PetscBool         warn;
    376: #endif

    381:   PetscDrawRegisterAll();

    383:   if (((PetscObject)draw)->type_name) def = ((PetscObject)draw)->type_name;
    384:   else {
    385:     PetscOptionsHasName(((PetscObject)draw)->options,NULL,"-nox",&nox);
    386:     def  = PETSC_DRAW_NULL;
    387: #if defined(PETSC_USE_WINDOWS_GRAPHICS)
    388:     if (!nox) def = PETSC_DRAW_WIN32;
    389: #elif defined(PETSC_HAVE_X)
    390:     if (!nox) def = PETSC_DRAW_X;
    391: #elif defined(PETSC_HAVE_GLUT)
    392:     if (!nox) def = PETSC_DRAW_GLUT;
    393: #elif defined(PETSC_HAVE_OPENGLES)
    394:     if (!nox) def = PETSC_DRAW_OPENGLES;
    395: #else
    396:     PetscOptionsHasName(NULL,NULL,"-nox_warning",&warn);
    397:     if (!nox && !warn) (*PetscErrorPrintf)("PETSc installed without X windows, Microsoft Graphics, OpenGL ES, or GLUT/OpenGL on this machine\nproceeding without graphics\n");
    398: #endif
    399:   }
    400:   PetscObjectOptionsBegin((PetscObject)draw);
    401:   PetscOptionsFList("-draw_type","Type of graphical output","PetscDrawSetType",PetscDrawList,def,vtype,256,&flg);
    402:   if (flg) {
    403:     PetscDrawSetType(draw,vtype);
    404:   } else if (!((PetscObject)draw)->type_name) {
    405:     PetscDrawSetType(draw,def);
    406:   }
    407:   PetscOptionsName("-nox","Run without graphics","None",&nox);
    408:   {
    409:     char      filename[PETSC_MAX_PATH_LEN];
    410:     char      movieext[32];
    411:     PetscBool image,movie;
    412:     PetscSNPrintf(filename,sizeof(filename),"%s%s",draw->savefilename?draw->savefilename:"",draw->saveimageext?draw->saveimageext:"");
    413:     PetscSNPrintf(movieext,sizeof(movieext),"%s",draw->savemovieext?draw->savemovieext:"");
    414:     PetscOptionsString("-draw_save","Save graphics to image file","PetscDrawSetSave",filename,filename,sizeof(filename),&image);
    415:     PetscOptionsString("-draw_save_movie","Make a movie from saved images","PetscDrawSetSaveMovie",movieext,movieext,sizeof(movieext),&movie);
    416:     PetscOptionsInt("-draw_save_movie_fps","Set frames per second in saved movie",__FUNCT__,draw->savemoviefps,&draw->savemoviefps,NULL);
    417:     PetscOptionsBool("-draw_save_single_file","Each new image replaces previous image in file",__FUNCT__,draw->savesinglefile,&draw->savesinglefile,NULL);
    418:     if (image) {PetscDrawSetSave(draw,filename);}
    419:     if (movie) {PetscDrawSetSaveMovie(draw,movieext);}
    420:     PetscOptionsString("-draw_save_final_image","Save final graphics to image file","PetscDrawSetSaveFinalImage",filename,filename,sizeof(filename),&image);
    421:     if (image) {PetscDrawSetSaveFinalImage(draw,filename);}
    422:     PetscOptionsBool("-draw_save_on_clear","Save graphics to file on each clear",__FUNCT__,draw->saveonclear,&draw->saveonclear,NULL);
    423:     PetscOptionsBool("-draw_save_on_flush","Save graphics to file on each flush",__FUNCT__,draw->saveonflush,&draw->saveonflush,NULL);
    424:   }
    425:   PetscOptionsReal("-draw_pause","Amount of time that program pauses after plots","PetscDrawSetPause",draw->pause,&draw->pause,NULL);
    426:   PetscOptionsEnum("-draw_marker_type","Type of marker to use on plots","PetscDrawSetMarkerType",PetscDrawMarkerTypes,(PetscEnum)draw->markertype,(PetscEnum *)&draw->markertype,NULL);

    428:   /* process any options handlers added with PetscObjectAddOptionsHandler() */
    429:   PetscObjectProcessOptionsHandlers(PetscOptionsObject,(PetscObject)draw);

    431:   PetscDrawViewFromOptions(draw,NULL,"-draw_view");
    432:   PetscOptionsEnd();
    433:   return(0);
    434: }