Date: 2015-10-02T21:58:11+00:00

Actual source code: filev.c
petsc-3.6.2 2015-10-02
Report Typos and Errors

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

      4: #define QUEUESTRINGSIZE 8192

      8: static PetscErrorCode PetscViewerFileClose_ASCII(PetscViewer viewer)
      9: {
     10:   PetscErrorCode    ierr;
     11:   PetscMPIInt       rank;
     12:   PetscViewer_ASCII *vascii = (PetscViewer_ASCII*)viewer->data;
     13:   int               err;

     16:   MPI_Comm_rank(PetscObjectComm((PetscObject)viewer),&rank);
     17:   if (!rank && vascii->fd != stderr && vascii->fd != PETSC_STDOUT) {
     18:     if (vascii->fd && vascii->closefile) {
     19:       err = fclose(vascii->fd);
     20:       if (err) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_SYS,"fclose() failed on file");
     21:     }
     22:     if (vascii->storecompressed) {
     23:       char par[PETSC_MAX_PATH_LEN],buf[PETSC_MAX_PATH_LEN];
     24:       FILE *fp;
     25:       PetscStrcpy(par,"gzip ");
     26:       PetscStrcat(par,vascii->filename);
     27: #if defined(PETSC_HAVE_POPEN)
     28:       PetscPOpen(PETSC_COMM_SELF,NULL,par,"r",&fp);
     29:       if (fgets(buf,1024,fp)) SETERRQ2(PETSC_COMM_SELF,PETSC_ERR_LIB,"Error from compression command %s\n%s",par,buf);
     30:       PetscPClose(PETSC_COMM_SELF,fp,NULL);
     31: #else
     32:       SETERRQ(PETSC_COMM_SELF,PETSC_ERR_SUP_SYS,"Cannot run external programs on this machine");
     33: #endif
     34:     }
     35:   }
     36:   PetscFree(vascii->filename);
     37:   return(0);
     38: }

     40: /* ----------------------------------------------------------------------*/
     43: PetscErrorCode PetscViewerDestroy_ASCII(PetscViewer viewer)
     44: {
     45:   PetscErrorCode    ierr;
     46:   PetscViewer_ASCII *vascii = (PetscViewer_ASCII*)viewer->data;
     47:   PetscViewerLink   *vlink;
     48:   PetscBool         flg;

     51:   if (vascii->sviewer) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ORDER,"ASCII PetscViewer destroyed before restoring singleton or subcomm PetscViewer");
     52:   PetscViewerFileClose_ASCII(viewer);
     53:   PetscFree(vascii);

     55:   /* remove the viewer from the list in the MPI Communicator */
     56:   if (Petsc_Viewer_keyval == MPI_KEYVAL_INVALID) {
     57:     MPI_Keyval_create(MPI_NULL_COPY_FN,Petsc_DelViewer,&Petsc_Viewer_keyval,(void*)0);
     58:   }

     60:   MPI_Attr_get(PetscObjectComm((PetscObject)viewer),Petsc_Viewer_keyval,(void**)&vlink,(PetscMPIInt*)&flg);
     61:   if (flg) {
     62:     if (vlink && vlink->viewer == viewer) {
     63:       if (vlink->next) {
     64:         MPI_Attr_put(PetscObjectComm((PetscObject)viewer),Petsc_Viewer_keyval,vlink->next);
     65:       } else {
     66:         MPI_Attr_delete(PetscObjectComm((PetscObject)viewer),Petsc_Viewer_keyval);
     67:       }
     68:       PetscFree(vlink);
     69:     } else {
     70:       while (vlink && vlink->next) {
     71:         if (vlink->next->viewer == viewer) {
     72:           PetscViewerLink *nv = vlink->next;
     73:           vlink->next = vlink->next->next;
     74:           PetscFree(nv);
     75:         }
     76:         vlink = vlink->next;
     77:       }
     78:     }
     79:   }
     80:   return(0);
     81: }

     85: PetscErrorCode PetscViewerDestroy_ASCII_Singleton(PetscViewer viewer)
     86: {
     87:   PetscViewer_ASCII *vascii = (PetscViewer_ASCII*)viewer->data;
     88:   PetscErrorCode    ierr;

     91:   PetscViewerRestoreSingleton(vascii->bviewer,&viewer);
     92:   vascii->bviewer = NULL;
     93:   return(0);
     94: }

     98: PetscErrorCode PetscViewerDestroy_ASCII_Subcomm(PetscViewer viewer)
     99: {
    100:   PetscViewer_ASCII *vascii = (PetscViewer_ASCII*)viewer->data;
    101:   PetscErrorCode    ierr;

    104:   PetscViewerRestoreSubcomm(vascii->subviewer,PetscObjectComm((PetscObject)viewer),&viewer);
    105:   vascii->subviewer = NULL;
    106:   return(0);
    107: }

    111: PetscErrorCode PetscViewerFlush_ASCII_Singleton_0(PetscViewer viewer)
    112: {
    113:   PetscViewer_ASCII *vascii = (PetscViewer_ASCII*)viewer->data;
    114:   int               err;

    117:   err = fflush(vascii->fd);
    118:   if (err) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_SYS,"fflush() failed on file");
    119:   return(0);
    120: }

    124: PetscErrorCode PetscViewerFlush_ASCII(PetscViewer viewer)
    125: {
    126:   PetscMPIInt       rank;
    127:   PetscErrorCode    ierr;
    128:   PetscViewer_ASCII *vascii = (PetscViewer_ASCII*)viewer->data;
    129:   int               err;

    132:   MPI_Comm_rank(PetscObjectComm((PetscObject)viewer),&rank);
    133:   /* fflush() fails on OSX for read-only descriptors */
    134:   if (!rank && (vascii->mode != FILE_MODE_READ)) {
    135:     err = fflush(vascii->fd);
    136:     if (err) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_SYS,"fflush() call failed");
    137:   }

    139:   if (vascii->allowsynchronized) {
    140:     /* Also flush anything printed with PetscViewerASCIISynchronizedPrintf()  */
    141:     PetscSynchronizedFlush(PetscObjectComm((PetscObject)viewer),vascii->fd);
    142:   }
    143:   return(0);
    144: }

    148: /*@C
    149:     PetscViewerASCIIGetPointer - Extracts the file pointer from an ASCII PetscViewer.

    151:     Not Collective

    153: +   viewer - PetscViewer context, obtained from PetscViewerASCIIOpen()
    154: -   fd - file pointer

    156:     Level: intermediate

    158:     Fortran Note:
    159:     This routine is not supported in Fortran.

    161:   Concepts: PetscViewer^file pointer
    162:   Concepts: file pointer^getting from PetscViewer

    164: .seealso: PetscViewerASCIIOpen(), PetscViewerDestroy(), PetscViewerSetType(), PetscViewerCreate(), PetscViewerASCIIPrintf(),
    165:           PetscViewerASCIISynchronizedPrintf(), PetscViewerFlush()
    166: @*/
    167: PetscErrorCode  PetscViewerASCIIGetPointer(PetscViewer viewer,FILE **fd)
    168: {
    169:   PetscViewer_ASCII *vascii = (PetscViewer_ASCII*)viewer->data;

    172:   *fd = vascii->fd;
    173:   return(0);
    174: }

    178: PetscErrorCode  PetscViewerFileGetMode_ASCII(PetscViewer viewer, PetscFileMode *mode)
    179: {
    180:   PetscViewer_ASCII *vascii = (PetscViewer_ASCII*)viewer->data;

    183:   *mode = vascii->mode;
    184:   return(0);
    185: }

    189: PetscErrorCode  PetscViewerFileSetMode_ASCII(PetscViewer viewer, PetscFileMode mode)
    190: {
    191:   PetscViewer_ASCII *vascii = (PetscViewer_ASCII*)viewer->data;

    194:   vascii->mode = mode;
    195:   return(0);
    196: }

    198: /*
    199:    If petsc_history is on, then all Petsc*Printf() results are saved
    200:    if the appropriate (usually .petschistory) file.
    201: */
    202: extern FILE *petsc_history;

    206: /*@
    207:     PetscViewerASCIISetTab - Causes PetscViewer to tab in a number of times

    209:     Not Collective, but only first processor in set has any effect

    211:     Input Parameters:
    212: +    viewer - optained with PetscViewerASCIIOpen()
    213: -    tabs - number of tabs

    215:     Level: developer

    217:     Fortran Note:
    218:     This routine is not supported in Fortran.

    220:   Concepts: PetscViewerASCII^formating
    221:   Concepts: tab^setting

    223: .seealso: PetscPrintf(), PetscSynchronizedPrintf(), PetscViewerASCIIPrintf(), PetscViewerASCIIGetTab(),
    224:           PetscViewerASCIIPopTab(), PetscViewerASCIISynchronizedPrintf(), PetscViewerASCIIOpen(),
    225:           PetscViewerCreate(), PetscViewerDestroy(), PetscViewerSetType(), PetscViewerASCIIGetPointer(), PetscViewerASCIIPushTab()
    226: @*/
    227: PetscErrorCode  PetscViewerASCIISetTab(PetscViewer viewer,PetscInt tabs)
    228: {
    229:   PetscViewer_ASCII *ascii = (PetscViewer_ASCII*)viewer->data;
    230:   PetscBool         iascii;
    231:   PetscErrorCode    ierr;

    235:   PetscObjectTypeCompare((PetscObject)viewer,PETSCVIEWERASCII,&iascii);
    236:   if (iascii) ascii->tab = tabs;
    237:   return(0);
    238: }

    242: /*@
    243:     PetscViewerASCIIGetTab - Return the number of tabs used by PetscViewer.

    245:     Not Collective, meaningful on first processor only.

    247:     Input Parameters:
    248: .    viewer - optained with PetscViewerASCIIOpen()
    249:     Output Parameters:
    250: .    tabs - number of tabs

    252:     Level: developer

    254:     Fortran Note:
    255:     This routine is not supported in Fortran.

    257:   Concepts: PetscViewerASCII^formating
    258:   Concepts: tab^retrieval

    260: .seealso: PetscPrintf(), PetscSynchronizedPrintf(), PetscViewerASCIIPrintf(), PetscViewerASCIISetTab(),
    261:           PetscViewerASCIIPopTab(), PetscViewerASCIISynchronizedPrintf(), PetscViewerASCIIOpen(),
    262:           PetscViewerCreate(), PetscViewerDestroy(), PetscViewerSetType(), PetscViewerASCIIGetPointer(), PetscViewerASCIIPushTab()
    263: @*/
    264: PetscErrorCode  PetscViewerASCIIGetTab(PetscViewer viewer,PetscInt *tabs)
    265: {
    266:   PetscViewer_ASCII *ascii = (PetscViewer_ASCII*)viewer->data;
    267:   PetscBool         iascii;
    268:   PetscErrorCode    ierr;

    272:   PetscObjectTypeCompare((PetscObject)viewer,PETSCVIEWERASCII,&iascii);
    273:   if (iascii && tabs) *tabs = ascii->tab;
    274:   return(0);
    275: }

    279: /*@
    280:     PetscViewerASCIIAddTab - Add to the number of times an ASCII viewer tabs before printing

    282:     Not Collective, but only first processor in set has any effect

    284:     Input Parameters:
    285: +    viewer - optained with PetscViewerASCIIOpen()
    286: -    tabs - number of tabs

    288:     Level: developer

    290:     Fortran Note:
    291:     This routine is not supported in Fortran.

    293:   Concepts: PetscViewerASCII^formating
    294:   Concepts: tab^setting

    296: .seealso: PetscPrintf(), PetscSynchronizedPrintf(), PetscViewerASCIIPrintf(),
    297:           PetscViewerASCIIPopTab(), PetscViewerASCIISynchronizedPrintf(), PetscViewerASCIIOpen(),
    298:           PetscViewerCreate(), PetscViewerDestroy(), PetscViewerSetType(), PetscViewerASCIIGetPointer(), PetscViewerASCIIPushTab()
    299: @*/
    300: PetscErrorCode  PetscViewerASCIIAddTab(PetscViewer viewer,PetscInt tabs)
    301: {
    302:   PetscViewer_ASCII *ascii = (PetscViewer_ASCII*)viewer->data;
    303:   PetscBool         iascii;
    304:   PetscErrorCode    ierr;

    308:   PetscObjectTypeCompare((PetscObject)viewer,PETSCVIEWERASCII,&iascii);
    309:   if (iascii) ascii->tab += tabs;
    310:   return(0);
    311: }

    315: /*@
    316:     PetscViewerASCIISubtractTab - Subtracts from the number of times an ASCII viewer tabs before printing

    318:     Not Collective, but only first processor in set has any effect

    320:     Input Parameters:
    321: +    viewer - optained with PetscViewerASCIIOpen()
    322: -    tabs - number of tabs

    324:     Level: developer

    326:     Fortran Note:
    327:     This routine is not supported in Fortran.

    329:   Concepts: PetscViewerASCII^formating
    330:   Concepts: tab^setting

    332: .seealso: PetscPrintf(), PetscSynchronizedPrintf(), PetscViewerASCIIPrintf(),
    333:           PetscViewerASCIIPopTab(), PetscViewerASCIISynchronizedPrintf(), PetscViewerASCIIOpen(),
    334:           PetscViewerCreate(), PetscViewerDestroy(), PetscViewerSetType(), PetscViewerASCIIGetPointer(), PetscViewerASCIIPushTab()
    335: @*/
    336: PetscErrorCode  PetscViewerASCIISubtractTab(PetscViewer viewer,PetscInt tabs)
    337: {
    338:   PetscViewer_ASCII *ascii = (PetscViewer_ASCII*)viewer->data;
    339:   PetscBool         iascii;
    340:   PetscErrorCode    ierr;

    344:   PetscObjectTypeCompare((PetscObject)viewer,PETSCVIEWERASCII,&iascii);
    345:   if (iascii) ascii->tab -= tabs;
    346:   return(0);
    347: }

    351: /*@C
    352:     PetscViewerASCIISynchronizedAllow - Allows calls to PetscViewerASCIISynchronizedPrintf() for this viewer

    354:     Collective on PetscViewer

    356:     Input Parameters:
    357: +    viewer - optained with PetscViewerASCIIOpen()
    358: -    allow - PETSC_TRUE to allow the synchronized printing

    360:     Level: intermediate

    362:   Concepts: PetscViewerASCII^formating
    363:   Concepts: tab^setting

    365: .seealso: PetscPrintf(), PetscSynchronizedPrintf(), PetscViewerASCIIPrintf(),
    366:           PetscViewerASCIIPopTab(), PetscViewerASCIISynchronizedPrintf(), PetscViewerASCIIOpen(),
    367:           PetscViewerCreate(), PetscViewerDestroy(), PetscViewerSetType(), PetscViewerASCIIGetPointer()
    368: @*/
    369: PetscErrorCode  PetscViewerASCIISynchronizedAllow(PetscViewer viewer,PetscBool allow)
    370: {
    371:   PetscViewer_ASCII *ascii = (PetscViewer_ASCII*)viewer->data;
    372:   PetscBool         iascii;
    373:   PetscErrorCode    ierr;

    377:   PetscObjectTypeCompare((PetscObject)viewer,PETSCVIEWERASCII,&iascii);
    378:   if (iascii) ascii->allowsynchronized = allow;
    379:   return(0);
    380: }

    384: /*@
    385:     PetscViewerASCIIPushTab - Adds one more tab to the amount that PetscViewerASCIIPrintf()
    386:      lines are tabbed.

    388:     Not Collective, but only first processor in set has any effect

    390:     Input Parameters:
    391: .    viewer - optained with PetscViewerASCIIOpen()

    393:     Level: developer

    395:     Fortran Note:
    396:     This routine is not supported in Fortran.

    398:   Concepts: PetscViewerASCII^formating
    399:   Concepts: tab^setting

    401: .seealso: PetscPrintf(), PetscSynchronizedPrintf(), PetscViewerASCIIPrintf(),
    402:           PetscViewerASCIIPopTab(), PetscViewerASCIISynchronizedPrintf(), PetscViewerASCIIOpen(),
    403:           PetscViewerCreate(), PetscViewerDestroy(), PetscViewerSetType(), PetscViewerASCIIGetPointer()
    404: @*/
    405: PetscErrorCode  PetscViewerASCIIPushTab(PetscViewer viewer)
    406: {
    407:   PetscViewer_ASCII *ascii = (PetscViewer_ASCII*)viewer->data;
    408:   PetscBool         iascii;
    409:   PetscErrorCode    ierr;

    413:   PetscObjectTypeCompare((PetscObject)viewer,PETSCVIEWERASCII,&iascii);
    414:   if (iascii) ascii->tab++;
    415:   return(0);
    416: }

    420: /*@
    421:     PetscViewerASCIIPopTab - Removes one tab from the amount that PetscViewerASCIIPrintf()
    422:      lines are tabbed.

    424:     Not Collective, but only first processor in set has any effect

    426:     Input Parameters:
    427: .    viewer - optained with PetscViewerASCIIOpen()

    429:     Level: developer

    431:     Fortran Note:
    432:     This routine is not supported in Fortran.

    434:   Concepts: PetscViewerASCII^formating
    435:   Concepts: tab^setting

    437: .seealso: PetscPrintf(), PetscSynchronizedPrintf(), PetscViewerASCIIPrintf(),
    438:           PetscViewerASCIIPushTab(), PetscViewerASCIISynchronizedPrintf(), PetscViewerASCIIOpen(),
    439:           PetscViewerCreate(), PetscViewerDestroy(), PetscViewerSetType(), PetscViewerASCIIGetPointer()
    440: @*/
    441: PetscErrorCode  PetscViewerASCIIPopTab(PetscViewer viewer)
    442: {
    443:   PetscViewer_ASCII *ascii = (PetscViewer_ASCII*)viewer->data;
    444:   PetscErrorCode    ierr;
    445:   PetscBool         iascii;

    449:   PetscObjectTypeCompare((PetscObject)viewer,PETSCVIEWERASCII,&iascii);
    450:   if (iascii) {
    451:     if (ascii->tab <= 0) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_WRONGSTATE,"More tabs popped than pushed");
    452:     ascii->tab--;
    453:   }
    454:   return(0);
    455: }

    459: /*@
    460:     PetscViewerASCIIUseTabs - Turns on or off the use of tabs with the ASCII PetscViewer

    462:     Not Collective, but only first processor in set has any effect

    464:     Input Parameters:
    465: +    viewer - optained with PetscViewerASCIIOpen()
    466: -    flg - PETSC_TRUE or PETSC_FALSE

    468:     Level: developer

    470:     Fortran Note:
    471:     This routine is not supported in Fortran.

    473:   Concepts: PetscViewerASCII^formating
    474:   Concepts: tab^setting

    476: .seealso: PetscPrintf(), PetscSynchronizedPrintf(), PetscViewerASCIIPrintf(),
    477:           PetscViewerASCIIPopTab(), PetscViewerASCIISynchronizedPrintf(), PetscViewerASCIIPushTab(), PetscViewerASCIIOpen(),
    478:           PetscViewerCreate(), PetscViewerDestroy(), PetscViewerSetType(), PetscViewerASCIIGetPointer()
    479: @*/
    480: PetscErrorCode  PetscViewerASCIIUseTabs(PetscViewer viewer,PetscBool flg)
    481: {
    482:   PetscViewer_ASCII *ascii = (PetscViewer_ASCII*)viewer->data;
    483:   PetscBool         iascii;
    484:   PetscErrorCode    ierr;

    488:   PetscObjectTypeCompare((PetscObject)viewer,PETSCVIEWERASCII,&iascii);
    489:   if (iascii) {
    490:     if (flg) ascii->tab = ascii->tab_store;
    491:     else {
    492:       ascii->tab_store = ascii->tab;
    493:       ascii->tab       = 0;
    494:     }
    495:   }
    496:   return(0);
    497: }

    499: /* ----------------------------------------------------------------------- */

    501: #include <../src/sys/fileio/mprint.h> /* defines the queue datastructures and variables */

    505: /*@C
    506:     PetscViewerASCIIPrintf - Prints to a file, only from the first
    507:     processor in the PetscViewer

    509:     Not Collective, but only first processor in set has any effect

    511:     Input Parameters:
    512: +    viewer - optained with PetscViewerASCIIOpen()
    513: -    format - the usual printf() format string

    515:     Level: developer

    517:     Fortran Note:
    518:     The call sequence is PetscViewerASCIIPrintf(PetscViewer, character(*), int ierr) from Fortran.
    519:     That is, you can only pass a single character string from Fortran.

    521:   Concepts: PetscViewerASCII^printing
    522:   Concepts: printing^to file
    523:   Concepts: printf

    525: .seealso: PetscPrintf(), PetscSynchronizedPrintf(), PetscViewerASCIIOpen(),
    526:           PetscViewerASCIIPushTab(), PetscViewerASCIIPopTab(), PetscViewerASCIISynchronizedPrintf(),
    527:           PetscViewerCreate(), PetscViewerDestroy(), PetscViewerSetType(), PetscViewerASCIIGetPointer(), PetscViewerASCIISynchronizedAllow()
    528: @*/
    529: PetscErrorCode  PetscViewerASCIIPrintf(PetscViewer viewer,const char format[],...)
    530: {
    531:   PetscViewer_ASCII *ascii = (PetscViewer_ASCII*)viewer->data;
    532:   PetscMPIInt       rank;
    533:   PetscInt          tab,intab = ascii->tab;
    534:   PetscErrorCode    ierr;
    535:   FILE              *fd = ascii->fd;
    536:   PetscBool         iascii,issingleton = PETSC_FALSE;
    537:   int               err;

    542:   PetscObjectTypeCompare((PetscObject)viewer,PETSCVIEWERASCII,&iascii);
    543:   if (!iascii) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_WRONG,"Not ASCII PetscViewer");
    544:   if (ascii->bviewer) {
    545:     viewer      = ascii->bviewer;
    546:     ascii       = (PetscViewer_ASCII*)viewer->data;
    547:     fd          = ascii->fd;
    548:     issingleton = PETSC_TRUE;
    549:   }

    551:   MPI_Comm_rank(PetscObjectComm((PetscObject)viewer),&rank);
    552:   if (!rank) {
    553:     va_list Argp;
    554:     tab = intab;
    555:     while (tab--) {
    556:       PetscFPrintf(PETSC_COMM_SELF,fd,"  ");
    557:     }

    559:     va_start(Argp,format);
    560:     (*PetscVFPrintf)(fd,format,Argp);
    561:     err  = fflush(fd);
    562:     if (err) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_SYS,"fflush() failed on file");
    563:     if (petsc_history) {
    564:       va_start(Argp,format);
    565:       tab = intab;
    566:       while (tab--) {
    567:         PetscFPrintf(PETSC_COMM_SELF,petsc_history,"  ");
    568:       }
    569:       (*PetscVFPrintf)(petsc_history,format,Argp);
    570:       err  = fflush(petsc_history);
    571:       if (err) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_SYS,"fflush() failed on file");
    572:     }
    573:     va_end(Argp);
    574:   } else if (issingleton) {
    575:     char        *string;
    576:     va_list     Argp;
    577:     size_t      fullLength;
    578:     PrintfQueue next;

    580:     PetscNew(&next);
    581:     if (petsc_printfqueue) {
    582:       petsc_printfqueue->next = next;
    583:       petsc_printfqueue       = next;
    584:     } else {
    585:       petsc_printfqueuebase = petsc_printfqueue = next;
    586:     }
    587:     petsc_printfqueuelength++;
    588:     next->size = QUEUESTRINGSIZE;
    589:     PetscCalloc1(next->size, &next->string);
    590:     string     = next->string;
    591:     tab        = intab;
    592:     tab       *= 2;
    593:     while (tab--) {
    594:       *string++ = ' ';
    595:     }
    596:     va_start(Argp,format);
    597:     PetscVSNPrintf(string,next->size-2*ascii->tab,format,&fullLength,Argp);
    598:     va_end(Argp);
    599:   }
    600:   return(0);
    601: }

    605: /*@C
    606:      PetscViewerFileSetName - Sets the name of the file the PetscViewer uses.

    608:     Collective on PetscViewer

    610:   Input Parameters:
    611: +  viewer - the PetscViewer; either ASCII or binary
    612: -  name - the name of the file it should use

    614:     Level: advanced

    616: .seealso: PetscViewerCreate(), PetscViewerSetType(), PetscViewerASCIIOpen(), PetscViewerBinaryOpen(), PetscViewerDestroy(),
    617:           PetscViewerASCIIGetPointer(), PetscViewerASCIIPrintf(), PetscViewerASCIISynchronizedPrintf()

    619: @*/
    620: PetscErrorCode  PetscViewerFileSetName(PetscViewer viewer,const char name[])
    621: {

    627:   PetscTryMethod(viewer,"PetscViewerFileSetName_C",(PetscViewer,const char[]),(viewer,name));
    628:   return(0);
    629: }

    633: /*@C
    634:      PetscViewerFileGetName - Gets the name of the file the PetscViewer uses.

    636:     Not Collective

    638:   Input Parameter:
    639: .  viewer - the PetscViewer; either ASCII or binary

    641:   Output Parameter:
    642: .  name - the name of the file it is using

    644:     Level: advanced

    646: .seealso: PetscViewerCreate(), PetscViewerSetType(), PetscViewerASCIIOpen(), PetscViewerBinaryOpen(), PetscViewerFileSetName()

    648: @*/
    649: PetscErrorCode  PetscViewerFileGetName(PetscViewer viewer,const char **name)
    650: {

    655:   PetscTryMethod(viewer,"PetscViewerFileGetName_C",(PetscViewer,const char**),(viewer,name));
    656:   return(0);
    657: }

    661: PetscErrorCode  PetscViewerFileGetName_ASCII(PetscViewer viewer,const char **name)
    662: {
    663:   PetscViewer_ASCII *vascii = (PetscViewer_ASCII*)viewer->data;

    666:   *name = vascii->filename;
    667:   return(0);
    668: }

    672: PetscErrorCode  PetscViewerFileSetName_ASCII(PetscViewer viewer,const char name[])
    673: {
    674:   PetscErrorCode    ierr;
    675:   size_t            len;
    676:   char              fname[PETSC_MAX_PATH_LEN],*gz;
    677:   PetscViewer_ASCII *vascii = (PetscViewer_ASCII*)viewer->data;
    678:   PetscBool         isstderr,isstdout;
    679:   PetscMPIInt       rank;

    682:   PetscViewerFileClose_ASCII(viewer);
    683:   if (!name) return(0);
    684:   PetscStrallocpy(name,&vascii->filename);

    686:   /* Is this file to be compressed */
    687:   vascii->storecompressed = PETSC_FALSE;

    689:   PetscStrstr(vascii->filename,".gz",&gz);
    690:   if (gz) {
    691:     PetscStrlen(gz,&len);
    692:     if (len == 3) {
    693:       *gz = 0;
    694:       vascii->storecompressed = PETSC_TRUE;
    695:     }
    696:   }
    697:   MPI_Comm_rank(PetscObjectComm((PetscObject)viewer),&rank);
    698:   if (!rank) {
    699:     PetscStrcmp(name,"stderr",&isstderr);
    700:     PetscStrcmp(name,"stdout",&isstdout);
    701:     /* empty filename means stdout */
    702:     if (name[0] == 0)  isstdout = PETSC_TRUE;
    703:     if (isstderr)      vascii->fd = PETSC_STDERR;
    704:     else if (isstdout) vascii->fd = PETSC_STDOUT;
    705:     else {

    708:       PetscFixFilename(name,fname);
    709:       switch (vascii->mode) {
    710:       case FILE_MODE_READ:
    711:         vascii->fd = fopen(fname,"r");
    712:         break;
    713:       case FILE_MODE_WRITE:
    714:         vascii->fd = fopen(fname,"w");
    715:         break;
    716:       case FILE_MODE_APPEND:
    717:         vascii->fd = fopen(fname,"a");
    718:         break;
    719:       case FILE_MODE_UPDATE:
    720:         vascii->fd = fopen(fname,"r+");
    721:         if (!vascii->fd) vascii->fd = fopen(fname,"w+");
    722:         break;
    723:       case FILE_MODE_APPEND_UPDATE:
    724:         /* I really want a file which is opened at the end for updating,
    725:            not a+, which opens at the beginning, but makes writes at the end.
    726:         */
    727:         vascii->fd = fopen(fname,"r+");
    728:         if (!vascii->fd) vascii->fd = fopen(fname,"w+");
    729:         else {
    730:           fseek(vascii->fd, 0, SEEK_END);
    731:         }
    732:         break;
    733:       default:
    734:         SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_ARG_WRONG, "Invalid file mode %d", vascii->mode);
    735:       }
    736:       if (!vascii->fd) SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_FILE_OPEN,"Cannot open PetscViewer file: %s",fname);
    737:     }
    738:   }
    739: #if defined(PETSC_USE_LOG)
    740:   PetscLogObjectState((PetscObject)viewer,"File: %s",name);
    741: #endif
    742:   return(0);
    743: }

    747: PetscErrorCode PetscViewerGetSingleton_ASCII(PetscViewer viewer,PetscViewer *outviewer)
    748: {
    749:   PetscMPIInt       rank;
    750:   PetscErrorCode    ierr;
    751:   PetscViewer_ASCII *vascii = (PetscViewer_ASCII*)viewer->data,*ovascii;
    752:   const char        *name;

    755:   if (vascii->sviewer) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ORDER,"Singleton already obtained from PetscViewer and not restored");
    756:   PetscViewerCreate(PETSC_COMM_SELF,outviewer);
    757:   PetscViewerSetType(*outviewer,PETSCVIEWERASCII);
    758:   ovascii      = (PetscViewer_ASCII*)(*outviewer)->data;
    759:   ovascii->fd  = vascii->fd;
    760:   ovascii->tab = vascii->tab;

    762:   vascii->sviewer = *outviewer;

    764:   (*outviewer)->format  = viewer->format;

    766:   PetscObjectGetName((PetscObject)viewer,&name);
    767:   PetscObjectSetName((PetscObject)(*outviewer),name);

    769:   MPI_Comm_rank(PetscObjectComm((PetscObject)viewer),&rank);
    770:   ((PetscViewer_ASCII*)((*outviewer)->data))->bviewer = viewer;
    771:   (*outviewer)->ops->destroy = PetscViewerDestroy_ASCII_Singleton;
    772:   if (rank) (*outviewer)->ops->flush = 0;
    773:   else      (*outviewer)->ops->flush = PetscViewerFlush_ASCII_Singleton_0;
    774:   return(0);
    775: }

    779: PetscErrorCode PetscViewerRestoreSingleton_ASCII(PetscViewer viewer,PetscViewer *outviewer)
    780: {
    781:   PetscErrorCode    ierr;
    782:   PetscViewer_ASCII *vascii = (PetscViewer_ASCII*)(*outviewer)->data;
    783:   PetscViewer_ASCII *ascii  = (PetscViewer_ASCII*)viewer->data;

    786:   if (!ascii->sviewer) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ORDER,"Singleton never obtained from PetscViewer");
    787:   if (ascii->sviewer != *outviewer) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_WRONG,"This PetscViewer did not generate singleton");

    789:   ascii->sviewer             = 0;
    790:   vascii->fd                 = PETSC_STDOUT;
    791:   (*outviewer)->ops->destroy = PetscViewerDestroy_ASCII;
    792:   PetscViewerDestroy(outviewer);
    793:   PetscViewerFlush(viewer);
    794:   return(0);
    795: }

    799: PetscErrorCode PetscViewerGetSubcomm_ASCII(PetscViewer viewer,MPI_Comm subcomm,PetscViewer *outviewer)
    800: {
    801:   PetscErrorCode    ierr;
    802:   PetscViewer_ASCII *vascii = (PetscViewer_ASCII*)viewer->data,*ovascii;
    803:   const char        *name;

    806:   if (vascii->sviewer) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ORDER,"Subcomm viewer already obtained from PetscViewer and not restored");
    807:   /* Note that we need to open vascii->filename for the subcomm:
    808:      we can't count on reusing viewer's fd since the root in comm and subcomm may differ.
    809:      Further, if the subcomm happens to be the same as comm, PetscViewerASCIIOpen() will
    810:      will return the current viewer, having increfed it.
    811:    */
    812:   PetscViewerASCIIOpen(subcomm,vascii->filename, outviewer);
    813:   if (*outviewer == viewer) return(0);
    814:   ovascii = (PetscViewer_ASCII*)(*outviewer)->data;

    816:   ovascii->tab    = vascii->tab;
    817:   vascii->sviewer = *outviewer;

    819:   (*outviewer)->format  = viewer->format;

    821:   PetscObjectGetName((PetscObject)viewer,&name);
    822:   PetscObjectSetName((PetscObject)(*outviewer),name);

    824:   ((PetscViewer_ASCII*)((*outviewer)->data))->subviewer = viewer;

    826:   (*outviewer)->ops->destroy = PetscViewerDestroy_ASCII_Subcomm;
    827:   return(0);
    828: }

    832: PetscErrorCode PetscViewerRestoreSubcomm_ASCII(PetscViewer viewer,MPI_Comm subcomm,PetscViewer *outviewer)
    833: {
    834:   PetscErrorCode    ierr;
    835:   PetscViewer_ASCII *oascii = (PetscViewer_ASCII*)(*outviewer)->data;
    836:   PetscViewer_ASCII *ascii  = (PetscViewer_ASCII*)viewer->data;

    839:   if (!ascii->sviewer) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ORDER,"Subcomm never obtained from PetscViewer");
    840:   if (ascii->sviewer != *outviewer) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_WRONG,"The given PetscViewer did not generate this subcomm viewer");

    842:   ascii->sviewer             = 0;
    843:   oascii->fd                 = PETSC_STDOUT;
    844:   (*outviewer)->ops->destroy = PetscViewerDestroy_ASCII;

    846:   PetscViewerDestroy(outviewer);
    847:   PetscViewerFlush(viewer);
    848:   return(0);
    849: }

    853: PetscErrorCode  PetscViewerView_ASCII(PetscViewer v,PetscViewer viewer)
    854: {
    855:   PetscErrorCode    ierr;
    856:   PetscViewer_ASCII *ascii = (PetscViewer_ASCII*)v->data;

    859:   if (ascii->filename) {
    860:     PetscViewerASCIIPrintf(viewer,"Filename: %s\n",ascii->filename);
    861:   }
    862:   return(0);
    863: }

    867: PETSC_EXTERN PetscErrorCode PetscViewerCreate_ASCII(PetscViewer viewer)
    868: {
    869:   PetscViewer_ASCII *vascii;
    870:   PetscErrorCode    ierr;

    873:   PetscNewLog(viewer,&vascii);
    874:   viewer->data = (void*)vascii;

    876:   viewer->ops->destroy          = PetscViewerDestroy_ASCII;
    877:   viewer->ops->flush            = PetscViewerFlush_ASCII;
    878:   viewer->ops->getsingleton     = PetscViewerGetSingleton_ASCII;
    879:   viewer->ops->restoresingleton = PetscViewerRestoreSingleton_ASCII;
    880:   viewer->ops->getsubcomm       = PetscViewerGetSubcomm_ASCII;
    881:   viewer->ops->restoresubcomm   = PetscViewerRestoreSubcomm_ASCII;
    882:   viewer->ops->view             = PetscViewerView_ASCII;
    883:   viewer->ops->read             = PetscViewerASCIIRead;

    885:   /* defaults to stdout unless set with PetscViewerFileSetName() */
    886:   vascii->fd        = PETSC_STDOUT;
    887:   vascii->mode      = FILE_MODE_WRITE;
    888:   vascii->bviewer   = 0;
    889:   vascii->subviewer = 0;
    890:   vascii->sviewer   = 0;
    891:   vascii->tab       = 0;
    892:   vascii->tab_store = 0;
    893:   vascii->filename  = 0;
    894:   vascii->closefile = PETSC_TRUE;

    896:   PetscObjectComposeFunction((PetscObject)viewer,"PetscViewerFileSetName_C",PetscViewerFileSetName_ASCII);
    897:   PetscObjectComposeFunction((PetscObject)viewer,"PetscViewerFileGetName_C",PetscViewerFileGetName_ASCII);
    898:   PetscObjectComposeFunction((PetscObject)viewer,"PetscViewerFileGetMode_C",PetscViewerFileGetMode_ASCII);
    899:   PetscObjectComposeFunction((PetscObject)viewer,"PetscViewerFileSetMode_C",PetscViewerFileSetMode_ASCII);
    900:   return(0);
    901: }

    906: /*@C
    907:     PetscViewerASCIISynchronizedPrintf - Prints synchronized output to the specified file from
    908:     several processors.  Output of the first processor is followed by that of the
    909:     second, etc.

    911:     Not Collective, must call collective PetscViewerFlush() to get the results out

    913:     Input Parameters:
    914: +   viewer - the ASCII PetscViewer
    915: -   format - the usual printf() format string

    917:     Level: intermediate

    919:     Notes: You must have previously called PetscViewerASCIISynchronizeAllow() to allow this routine to be called.

    921:     Fortran Note:
    922:       Can only print a single character* string

    924: .seealso: PetscSynchronizedPrintf(), PetscSynchronizedFlush(), PetscFPrintf(),
    925:           PetscFOpen(), PetscViewerFlush(), PetscViewerASCIIGetPointer(), PetscViewerDestroy(), PetscViewerASCIIOpen(),
    926:           PetscViewerASCIIPrintf(), PetscViewerASCIISynchronizedAllow()

    928: @*/
    929: PetscErrorCode  PetscViewerASCIISynchronizedPrintf(PetscViewer viewer,const char format[],...)
    930: {
    931:   PetscViewer_ASCII *vascii = (PetscViewer_ASCII*)viewer->data;
    932:   PetscErrorCode    ierr;
    933:   PetscMPIInt       rank,size;
    934:   PetscInt          tab = vascii->tab;
    935:   MPI_Comm          comm;
    936:   FILE              *fp;
    937:   PetscBool         iascii;
    938:   int               err;

    943:   PetscObjectTypeCompare((PetscObject)viewer,PETSCVIEWERASCII,&iascii);
    944:   if (!iascii) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_WRONG,"Not ASCII PetscViewer");
    945:   MPI_Comm_size(PetscObjectComm((PetscObject)viewer),&size);
    946:   if (size > 1 && !vascii->allowsynchronized) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_WRONGSTATE,"First call PetscViewerASCIISynchronizedAllow() to allow this call");
    947:   if (!viewer->ops->flush) return(0); /* This viewer obtained via PetscViewerGetSubcomm_ASCII(), should not participate. */

    949:   PetscObjectGetComm((PetscObject)viewer,&comm);
    950:   fp   = vascii->fd;
    951:   MPI_Comm_rank(comm,&rank);

    953:   /* First processor prints immediately to fp */
    954:   if (!rank) {
    955:     va_list Argp;

    957:     while (tab--) {
    958:       PetscFPrintf(PETSC_COMM_SELF,fp,"  ");
    959:     }

    961:     va_start(Argp,format);
    962:     (*PetscVFPrintf)(fp,format,Argp);
    963:     err  = fflush(fp);
    964:     if (err) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_SYS,"fflush() failed on file");
    965:     if (petsc_history) {
    966:       va_start(Argp,format);
    967:       (*PetscVFPrintf)(petsc_history,format,Argp);
    968:       err  = fflush(petsc_history);
    969:       if (err) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_SYS,"fflush() failed on file");
    970:     }
    971:     va_end(Argp);
    972:   } else { /* other processors add to local queue */
    973:     char        *string;
    974:     va_list     Argp;
    975:     size_t      fullLength;
    976:     PrintfQueue next;

    978:     PetscNew(&next);
    979:     if (petsc_printfqueue) {
    980:       petsc_printfqueue->next = next;
    981:       petsc_printfqueue       = next;
    982:     } else {
    983:       petsc_printfqueuebase = petsc_printfqueue = next;
    984:     }
    985:     petsc_printfqueuelength++;
    986:     next->size = QUEUESTRINGSIZE;
    987:     PetscMalloc1(next->size, &next->string);
    988:     PetscMemzero(next->string,next->size);
    989:     string     = next->string;
    990:     tab       *= 2;
    991:     while (tab--) {
    992:       *string++ = ' ';
    993:     }
    994:     va_start(Argp,format);
    995:     PetscVSNPrintf(string,next->size-2*vascii->tab,format,&fullLength,Argp);
    996:     va_end(Argp);
    997:   }
    998:   return(0);
    999: }

    1003: /*@C
    1004:    PetscViewerASCIIRead - Reads from am ASCII file

    1006:    Collective on MPI_Comm

    1008:    Input Parameters:
    1009: +  viewer - the ascii viewer
    1010: .  data - location to write the data
    1011: .  num - number of items of data to read
    1012: -  datatype - type of data to read

    1014:    Output Parameters:
    1015: .  count - number of items of data actually read, or NULL

    1017:    Level: beginner

    1019:    Concepts: ascii files

    1021: .seealso: PetscViewerASCIIOpen(), PetscViewerSetFormat(), PetscViewerDestroy(),
    1022:           VecView(), MatView(), VecLoad(), MatLoad(), PetscViewerBinaryGetDescriptor(),
    1023:           PetscViewerBinaryGetInfoPointer(), PetscFileMode, PetscViewer, PetscBinaryViewerRead()
    1024: @*/
    1025: PetscErrorCode PetscViewerASCIIRead(PetscViewer viewer,void *data,PetscInt num,PetscInt *count,PetscDataType dtype)
    1026: {
    1027:   PetscViewer_ASCII *vascii = (PetscViewer_ASCII*)viewer->data;
    1028:   FILE              *fd = vascii->fd;
    1029:   PetscInt           i;
    1030:   int                ret = 0;

    1034:   for (i=0; i<num; i++) {
    1035:     if (dtype == PETSC_CHAR)         ret = fscanf(fd, "%c",  &(((char*)data)[i]));
    1036:     else if (dtype == PETSC_STRING)  ret = fscanf(fd, "%s",  &(((char*)data)[i]));
    1037: #if PETSC_USE_64BIT_INDICES
    1038: #if (PETSC_SIZEOF_LONG_LONG == 8)
    1039:     else if (dtype == PETSC_INT)     ret = fscanf(fd, "%ld",  &(((PetscInt*)data)[i]));
    1040: #else
    1041:     else if (dtype == PETSC_INT)     ret = fscanf(fd, "%lld",  &(((PetscInt*)data)[i]));
    1042: #endif
    1043: #else
    1044:     else if (dtype == PETSC_INT)     ret = fscanf(fd, "%d",  &(((PetscInt*)data)[i]));
    1045: #endif
    1046:     else if (dtype == PETSC_ENUM)    ret = fscanf(fd, "%d",  &(((int*)data)[i]));
    1047:     else if (dtype == PETSC_FLOAT)   ret = fscanf(fd, "%f",  &(((float*)data)[i]));
    1048:     else if (dtype == PETSC_DOUBLE)  ret = fscanf(fd, "%lg", &(((double*)data)[i]));
    1049:     else {SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_ARG_WRONG,"Data type %d not supported", (int) dtype);}
    1050:     if (!ret) SETERRQ1(PETSC_COMM_SELF, PETSC_ERR_ARG_WRONG, "Conversion error for data type %d", (int) dtype);
    1051:     else if (ret < 0) break; /* Proxy for EOF, need to check for it in configure */
    1052:   }
    1053:   if (count) *count = i;
    1054:   else if (ret < 0) SETERRQ2(PETSC_COMM_SELF, PETSC_ERR_ARG_WRONG, "Insufficient data, read only %D < %D items", i, num);
    1055:   return(0);
    1056: }