Date: 2016-09-29T11:12:10+00:00

Actual source code: svdmon.c
slepc-3.7.3 2016-09-29
Report Typos and Errors

      1: /*
      2:       SVD routines related to monitors.

      4:    - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
      5:    SLEPc - Scalable Library for Eigenvalue Problem Computations
      6:    Copyright (c) 2002-2016, Universitat Politecnica de Valencia, Spain

      8:    This file is part of SLEPc.

     10:    SLEPc is free software: you can redistribute it and/or modify it under  the
     11:    terms of version 3 of the GNU Lesser General Public License as published by
     12:    the Free Software Foundation.

     14:    SLEPc  is  distributed in the hope that it will be useful, but WITHOUT  ANY
     15:    WARRANTY;  without even the implied warranty of MERCHANTABILITY or  FITNESS
     16:    FOR  A  PARTICULAR PURPOSE. See the GNU Lesser General Public  License  for
     17:    more details.

     19:    You  should have received a copy of the GNU Lesser General  Public  License
     20:    along with SLEPc. If not, see <http://www.gnu.org/licenses/>.
     21:    - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
     22: */

     24: #include <slepc/private/svdimpl.h>   /*I "slepcsvd.h" I*/
     25: #include <petscdraw.h>

     29: /*
     30:    Runs the user provided monitor routines, if any.
     31: */
     32: PetscErrorCode SVDMonitor(SVD svd,PetscInt it,PetscInt nconv,PetscReal *sigma,PetscReal *errest,PetscInt nest)
     33: {
     35:   PetscInt       i,n = svd->numbermonitors;

     38:   for (i=0;i<n;i++) {
     39:     (*svd->monitor[i])(svd,it,nconv,sigma,errest,nest,svd->monitorcontext[i]);
     40:   }
     41:   return(0);
     42: }

     46: /*@C
     47:    SVDMonitorSet - Sets an ADDITIONAL function to be called at every
     48:    iteration to monitor the error estimates for each requested singular triplet.

     50:    Collective on SVD

     52:    Input Parameters:
     53: +  svd     - singular value solver context obtained from SVDCreate()
     54: .  monitor - pointer to function (if this is NULL, it turns off monitoring)
     55: -  mctx    - [optional] context for private data for the
     56:              monitor routine (use NULL if no context is desired)

     58:    Calling Sequence of monitor:
     59: $   monitor(SVD svd,PetscInt its,PetscInt nconv,PetscReal *sigma,PetscReal *errest,PetscInt nest,void *mctx)

     61: +  svd    - singular value solver context obtained from SVDCreate()
     62: .  its    - iteration number
     63: .  nconv  - number of converged singular triplets
     64: .  sigma  - singular values
     65: .  errest - relative error estimates for each singular triplet
     66: .  nest   - number of error estimates
     67: -  mctx   - optional monitoring context, as set by SVDMonitorSet()

     69:    Options Database Keys:
     70: +    -svd_monitor        - print only the first error estimate
     71: .    -svd_monitor_all    - print error estimates at each iteration
     72: .    -svd_monitor_conv   - print the singular value approximations only when
     73:       convergence has been reached
     74: .    -svd_monitor_lg     - sets line graph monitor for the first unconverged
     75:       approximate singular value
     76: .    -svd_monitor_lg_all - sets line graph monitor for all unconverged
     77:       approximate singular values
     78: -    -svd_monitor_cancel - cancels all monitors that have been hardwired into
     79:       a code by calls to SVDMonitorSet(), but does not cancel those set via
     80:       the options database.

     82:    Notes:
     83:    Several different monitoring routines may be set by calling
     84:    SVDMonitorSet() multiple times; all will be called in the
     85:    order in which they were set.

     87:    Level: intermediate

     89: .seealso: SVDMonitorFirst(), SVDMonitorAll(), SVDMonitorCancel()
     90: @*/
     91: PetscErrorCode SVDMonitorSet(SVD svd,PetscErrorCode (*monitor)(SVD,PetscInt,PetscInt,PetscReal*,PetscReal*,PetscInt,void*),void *mctx,PetscErrorCode (*monitordestroy)(void**))
     92: {
     95:   if (svd->numbermonitors >= MAXSVDMONITORS) SETERRQ(PetscObjectComm((PetscObject)svd),PETSC_ERR_ARG_OUTOFRANGE,"Too many SVD monitors set");
     96:   svd->monitor[svd->numbermonitors]           = monitor;
     97:   svd->monitorcontext[svd->numbermonitors]    = (void*)mctx;
     98:   svd->monitordestroy[svd->numbermonitors++]  = monitordestroy;
     99:   return(0);
    100: }

    104: /*@
    105:    SVDMonitorCancel - Clears all monitors for an SVD object.

    107:    Collective on SVD

    109:    Input Parameters:
    110: .  svd - singular value solver context obtained from SVDCreate()

    112:    Options Database Key:
    113: .    -svd_monitor_cancel - Cancels all monitors that have been hardwired
    114:       into a code by calls to SVDMonitorSet(),
    115:       but does not cancel those set via the options database.

    117:    Level: intermediate

    119: .seealso: SVDMonitorSet()
    120: @*/
    121: PetscErrorCode SVDMonitorCancel(SVD svd)
    122: {
    124:   PetscInt       i;

    128:   for (i=0; i<svd->numbermonitors; i++) {
    129:     if (svd->monitordestroy[i]) {
    130:       (*svd->monitordestroy[i])(&svd->monitorcontext[i]);
    131:     }
    132:   }
    133:   svd->numbermonitors = 0;
    134:   return(0);
    135: }

    139: /*@C
    140:    SVDGetMonitorContext - Gets the monitor context, as set by
    141:    SVDMonitorSet() for the FIRST monitor only.

    143:    Not Collective

    145:    Input Parameter:
    146: .  svd - singular value solver context obtained from SVDCreate()

    148:    Output Parameter:
    149: .  ctx - monitor context

    151:    Level: intermediate

    153: .seealso: SVDMonitorSet()
    154: @*/
    155: PetscErrorCode SVDGetMonitorContext(SVD svd,void **ctx)
    156: {
    159:   *ctx = svd->monitorcontext[0];
    160:   return(0);
    161: }

    165: /*@C
    166:    SVDMonitorAll - Print the current approximate values and
    167:    error estimates at each iteration of the singular value solver.

    169:    Collective on SVD

    171:    Input Parameters:
    172: +  svd    - singular value solver context
    173: .  its    - iteration number
    174: .  nconv  - number of converged singular triplets so far
    175: .  sigma  - singular values
    176: .  errest - error estimates
    177: .  nest   - number of error estimates to display
    178: -  vf     - viewer and format for monitoring

    180:    Level: intermediate

    182: .seealso: SVDMonitorSet(), SVDMonitorFirst(), SVDMonitorConverged()
    183: @*/
    184: PetscErrorCode SVDMonitorAll(SVD svd,PetscInt its,PetscInt nconv,PetscReal *sigma,PetscReal *errest,PetscInt nest,PetscViewerAndFormat *vf)
    185: {
    187:   PetscInt       i;
    188:   PetscViewer    viewer;

    193:   viewer = vf->viewer;
    195:   PetscViewerPushFormat(viewer,vf->format);
    196:   PetscViewerASCIIAddTab(viewer,((PetscObject)svd)->tablevel);
    197:   if (its==1 && ((PetscObject)svd)->prefix) {
    198:     PetscViewerASCIIPrintf(viewer,"  Singular value approximations and residual norms for %s solve.\n",((PetscObject)svd)->prefix);
    199:   }
    200:   PetscViewerASCIIPrintf(viewer,"%3D SVD nconv=%D Values (Errors)",its,nconv);
    201:   PetscViewerASCIIUseTabs(viewer,PETSC_FALSE);
    202:   for (i=0;i<nest;i++) {
    203:     PetscViewerASCIIPrintf(viewer," %g (%10.8e)",(double)sigma[i],(double)errest[i]);
    204:   }
    205:   PetscViewerASCIIPrintf(viewer,"\n");
    206:   PetscViewerASCIIUseTabs(viewer,PETSC_TRUE);
    207:   PetscViewerASCIISubtractTab(viewer,((PetscObject)svd)->tablevel);
    208:   PetscViewerPopFormat(viewer);
    209:   return(0);
    210: }

    214: /*@C
    215:    SVDMonitorFirst - Print the first unconverged approximate values and
    216:    error estimates at each iteration of the singular value solver.

    218:    Collective on SVD

    220:    Input Parameters:
    221: +  svd    - singular value solver context
    222: .  its    - iteration number
    223: .  nconv  - number of converged singular triplets so far
    224: .  sigma  - singular values
    225: .  errest - error estimates
    226: .  nest   - number of error estimates to display
    227: -  vf     - viewer and format for monitoring

    229:    Level: intermediate

    231: .seealso: SVDMonitorSet(), SVDMonitorAll(), SVDMonitorConverged()
    232: @*/
    233: PetscErrorCode SVDMonitorFirst(SVD svd,PetscInt its,PetscInt nconv,PetscReal *sigma,PetscReal *errest,PetscInt nest,PetscViewerAndFormat *vf)
    234: {
    236:   PetscViewer    viewer;

    241:   viewer = vf->viewer;
    243:   if (its==1 && ((PetscObject)svd)->prefix) {
    244:     PetscViewerASCIIPrintf(viewer,"  Singular value approximations and residual norms for %s solve.\n",((PetscObject)svd)->prefix);
    245:   }
    246:   if (nconv<nest) {
    247:     PetscViewerPushFormat(viewer,vf->format);
    248:     PetscViewerASCIIAddTab(viewer,((PetscObject)svd)->tablevel);
    249:     PetscViewerASCIIPrintf(viewer,"%3D SVD nconv=%D first unconverged value (error)",its,nconv);
    250:     PetscViewerASCIIUseTabs(viewer,PETSC_FALSE);
    251:     PetscViewerASCIIPrintf(viewer," %g (%10.8e)\n",(double)sigma[nconv],(double)errest[nconv]);
    252:     PetscViewerASCIIUseTabs(viewer,PETSC_TRUE);
    253:     PetscViewerASCIISubtractTab(viewer,((PetscObject)svd)->tablevel);
    254:     PetscViewerPopFormat(viewer);
    255:   }
    256:   return(0);
    257: }

    261: /*@C
    262:    SVDMonitorConverged - Print the approximate values and error estimates as they converge.

    264:    Collective on SVD

    266:    Input Parameters:
    267: +  svd    - singular value solver context
    268: .  its    - iteration number
    269: .  nconv  - number of converged singular triplets so far
    270: .  sigma  - singular values
    271: .  errest - error estimates
    272: .  nest   - number of error estimates to display
    273: -  ctx    - monitor context

    275:    Level: intermediate

    277: .seealso: SVDMonitorSet(), SVDMonitorFirst(), SVDMonitorAll()
    278: @*/
    279: PetscErrorCode SVDMonitorConverged(SVD svd,PetscInt its,PetscInt nconv,PetscReal *sigma,PetscReal *errest,PetscInt nest,SlepcConvMonitor ctx)
    280: {
    282:   PetscInt       i;
    283:   PetscViewer    viewer;

    288:   viewer = ctx->viewer;
    290:   if (its==1 && ((PetscObject)svd)->prefix) {
    291:     PetscViewerASCIIPrintf(viewer,"  Convergence history for %s solve.\n",((PetscObject)svd)->prefix);
    292:   }
    293:   if (its==1) ctx->oldnconv = 0;
    294:   if (ctx->oldnconv!=nconv) {
    295:     PetscViewerPushFormat(viewer,ctx->format);
    296:     PetscViewerASCIIAddTab(viewer,((PetscObject)svd)->tablevel);
    297:     for (i=ctx->oldnconv;i<nconv;i++) {
    298:       PetscViewerASCIIPrintf(viewer,"%3D SVD converged value (error) #%D",its,i);
    299:       PetscViewerASCIIUseTabs(viewer,PETSC_FALSE);
    300:       PetscViewerASCIIPrintf(viewer," %g (%10.8e)\n",(double)sigma[i],(double)errest[i]);
    301:       PetscViewerASCIIUseTabs(viewer,PETSC_TRUE);
    302:     }
    303:     PetscViewerASCIISubtractTab(viewer,((PetscObject)svd)->tablevel);
    304:     PetscViewerPopFormat(viewer);
    305:     ctx->oldnconv = nconv;
    306:   }
    307:   return(0);
    308: }

    312: /*@C
    313:    SVDMonitorLGCreate - Creates a line graph context for use with
    314:    SVD to monitor convergence.

    316:    Collective on MPI_Comm

    318:    Input Parameters:
    319: +  comm - communicator context
    320: .  host - the X display to open, or null for the local machine
    321: .  label - the title to put in the title bar
    322: .  x, y - the screen coordinates of the upper left coordinate of
    323:           the window
    324: -  m, n - the screen width and height in pixels

    326:    Output Parameter:
    327: .  lgctx - the drawing context

    329:    Options Database Keys:
    330: +  -svd_monitor_lg - Sets line graph monitor for the first residual
    331: -  -svd_monitor_lg_all - Sets line graph monitor for all residuals

    333:    Notes:
    334:    Use PetscDrawLGDestroy() to destroy this line graph.

    336:    Level: intermediate

    338: .seealso: SVDMonitorSet()
    339: @*/
    340: PetscErrorCode SVDMonitorLGCreate(MPI_Comm comm,const char host[],const char label[],int x,int y,int m,int n,PetscDrawLG *lgctx)
    341: {
    342:   PetscDraw      draw;
    343:   PetscDrawLG    lg;

    347:   PetscDrawCreate(comm,host,label,x,y,m,n,&draw);
    348:   PetscDrawSetFromOptions(draw);
    349:   PetscDrawLGCreate(draw,1,&lg);
    350:   PetscDrawLGSetFromOptions(lg);
    351:   PetscDrawDestroy(&draw);
    352:   *lgctx = lg;
    353:   return(0);
    354: }

    358: PetscErrorCode SVDMonitorLG(SVD svd,PetscInt its,PetscInt nconv,PetscReal *sigma,PetscReal *errest,PetscInt nest,void *ctx)
    359: {
    360:   PetscDrawLG    lg = (PetscDrawLG)ctx;
    361:   PetscReal      x,y;

    366:   if (its==1) {
    367:     PetscDrawLGReset(lg);
    368:     PetscDrawLGSetDimension(lg,1);
    369:     PetscDrawLGSetLimits(lg,1,1.0,PetscLog10Real(svd->tol)-2,0.0);
    370:   }
    371:   x = (PetscReal)its;
    372:   if (errest[nconv] > 0.0) y = PetscLog10Real(errest[nconv]);
    373:   else y = 0.0;
    374:   PetscDrawLGAddPoint(lg,&x,&y);
    375:   if (its <= 20 || !(its % 5) || svd->reason) {
    376:     PetscDrawLGDraw(lg);
    377:     PetscDrawLGSave(lg);
    378:   }
    379:   return(0);
    380: }

    384: PetscErrorCode SVDMonitorLGAll(SVD svd,PetscInt its,PetscInt nconv,PetscReal *sigma,PetscReal *errest,PetscInt nest,void *ctx)
    385: {
    386:   PetscDrawLG    lg = (PetscDrawLG)ctx;
    387:   PetscInt       i,n = PetscMin(svd->nsv,255);
    388:   PetscReal      *x,*y;

    393:   if (its==1) {
    394:     PetscDrawLGReset(lg);
    395:     PetscDrawLGSetDimension(lg,n);
    396:     PetscDrawLGSetLimits(lg,1,1.0,PetscLog10Real(svd->tol)-2,0.0);
    397:   }
    398:   PetscMalloc2(n,&x,n,&y);
    399:   for (i=0;i<n;i++) {
    400:     x[i] = (PetscReal)its;
    401:     if (i < nest && errest[i] > 0.0) y[i] = PetscLog10Real(errest[i]);
    402:     else y[i] = 0.0;
    403:   }
    404:   PetscDrawLGAddPoint(lg,x,y);
    405:   if (its <= 20 || !(its % 5) || svd->reason) {
    406:     PetscDrawLGDraw(lg);
    407:     PetscDrawLGSave(lg);
    408:   }
    409:   PetscFree2(x,y);
    410:   return(0);
    411: }