Date: 2013-07-02T14:38:04+00:00

Actual source code: vcreatea.c
petsc-3.4.2 2013-07-02

      2: #include <../src/sys/classes/viewer/impls/ascii/asciiimpl.h>  /*I     "petscsys.h"   I*/

      4: /* ---------------------------------------------------------------------*/
      5: /*
      6:     The variable Petsc_Viewer_Stdout_keyval is used to indicate an MPI attribute that
      7:   is attached to a communicator, in this case the attribute is a PetscViewer.
      8: */
      9: static PetscMPIInt Petsc_Viewer_Stdout_keyval = MPI_KEYVAL_INVALID;

     13: /*@C
     14:    PetscViewerASCIIGetStdout - Creates a ASCII PetscViewer shared by all processors
     15:                     in a communicator. Error returning version of PETSC_VIEWER_STDOUT_()

     17:    Collective on MPI_Comm

     19:    Input Parameter:
     20: .  comm - the MPI communicator to share the PetscViewer

     22:    Level: beginner

     24:    Notes:
     25:      This should be used in all PETSc source code instead of PETSC_VIEWER_STDOUT_()

     27: .seealso: PETSC_VIEWER_DRAW_(), PetscViewerASCIIOpen(), PETSC_VIEWER_STDERR_, PETSC_VIEWER_STDOUT_WORLD,
     28:           PETSC_VIEWER_STDOUT_SELF

     30: @*/
     31: PetscErrorCode  PetscViewerASCIIGetStdout(MPI_Comm comm,PetscViewer *viewer)
     32: {
     34:   PetscBool      flg;
     35:   MPI_Comm       ncomm;

     38:   PetscCommDuplicate(comm,&ncomm,NULL);
     39:   if (Petsc_Viewer_Stdout_keyval == MPI_KEYVAL_INVALID) {
     40:     MPI_Keyval_create(MPI_NULL_COPY_FN,MPI_NULL_DELETE_FN,&Petsc_Viewer_Stdout_keyval,0);
     41:   }
     42:   MPI_Attr_get(ncomm,Petsc_Viewer_Stdout_keyval,(void**)viewer,(PetscMPIInt*)&flg);
     43:   if (!flg) { /* PetscViewer not yet created */
     44:     PetscViewerASCIIOpen(ncomm,"stdout",viewer);
     45:     PetscObjectRegisterDestroy((PetscObject)*viewer);
     46:     MPI_Attr_put(ncomm,Petsc_Viewer_Stdout_keyval,(void*)*viewer);
     47:   }
     48:   PetscCommDestroy(&ncomm);
     49:   return(0);
     50: }

     54: /*@C
     55:    PETSC_VIEWER_STDOUT_ - Creates a ASCII PetscViewer shared by all processors
     56:                     in a communicator.

     58:    Collective on MPI_Comm

     60:    Input Parameter:
     61: .  comm - the MPI communicator to share the PetscViewer

     63:    Level: beginner

     65:    Notes:
     66:    Unlike almost all other PETSc routines, this does not return
     67:    an error code. Usually used in the form
     68: $      XXXView(XXX object,PETSC_VIEWER_STDOUT_(comm));

     70: .seealso: PETSC_VIEWER_DRAW_(), PetscViewerASCIIOpen(), PETSC_VIEWER_STDERR_, PETSC_VIEWER_STDOUT_WORLD,
     71:           PETSC_VIEWER_STDOUT_SELF

     73: @*/
     74: PetscViewer  PETSC_VIEWER_STDOUT_(MPI_Comm comm)
     75: {
     77:   PetscViewer    viewer;

     80:   PetscViewerASCIIGetStdout(comm,&viewer);
     81:   if (ierr) {PetscError(PETSC_COMM_SELF,__LINE__,"PETSC_VIEWER_STDOUT_",__FILE__,__SDIR__,PETSC_ERR_PLIB,PETSC_ERROR_INITIAL," "); return(0);}
     82:   PetscFunctionReturn(viewer);
     83: }

     85: /* ---------------------------------------------------------------------*/
     86: /*
     87:     The variable Petsc_Viewer_Stderr_keyval is used to indicate an MPI attribute that
     88:   is attached to a communicator, in this case the attribute is a PetscViewer.
     89: */
     90: static PetscMPIInt Petsc_Viewer_Stderr_keyval = MPI_KEYVAL_INVALID;

     94: /*@C
     95:    PetscViewerASCIIGetStderr - Creates a ASCII PetscViewer shared by all processors
     96:                     in a communicator. Error returning version of PETSC_VIEWER_STDERR_()

     98:    Collective on MPI_Comm

    100:    Input Parameter:
    101: .  comm - the MPI communicator to share the PetscViewer

    103:    Level: beginner

    105:    Notes:
    106:      This should be used in all PETSc source code instead of PETSC_VIEWER_STDERR_()

    108: .seealso: PETSC_VIEWER_DRAW_(), PetscViewerASCIIOpen(), PETSC_VIEWER_STDERR_, PETSC_VIEWER_STDERR_WORLD,
    109:           PETSC_VIEWER_STDERR_SELF

    111: @*/
    112: PetscErrorCode  PetscViewerASCIIGetStderr(MPI_Comm comm,PetscViewer *viewer)
    113: {
    115:   PetscBool      flg;
    116:   MPI_Comm       ncomm;

    119:   PetscCommDuplicate(comm,&ncomm,NULL);
    120:   if (Petsc_Viewer_Stderr_keyval == MPI_KEYVAL_INVALID) {
    121:     MPI_Keyval_create(MPI_NULL_COPY_FN,MPI_NULL_DELETE_FN,&Petsc_Viewer_Stderr_keyval,0);
    122:   }
    123:   MPI_Attr_get(ncomm,Petsc_Viewer_Stderr_keyval,(void**)viewer,(PetscMPIInt*)&flg);
    124:   if (!flg) { /* PetscViewer not yet created */
    125:     PetscViewerASCIIOpen(ncomm,"stderr",viewer);
    126:     PetscObjectRegisterDestroy((PetscObject)*viewer);
    127:     MPI_Attr_put(ncomm,Petsc_Viewer_Stderr_keyval,(void*)*viewer);
    128:   }
    129:   PetscCommDestroy(&ncomm);
    130:   return(0);
    131: }

    135: /*@C
    136:    PETSC_VIEWER_STDERR_ - Creates a ASCII PetscViewer shared by all processors
    137:                     in a communicator.

    139:    Collective on MPI_Comm

    141:    Input Parameter:
    142: .  comm - the MPI communicator to share the PetscViewer

    144:    Level: beginner

    146:    Note:
    147:    Unlike almost all other PETSc routines, this does not return
    148:    an error code. Usually used in the form
    149: $      XXXView(XXX object,PETSC_VIEWER_STDERR_(comm));

    151: .seealso: PETSC_VIEWER_DRAW_, PetscViewerASCIIOpen(), PETSC_VIEWER_STDOUT_, PETSC_VIEWER_STDOUT_WORLD,
    152:           PETSC_VIEWER_STDOUT_SELF, PETSC_VIEWER_STDERR_WORLD, PETSC_VIEWER_STDERR_SELF
    153: @*/
    154: PetscViewer  PETSC_VIEWER_STDERR_(MPI_Comm comm)
    155: {
    157:   PetscViewer    viewer;

    160:   PetscViewerASCIIGetStderr(comm,&viewer);
    161:   if (ierr) {PetscError(PETSC_COMM_SELF,__LINE__,"PETSC_VIEWER_STDERR_",__FILE__,__SDIR__,PETSC_ERR_PLIB,PETSC_ERROR_INITIAL," "); return(0);}
    162:   PetscFunctionReturn(viewer);
    163: }

    166: PetscMPIInt Petsc_Viewer_keyval = MPI_KEYVAL_INVALID;
    169: /*
    170:    Called with MPI_Comm_free() is called on a communicator that has a viewer as an attribute. The viewer is not actually destroyed because that is managed by
    171:    PetscObjectDestroyRegisterAll(). PetscViewerASCIIGetStdout() registers the viewer with PetscObjectDestroyRegister() to be destroyed when PetscFinalize() is called.

    173:   This is called by MPI, not by users.

    175: */
    176: PETSC_EXTERN PetscMPIInt MPIAPI Petsc_DelViewer(MPI_Comm comm,PetscMPIInt keyval,void *attr_val,void *extra_state)
    177: {

    181:   PetscInfo1(0,"Removing viewer data attribute in an MPI_Comm %ld\n",(long)comm);if (ierr) PetscFunctionReturn((PetscMPIInt)ierr);
    182:   PetscFunctionReturn(MPI_SUCCESS);
    183: }

    187: /*@C
    188:    PetscViewerASCIIOpen - Opens an ASCII file as a PetscViewer.

    190:    Collective on MPI_Comm

    192:    Input Parameters:
    193: +  comm - the communicator
    194: -  name - the file name

    196:    Output Parameter:
    197: .  lab - the PetscViewer to use with the specified file

    199:    Level: beginner

    201:    Notes:
    202:    This PetscViewer can be destroyed with PetscViewerDestroy().

    204:    If a multiprocessor communicator is used (such as PETSC_COMM_WORLD),
    205:    then only the first processor in the group opens the file.  All other
    206:    processors send their data to the first processor to print.

    208:    Each processor can instead write its own independent output by
    209:    specifying the communicator PETSC_COMM_SELF.

    211:    As shown below, PetscViewerASCIIOpen() is useful in conjunction with
    212:    MatView() and VecView()
    213: .vb
    214:      PetscViewerASCIIOpen(PETSC_COMM_WORLD,"mat.output",&viewer);
    215:      MatView(matrix,viewer);
    216: .ve

    218:   Concepts: PetscViewerASCII^creating
    219:   Concepts: printf
    220:   Concepts: printing
    221:   Concepts: accessing remote file
    222:   Concepts: remote file

    224: .seealso: MatView(), VecView(), PetscViewerDestroy(), PetscViewerBinaryOpen(),
    225:           PetscViewerASCIIGetPointer(), PetscViewerSetFormat(), PETSC_VIEWER_STDOUT_, PETSC_VIEWER_STDERR_,
    226:           PETSC_VIEWER_STDOUT_WORLD, PETSC_VIEWER_STDOUT_SELF,
    227: @*/
    228: PetscErrorCode  PetscViewerASCIIOpen(MPI_Comm comm,const char name[],PetscViewer *lab)
    229: {
    230:   PetscErrorCode  ierr;
    231:   PetscViewerLink *vlink,*nv;
    232:   PetscBool       flg,eq;
    233:   size_t          len;

    236:   PetscStrlen(name,&len);
    237:   if (!len) {
    238:     PetscViewerASCIIGetStdout(comm,lab);
    239:     PetscObjectReference((PetscObject)*lab);
    240:     return(0);
    241:   }
    242:   if (Petsc_Viewer_keyval == MPI_KEYVAL_INVALID) {
    243:     MPI_Keyval_create(MPI_NULL_COPY_FN,Petsc_DelViewer,&Petsc_Viewer_keyval,(void*)0);
    244:   }
    245:   /*
    246:        It would be better to move this code to PetscFileSetName() but since it must return a preexiting communicator
    247:      we cannot do that, since PetscFileSetName() takes a communicator that already exists.

    249:       Plus if the original communicator that created the file has since been close this will not detect the old
    250:       communictor and hence will overwrite the old data. It may be better to simply remove all this code
    251:   */
    252:   /* make sure communicator is a PETSc communicator */
    253:   PetscCommDuplicate(comm,&comm,NULL);
    254:   /* has file already been opened into a viewer */
    255:   MPI_Attr_get(comm,Petsc_Viewer_keyval,(void**)&vlink,(PetscMPIInt*)&flg);
    256:   if (flg) {
    257:     while (vlink) {
    258:       PetscStrcmp(name,((PetscViewer_ASCII*)(vlink->viewer->data))->filename,&eq);
    259:       if (eq) {
    260:         PetscObjectReference((PetscObject)vlink->viewer);
    261:         *lab = vlink->viewer;
    262:         PetscCommDestroy(&comm);
    263:         return(0);
    264:       }
    265:       vlink = vlink->next;
    266:     }
    267:   }
    268:   PetscViewerCreate(comm,lab);
    269:   PetscViewerSetType(*lab,PETSCVIEWERASCII);
    270:   if (name) {
    271:     PetscViewerFileSetName(*lab,name);
    272:   }
    273:   /* save viewer into communicator if needed later */
    274:   PetscNew(PetscViewerLink,&nv);
    275:   nv->viewer = *lab;
    276:   if (!flg) {
    277:     MPI_Attr_put(comm,Petsc_Viewer_keyval,nv);
    278:   } else {
    279:     MPI_Attr_get(comm,Petsc_Viewer_keyval,(void**)&vlink,(PetscMPIInt*)&flg);
    280:     if (vlink) {
    281:       while (vlink->next) vlink = vlink->next;
    282:       vlink->next = nv;
    283:     } else {
    284:       MPI_Attr_put(comm,Petsc_Viewer_keyval,nv);
    285:     }
    286:   }
    287:   PetscCommDestroy(&comm);
    288:   return(0);
    289: }

    293: /*@C
    294:    PetscViewerASCIIOpenWithFILE - Given an open file creates an ASCII viewer that prints to it.

    296:    Collective on MPI_Comm

    298:    Input Parameters:
    299: +  comm - the communicator
    300: -  fd - the FILE pointer

    302:    Output Parameter:
    303: .  lab - the PetscViewer to use with the specified file

    305:    Level: beginner

    307:    Notes:
    308:    This PetscViewer can be destroyed with PetscViewerDestroy(), but the fd will NOT be closed.

    310:    If a multiprocessor communicator is used (such as PETSC_COMM_WORLD),
    311:    then only the first processor in the group uses the file.  All other
    312:    processors send their data to the first processor to print.

    314:   Concepts: PetscViewerASCII^creating
    315:   Concepts: printf
    316:   Concepts: printing
    317:   Concepts: accessing remote file
    318:   Concepts: remote file

    320: .seealso: MatView(), VecView(), PetscViewerDestroy(), PetscViewerBinaryOpen(),
    321:           PetscViewerASCIIGetPointer(), PetscViewerSetFormat(), PETSC_VIEWER_STDOUT_, PETSC_VIEWER_STDERR_,
    322:           PETSC_VIEWER_STDOUT_WORLD, PETSC_VIEWER_STDOUT_SELF, PetscViewerASCIIOpen()
    323: @*/
    324: PetscErrorCode  PetscViewerASCIIOpenWithFILE(MPI_Comm comm,FILE *fd,PetscViewer *lab)
    325: {

    329:   PetscViewerCreate(comm,lab);
    330:   PetscViewerSetType(*lab,PETSCVIEWERASCII);
    331:   PetscViewerASCIISetFILE(*lab,fd);
    332:   return(0);
    333: }

    337: PetscErrorCode  PetscViewerASCIISetFILE(PetscViewer viewer,FILE *fd)
    338: {
    339:   PetscViewer_ASCII *vascii = (PetscViewer_ASCII*)viewer->data;

    342:   vascii->fd        = fd;
    343:   vascii->closefile = PETSC_FALSE;
    344:   return(0);
    345: }