Actual source code: nepview.c

slepc-3.18.1 2022-11-02
Report Typos and Errors
  1: /*
  2:    - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  3:    SLEPc - Scalable Library for Eigenvalue Problem Computations
  4:    Copyright (c) 2002-, Universitat Politecnica de Valencia, Spain

  6:    This file is part of SLEPc.
  7:    SLEPc is distributed under a 2-clause BSD license (see LICENSE).
  8:    - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
  9: */
 10: /*
 11:    NEP routines related to various viewers
 12: */

 14: #include <slepc/private/nepimpl.h>
 15: #include <slepc/private/bvimpl.h>
 16: #include <petscdraw.h>

 18: /*@C
 19:    NEPView - Prints the NEP data structure.

 21:    Collective on nep

 23:    Input Parameters:
 24: +  nep - the nonlinear eigenproblem solver context
 25: -  viewer - optional visualization context

 27:    Options Database Key:
 28: .  -nep_view -  Calls NEPView() at end of NEPSolve()

 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: .seealso: FNView()
 44: @*/
 45: PetscErrorCode NEPView(NEP nep,PetscViewer viewer)
 46: {
 47:   const char     *type=NULL;
 48:   char           str[50];
 49:   PetscInt       i;
 50:   PetscBool      isascii,istrivial;
 51:   PetscViewer    sviewer;
 52:   MPI_Comm       child;

 55:   if (!viewer) PetscViewerASCIIGetStdout(PetscObjectComm((PetscObject)nep),&viewer);

 59:   PetscObjectTypeCompare((PetscObject)viewer,PETSCVIEWERASCII,&isascii);
 60:   if (isascii) {
 61:     PetscObjectPrintClassNamePrefixType((PetscObject)nep,viewer);
 62:     PetscViewerASCIIPushTab(viewer);
 63:     PetscTryTypeMethod(nep,view,viewer);
 64:     PetscViewerASCIIPopTab(viewer);
 65:     if (nep->problem_type) {
 66:       switch (nep->problem_type) {
 67:         case NEP_GENERAL:  type = "general nonlinear eigenvalue problem"; break;
 68:         case NEP_RATIONAL: type = "rational eigenvalue problem"; break;
 69:       }
 70:     } else type = "not yet set";
 71:     PetscViewerASCIIPrintf(viewer,"  problem type: %s\n",type);
 72:     if (nep->fui) {
 73:       switch (nep->fui) {
 74:       case NEP_USER_INTERFACE_CALLBACK:
 75:         PetscViewerASCIIPrintf(viewer,"  nonlinear operator from user callbacks\n");
 76:         break;
 77:       case NEP_USER_INTERFACE_SPLIT:
 78:         PetscViewerASCIIPrintf(viewer,"  nonlinear operator in split form\n");
 79:         PetscViewerASCIIPrintf(viewer,"    number of terms: %" PetscInt_FMT "\n",nep->nt);
 80:         PetscViewerASCIIPrintf(viewer,"    nonzero pattern of the matrices: %s\n",MatStructures[nep->mstr]);
 81:         break;
 82:       }
 83:     } else PetscViewerASCIIPrintf(viewer,"  nonlinear operator not specified yet\n");
 84:     PetscViewerASCIIPrintf(viewer,"  selected portion of the spectrum: ");
 85:     PetscViewerASCIIUseTabs(viewer,PETSC_FALSE);
 86:     SlepcSNPrintfScalar(str,sizeof(str),nep->target,PETSC_FALSE);
 87:     if (!nep->which) PetscViewerASCIIPrintf(viewer,"not yet set\n");
 88:     else switch (nep->which) {
 89:       case NEP_WHICH_USER:
 90:         PetscViewerASCIIPrintf(viewer,"user defined\n");
 91:         break;
 92:       case NEP_TARGET_MAGNITUDE:
 93:         PetscViewerASCIIPrintf(viewer,"closest to target: %s (in magnitude)\n",str);
 94:         break;
 95:       case NEP_TARGET_REAL:
 96:         PetscViewerASCIIPrintf(viewer,"closest to target: %s (along the real axis)\n",str);
 97:         break;
 98:       case NEP_TARGET_IMAGINARY:
 99:         PetscViewerASCIIPrintf(viewer,"closest to target: %s (along the imaginary axis)\n",str);
100:         break;
101:       case NEP_LARGEST_MAGNITUDE:
102:         PetscViewerASCIIPrintf(viewer,"largest eigenvalues in magnitude\n");
103:         break;
104:       case NEP_SMALLEST_MAGNITUDE:
105:         PetscViewerASCIIPrintf(viewer,"smallest eigenvalues in magnitude\n");
106:         break;
107:       case NEP_LARGEST_REAL:
108:         PetscViewerASCIIPrintf(viewer,"largest real parts\n");
109:         break;
110:       case NEP_SMALLEST_REAL:
111:         PetscViewerASCIIPrintf(viewer,"smallest real parts\n");
112:         break;
113:       case NEP_LARGEST_IMAGINARY:
114:         PetscViewerASCIIPrintf(viewer,"largest imaginary parts\n");
115:         break;
116:       case NEP_SMALLEST_IMAGINARY:
117:         PetscViewerASCIIPrintf(viewer,"smallest imaginary parts\n");
118:         break;
119:       case NEP_ALL:
120:         PetscViewerASCIIPrintf(viewer,"all eigenvalues in the region\n");
121:         break;
122:     }
123:     PetscViewerASCIIUseTabs(viewer,PETSC_TRUE);
124:     if (nep->twosided) PetscViewerASCIIPrintf(viewer,"  using two-sided variant (for left eigenvectors)\n");
125:     PetscViewerASCIIPrintf(viewer,"  number of eigenvalues (nev): %" PetscInt_FMT "\n",nep->nev);
126:     PetscViewerASCIIPrintf(viewer,"  number of column vectors (ncv): %" PetscInt_FMT "\n",nep->ncv);
127:     PetscViewerASCIIPrintf(viewer,"  maximum dimension of projected problem (mpd): %" PetscInt_FMT "\n",nep->mpd);
128:     PetscViewerASCIIPrintf(viewer,"  maximum number of iterations: %" PetscInt_FMT "\n",nep->max_it);
129:     PetscViewerASCIIPrintf(viewer,"  tolerance: %g\n",(double)nep->tol);
130:     PetscViewerASCIIPrintf(viewer,"  convergence test: ");
131:     PetscViewerASCIIUseTabs(viewer,PETSC_FALSE);
132:     switch (nep->conv) {
133:     case NEP_CONV_ABS:
134:       PetscViewerASCIIPrintf(viewer,"absolute\n");break;
135:     case NEP_CONV_REL:
136:       PetscViewerASCIIPrintf(viewer,"relative to the eigenvalue\n");break;
137:     case NEP_CONV_NORM:
138:       PetscViewerASCIIPrintf(viewer,"relative to the matrix norms\n");
139:       if (nep->nrma) {
140:         PetscViewerASCIIPrintf(viewer,"  computed matrix norms: %g",(double)nep->nrma[0]);
141:         for (i=1;i<nep->nt;i++) PetscViewerASCIIPrintf(viewer,", %g",(double)nep->nrma[i]);
142:         PetscViewerASCIIPrintf(viewer,"\n");
143:       }
144:       break;
145:     case NEP_CONV_USER:
146:       PetscViewerASCIIPrintf(viewer,"user-defined\n");break;
147:     }
148:     PetscViewerASCIIUseTabs(viewer,PETSC_TRUE);
149:     if (nep->refine) {
150:       PetscViewerASCIIPrintf(viewer,"  iterative refinement: %s, with %s scheme\n",NEPRefineTypes[nep->refine],NEPRefineSchemes[nep->scheme]);
151:       PetscViewerASCIIPrintf(viewer,"  refinement stopping criterion: tol=%g, its=%" PetscInt_FMT "\n",(double)nep->rtol,nep->rits);
152:       if (nep->npart>1) PetscViewerASCIIPrintf(viewer,"  splitting communicator in %" PetscInt_FMT " partitions for refinement\n",nep->npart);
153:     }
154:     if (nep->nini) PetscViewerASCIIPrintf(viewer,"  dimension of user-provided initial space: %" PetscInt_FMT "\n",PetscAbs(nep->nini));
155:   } else PetscTryTypeMethod(nep,view,viewer);
156:   PetscViewerPushFormat(viewer,PETSC_VIEWER_ASCII_INFO);
157:   if (!nep->V) NEPGetBV(nep,&nep->V);
158:   BVView(nep->V,viewer);
159:   if (!nep->rg) NEPGetRG(nep,&nep->rg);
160:   RGIsTrivial(nep->rg,&istrivial);
161:   if (!istrivial) RGView(nep->rg,viewer);
162:   if (nep->useds) {
163:     if (!nep->ds) NEPGetDS(nep,&nep->ds);
164:     DSView(nep->ds,viewer);
165:   }
166:   PetscViewerPopFormat(viewer);
167:   if (nep->refine!=NEP_REFINE_NONE) {
168:     PetscViewerASCIIPushTab(viewer);
169:     if (nep->npart>1) {
170:       if (nep->refinesubc->color==0) {
171:         PetscSubcommGetChild(nep->refinesubc,&child);
172:         PetscViewerASCIIGetStdout(child,&sviewer);
173:         KSPView(nep->refineksp,sviewer);
174:       }
175:     } else KSPView(nep->refineksp,viewer);
176:     PetscViewerASCIIPopTab(viewer);
177:   }
178:   return 0;
179: }

181: /*@C
182:    NEPViewFromOptions - View from options

184:    Collective on NEP

186:    Input Parameters:
187: +  nep  - the nonlinear eigensolver context
188: .  obj  - optional object
189: -  name - command line option

191:    Level: intermediate

193: .seealso: NEPView(), NEPCreate()
194: @*/
195: PetscErrorCode NEPViewFromOptions(NEP nep,PetscObject obj,const char name[])
196: {
198:   PetscObjectViewFromOptions((PetscObject)nep,obj,name);
199:   return 0;
200: }

202: /*@C
203:    NEPConvergedReasonView - Displays the reason a NEP solve converged or diverged.

205:    Collective on nep

207:    Input Parameters:
208: +  nep - the nonlinear eigensolver context
209: -  viewer - the viewer to display the reason

211:    Options Database Keys:
212: .  -nep_converged_reason - print reason for convergence, and number of iterations

214:    Note:
215:    To change the format of the output call PetscViewerPushFormat(viewer,format) before
216:    this call. Use PETSC_VIEWER_DEFAULT for the default, use PETSC_VIEWER_FAILED to only
217:    display a reason if it fails. The latter can be set in the command line with
218:    -nep_converged_reason ::failed

220:    Level: intermediate

222: .seealso: NEPSetConvergenceTest(), NEPSetTolerances(), NEPGetIterationNumber(), NEPConvergedReasonViewFromOptions()
223: @*/
224: PetscErrorCode NEPConvergedReasonView(NEP nep,PetscViewer viewer)
225: {
226:   PetscBool         isAscii;
227:   PetscViewerFormat format;

229:   if (!viewer) viewer = PETSC_VIEWER_STDOUT_(PetscObjectComm((PetscObject)nep));
230:   PetscObjectTypeCompare((PetscObject)viewer,PETSCVIEWERASCII,&isAscii);
231:   if (isAscii) {
232:     PetscViewerGetFormat(viewer,&format);
233:     PetscViewerASCIIAddTab(viewer,((PetscObject)nep)->tablevel);
234:     if (nep->reason > 0 && format != PETSC_VIEWER_FAILED) PetscViewerASCIIPrintf(viewer,"%s Nonlinear eigensolve converged (%" PetscInt_FMT " eigenpair%s) due to %s; iterations %" PetscInt_FMT "\n",((PetscObject)nep)->prefix?((PetscObject)nep)->prefix:"",nep->nconv,(nep->nconv>1)?"s":"",NEPConvergedReasons[nep->reason],nep->its);
235:     else if (nep->reason <= 0) PetscViewerASCIIPrintf(viewer,"%s Nonlinear eigensolve did not converge due to %s; iterations %" PetscInt_FMT "\n",((PetscObject)nep)->prefix?((PetscObject)nep)->prefix:"",NEPConvergedReasons[nep->reason],nep->its);
236:     PetscViewerASCIISubtractTab(viewer,((PetscObject)nep)->tablevel);
237:   }
238:   return 0;
239: }

241: /*@
242:    NEPConvergedReasonViewFromOptions - Processes command line options to determine if/how
243:    the NEP converged reason is to be viewed.

245:    Collective on nep

247:    Input Parameter:
248: .  nep - the nonlinear eigensolver context

250:    Level: developer

252: .seealso: NEPConvergedReasonView()
253: @*/
254: PetscErrorCode NEPConvergedReasonViewFromOptions(NEP nep)
255: {
256:   PetscViewer       viewer;
257:   PetscBool         flg;
258:   static PetscBool  incall = PETSC_FALSE;
259:   PetscViewerFormat format;

261:   if (incall) return 0;
262:   incall = PETSC_TRUE;
263:   PetscOptionsGetViewer(PetscObjectComm((PetscObject)nep),((PetscObject)nep)->options,((PetscObject)nep)->prefix,"-nep_converged_reason",&viewer,&format,&flg);
264:   if (flg) {
265:     PetscViewerPushFormat(viewer,format);
266:     NEPConvergedReasonView(nep,viewer);
267:     PetscViewerPopFormat(viewer);
268:     PetscViewerDestroy(&viewer);
269:   }
270:   incall = PETSC_FALSE;
271:   return 0;
272: }

274: static PetscErrorCode NEPErrorView_ASCII(NEP nep,NEPErrorType etype,PetscViewer viewer)
275: {
276:   PetscReal      error;
277:   PetscInt       i,j,k,nvals;

279:   nvals = (nep->which==NEP_ALL)? nep->nconv: nep->nev;
280:   if (nep->which!=NEP_ALL && nep->nconv<nvals) {
281:     PetscViewerASCIIPrintf(viewer," Problem: less than %" PetscInt_FMT " eigenvalues converged\n\n",nep->nev);
282:     return 0;
283:   }
284:   if (nep->which==NEP_ALL && !nvals) {
285:     PetscViewerASCIIPrintf(viewer," No eigenvalues have been found\n\n");
286:     return 0;
287:   }
288:   for (i=0;i<nvals;i++) {
289:     NEPComputeError(nep,i,etype,&error);
290:     if (error>=5.0*nep->tol) {
291:       PetscViewerASCIIPrintf(viewer," Problem: some of the first %" PetscInt_FMT " relative errors are higher than the tolerance\n\n",nvals);
292:       return 0;
293:     }
294:   }
295:   if (nep->which==NEP_ALL) PetscViewerASCIIPrintf(viewer," Found %" PetscInt_FMT " eigenvalues, all of them computed up to the required tolerance:",nvals);
296:   else PetscViewerASCIIPrintf(viewer," All requested eigenvalues computed up to the required tolerance:");
297:   for (i=0;i<=(nvals-1)/8;i++) {
298:     PetscViewerASCIIPrintf(viewer,"\n     ");
299:     for (j=0;j<PetscMin(8,nvals-8*i);j++) {
300:       k = nep->perm[8*i+j];
301:       SlepcPrintEigenvalueASCII(viewer,nep->eigr[k],nep->eigi[k]);
302:       if (8*i+j+1<nvals) PetscViewerASCIIPrintf(viewer,", ");
303:     }
304:   }
305:   PetscViewerASCIIPrintf(viewer,"\n\n");
306:   return 0;
307: }

309: static PetscErrorCode NEPErrorView_DETAIL(NEP nep,NEPErrorType etype,PetscViewer viewer)
310: {
311:   PetscReal      error,re,im;
312:   PetscScalar    kr,ki;
313:   PetscInt       i;
314:   char           ex[30],sep[]=" ---------------------- --------------------\n";

316:   if (!nep->nconv) return 0;
317:   switch (etype) {
318:     case NEP_ERROR_ABSOLUTE:
319:       PetscSNPrintf(ex,sizeof(ex),"    ||T(k)x||");
320:       break;
321:     case NEP_ERROR_RELATIVE:
322:       PetscSNPrintf(ex,sizeof(ex)," ||T(k)x||/||kx||");
323:       break;
324:     case NEP_ERROR_BACKWARD:
325:       PetscSNPrintf(ex,sizeof(ex),"    eta(x,k)");
326:       break;
327:   }
328:   PetscViewerASCIIPrintf(viewer,"%s            k             %s\n%s",sep,ex,sep);
329:   for (i=0;i<nep->nconv;i++) {
330:     NEPGetEigenpair(nep,i,&kr,&ki,NULL,NULL);
331:     NEPComputeError(nep,i,etype,&error);
332: #if defined(PETSC_USE_COMPLEX)
333:     re = PetscRealPart(kr);
334:     im = PetscImaginaryPart(kr);
335: #else
336:     re = kr;
337:     im = ki;
338: #endif
339:     if (im!=0.0) PetscViewerASCIIPrintf(viewer,"  % 9f%+9fi      %12g\n",(double)re,(double)im,(double)error);
340:     else PetscViewerASCIIPrintf(viewer,"    % 12f           %12g\n",(double)re,(double)error);
341:   }
342:   PetscViewerASCIIPrintf(viewer,"%s",sep);
343:   return 0;
344: }

346: static PetscErrorCode NEPErrorView_MATLAB(NEP nep,NEPErrorType etype,PetscViewer viewer)
347: {
348:   PetscReal      error;
349:   PetscInt       i;
350:   const char     *name;

352:   PetscObjectGetName((PetscObject)nep,&name);
353:   PetscViewerASCIIPrintf(viewer,"Error_%s = [\n",name);
354:   for (i=0;i<nep->nconv;i++) {
355:     NEPComputeError(nep,i,etype,&error);
356:     PetscViewerASCIIPrintf(viewer,"%18.16e\n",(double)error);
357:   }
358:   PetscViewerASCIIPrintf(viewer,"];\n");
359:   return 0;
360: }

362: /*@C
363:    NEPErrorView - Displays the errors associated with the computed solution
364:    (as well as the eigenvalues).

366:    Collective on nep

368:    Input Parameters:
369: +  nep    - the nonlinear eigensolver context
370: .  etype  - error type
371: -  viewer - optional visualization context

373:    Options Database Keys:
374: +  -nep_error_absolute - print absolute errors of each eigenpair
375: .  -nep_error_relative - print relative errors of each eigenpair
376: -  -nep_error_backward - print backward errors of each eigenpair

378:    Notes:
379:    By default, this function checks the error of all eigenpairs and prints
380:    the eigenvalues if all of them are below the requested tolerance.
381:    If the viewer has format=PETSC_VIEWER_ASCII_INFO_DETAIL then a table with
382:    eigenvalues and corresponding errors is printed.

384:    Level: intermediate

386: .seealso: NEPSolve(), NEPValuesView(), NEPVectorsView()
387: @*/
388: PetscErrorCode NEPErrorView(NEP nep,NEPErrorType etype,PetscViewer viewer)
389: {
390:   PetscBool         isascii;
391:   PetscViewerFormat format;

394:   if (!viewer) PetscViewerASCIIGetStdout(PetscObjectComm((PetscObject)nep),&viewer);
397:   NEPCheckSolved(nep,1);
398:   PetscObjectTypeCompare((PetscObject)viewer,PETSCVIEWERASCII,&isascii);
399:   if (!isascii) return 0;

401:   PetscViewerGetFormat(viewer,&format);
402:   switch (format) {
403:     case PETSC_VIEWER_DEFAULT:
404:     case PETSC_VIEWER_ASCII_INFO:
405:       NEPErrorView_ASCII(nep,etype,viewer);
406:       break;
407:     case PETSC_VIEWER_ASCII_INFO_DETAIL:
408:       NEPErrorView_DETAIL(nep,etype,viewer);
409:       break;
410:     case PETSC_VIEWER_ASCII_MATLAB:
411:       NEPErrorView_MATLAB(nep,etype,viewer);
412:       break;
413:     default:
414:       PetscInfo(nep,"Unsupported viewer format %s\n",PetscViewerFormats[format]);
415:   }
416:   return 0;
417: }

419: /*@
420:    NEPErrorViewFromOptions - Processes command line options to determine if/how
421:    the errors of the computed solution are to be viewed.

423:    Collective on nep

425:    Input Parameter:
426: .  nep - the nonlinear eigensolver context

428:    Level: developer

430: .seealso: NEPErrorView()
431: @*/
432: PetscErrorCode NEPErrorViewFromOptions(NEP nep)
433: {
434:   PetscViewer       viewer;
435:   PetscBool         flg;
436:   static PetscBool  incall = PETSC_FALSE;
437:   PetscViewerFormat format;

439:   if (incall) return 0;
440:   incall = PETSC_TRUE;
441:   PetscOptionsGetViewer(PetscObjectComm((PetscObject)nep),((PetscObject)nep)->options,((PetscObject)nep)->prefix,"-nep_error_absolute",&viewer,&format,&flg);
442:   if (flg) {
443:     PetscViewerPushFormat(viewer,format);
444:     NEPErrorView(nep,NEP_ERROR_ABSOLUTE,viewer);
445:     PetscViewerPopFormat(viewer);
446:     PetscViewerDestroy(&viewer);
447:   }
448:   PetscOptionsGetViewer(PetscObjectComm((PetscObject)nep),((PetscObject)nep)->options,((PetscObject)nep)->prefix,"-nep_error_relative",&viewer,&format,&flg);
449:   if (flg) {
450:     PetscViewerPushFormat(viewer,format);
451:     NEPErrorView(nep,NEP_ERROR_RELATIVE,viewer);
452:     PetscViewerPopFormat(viewer);
453:     PetscViewerDestroy(&viewer);
454:   }
455:   PetscOptionsGetViewer(PetscObjectComm((PetscObject)nep),((PetscObject)nep)->options,((PetscObject)nep)->prefix,"-nep_error_backward",&viewer,&format,&flg);
456:   if (flg) {
457:     PetscViewerPushFormat(viewer,format);
458:     NEPErrorView(nep,NEP_ERROR_BACKWARD,viewer);
459:     PetscViewerPopFormat(viewer);
460:     PetscViewerDestroy(&viewer);
461:   }
462:   incall = PETSC_FALSE;
463:   return 0;
464: }

466: static PetscErrorCode NEPValuesView_DRAW(NEP nep,PetscViewer viewer)
467: {
468:   PetscDraw      draw;
469:   PetscDrawSP    drawsp;
470:   PetscReal      re,im;
471:   PetscInt       i,k;

473:   if (!nep->nconv) return 0;
474:   PetscViewerDrawGetDraw(viewer,0,&draw);
475:   PetscDrawSetTitle(draw,"Computed Eigenvalues");
476:   PetscDrawSPCreate(draw,1,&drawsp);
477:   for (i=0;i<nep->nconv;i++) {
478:     k = nep->perm[i];
479: #if defined(PETSC_USE_COMPLEX)
480:     re = PetscRealPart(nep->eigr[k]);
481:     im = PetscImaginaryPart(nep->eigr[k]);
482: #else
483:     re = nep->eigr[k];
484:     im = nep->eigi[k];
485: #endif
486:     PetscDrawSPAddPoint(drawsp,&re,&im);
487:   }
488:   PetscDrawSPDraw(drawsp,PETSC_TRUE);
489:   PetscDrawSPSave(drawsp);
490:   PetscDrawSPDestroy(&drawsp);
491:   return 0;
492: }

494: static PetscErrorCode NEPValuesView_BINARY(NEP nep,PetscViewer viewer)
495: {
496: #if defined(PETSC_HAVE_COMPLEX)
497:   PetscInt       i,k;
498:   PetscComplex   *ev;
499: #endif

501: #if defined(PETSC_HAVE_COMPLEX)
502:   PetscMalloc1(nep->nconv,&ev);
503:   for (i=0;i<nep->nconv;i++) {
504:     k = nep->perm[i];
505: #if defined(PETSC_USE_COMPLEX)
506:     ev[i] = nep->eigr[k];
507: #else
508:     ev[i] = PetscCMPLX(nep->eigr[k],nep->eigi[k]);
509: #endif
510:   }
511:   PetscViewerBinaryWrite(viewer,ev,nep->nconv,PETSC_COMPLEX);
512:   PetscFree(ev);
513: #endif
514:   return 0;
515: }

517: #if defined(PETSC_HAVE_HDF5)
518: static PetscErrorCode NEPValuesView_HDF5(NEP nep,PetscViewer viewer)
519: {
520:   PetscInt       i,k,n,N;
521:   PetscMPIInt    rank;
522:   Vec            v;
523:   char           vname[30];
524:   const char     *ename;

526:   MPI_Comm_rank(PetscObjectComm((PetscObject)nep),&rank);
527:   N = nep->nconv;
528:   n = rank? 0: N;
529:   /* create a vector containing the eigenvalues */
530:   VecCreateMPI(PetscObjectComm((PetscObject)nep),n,N,&v);
531:   PetscObjectGetName((PetscObject)nep,&ename);
532:   PetscSNPrintf(vname,sizeof(vname),"eigr_%s",ename);
533:   PetscObjectSetName((PetscObject)v,vname);
534:   if (!rank) {
535:     for (i=0;i<nep->nconv;i++) {
536:       k = nep->perm[i];
537:       VecSetValue(v,i,nep->eigr[k],INSERT_VALUES);
538:     }
539:   }
540:   VecAssemblyBegin(v);
541:   VecAssemblyEnd(v);
542:   VecView(v,viewer);
543: #if !defined(PETSC_USE_COMPLEX)
544:   /* in real scalars write the imaginary part as a separate vector */
545:   PetscSNPrintf(vname,sizeof(vname),"eigi_%s",ename);
546:   PetscObjectSetName((PetscObject)v,vname);
547:   if (!rank) {
548:     for (i=0;i<nep->nconv;i++) {
549:       k = nep->perm[i];
550:       VecSetValue(v,i,nep->eigi[k],INSERT_VALUES);
551:     }
552:   }
553:   VecAssemblyBegin(v);
554:   VecAssemblyEnd(v);
555:   VecView(v,viewer);
556: #endif
557:   VecDestroy(&v);
558:   return 0;
559: }
560: #endif

562: static PetscErrorCode NEPValuesView_ASCII(NEP nep,PetscViewer viewer)
563: {
564:   PetscInt       i,k;

566:   PetscViewerASCIIPrintf(viewer,"Eigenvalues = \n");
567:   for (i=0;i<nep->nconv;i++) {
568:     k = nep->perm[i];
569:     PetscViewerASCIIPrintf(viewer,"   ");
570:     SlepcPrintEigenvalueASCII(viewer,nep->eigr[k],nep->eigi[k]);
571:     PetscViewerASCIIPrintf(viewer,"\n");
572:   }
573:   PetscViewerASCIIPrintf(viewer,"\n");
574:   return 0;
575: }

577: static PetscErrorCode NEPValuesView_MATLAB(NEP nep,PetscViewer viewer)
578: {
579:   PetscInt       i,k;
580:   PetscReal      re,im;
581:   const char     *name;

583:   PetscObjectGetName((PetscObject)nep,&name);
584:   PetscViewerASCIIPrintf(viewer,"Lambda_%s = [\n",name);
585:   for (i=0;i<nep->nconv;i++) {
586:     k = nep->perm[i];
587: #if defined(PETSC_USE_COMPLEX)
588:     re = PetscRealPart(nep->eigr[k]);
589:     im = PetscImaginaryPart(nep->eigr[k]);
590: #else
591:     re = nep->eigr[k];
592:     im = nep->eigi[k];
593: #endif
594:     if (im!=0.0) PetscViewerASCIIPrintf(viewer,"%18.16e%+18.16ei\n",(double)re,(double)im);
595:     else PetscViewerASCIIPrintf(viewer,"%18.16e\n",(double)re);
596:   }
597:   PetscViewerASCIIPrintf(viewer,"];\n");
598:   return 0;
599: }

601: /*@C
602:    NEPValuesView - Displays the computed eigenvalues in a viewer.

604:    Collective on nep

606:    Input Parameters:
607: +  nep    - the nonlinear eigensolver context
608: -  viewer - the viewer

610:    Options Database Key:
611: .  -nep_view_values - print computed eigenvalues

613:    Level: intermediate

615: .seealso: NEPSolve(), NEPVectorsView(), NEPErrorView()
616: @*/
617: PetscErrorCode NEPValuesView(NEP nep,PetscViewer viewer)
618: {
619:   PetscBool         isascii,isdraw,isbinary;
620:   PetscViewerFormat format;
621: #if defined(PETSC_HAVE_HDF5)
622:   PetscBool         ishdf5;
623: #endif

626:   if (!viewer) PetscViewerASCIIGetStdout(PetscObjectComm((PetscObject)nep),&viewer);
629:   NEPCheckSolved(nep,1);
630:   PetscObjectTypeCompare((PetscObject)viewer,PETSCVIEWERDRAW,&isdraw);
631:   PetscObjectTypeCompare((PetscObject)viewer,PETSCVIEWERBINARY,&isbinary);
632: #if defined(PETSC_HAVE_HDF5)
633:   PetscObjectTypeCompare((PetscObject)viewer,PETSCVIEWERHDF5,&ishdf5);
634: #endif
635:   PetscObjectTypeCompare((PetscObject)viewer,PETSCVIEWERASCII,&isascii);
636:   if (isdraw) NEPValuesView_DRAW(nep,viewer);
637:   else if (isbinary) NEPValuesView_BINARY(nep,viewer);
638: #if defined(PETSC_HAVE_HDF5)
639:   else if (ishdf5) NEPValuesView_HDF5(nep,viewer);
640: #endif
641:   else if (isascii) {
642:     PetscViewerGetFormat(viewer,&format);
643:     switch (format) {
644:       case PETSC_VIEWER_DEFAULT:
645:       case PETSC_VIEWER_ASCII_INFO:
646:       case PETSC_VIEWER_ASCII_INFO_DETAIL:
647:         NEPValuesView_ASCII(nep,viewer);
648:         break;
649:       case PETSC_VIEWER_ASCII_MATLAB:
650:         NEPValuesView_MATLAB(nep,viewer);
651:         break;
652:       default:
653:         PetscInfo(nep,"Unsupported viewer format %s\n",PetscViewerFormats[format]);
654:     }
655:   }
656:   return 0;
657: }

659: /*@
660:    NEPValuesViewFromOptions - Processes command line options to determine if/how
661:    the computed eigenvalues are to be viewed.

663:    Collective on nep

665:    Input Parameter:
666: .  nep - the nonlinear eigensolver context

668:    Level: developer

670: .seealso: NEPValuesView()
671: @*/
672: PetscErrorCode NEPValuesViewFromOptions(NEP nep)
673: {
674:   PetscViewer       viewer;
675:   PetscBool         flg;
676:   static PetscBool  incall = PETSC_FALSE;
677:   PetscViewerFormat format;

679:   if (incall) return 0;
680:   incall = PETSC_TRUE;
681:   PetscOptionsGetViewer(PetscObjectComm((PetscObject)nep),((PetscObject)nep)->options,((PetscObject)nep)->prefix,"-nep_view_values",&viewer,&format,&flg);
682:   if (flg) {
683:     PetscViewerPushFormat(viewer,format);
684:     NEPValuesView(nep,viewer);
685:     PetscViewerPopFormat(viewer);
686:     PetscViewerDestroy(&viewer);
687:   }
688:   incall = PETSC_FALSE;
689:   return 0;
690: }

692: /*@C
693:    NEPVectorsView - Outputs computed eigenvectors to a viewer.

695:    Collective on nep

697:    Input Parameters:
698: +  nep    - the nonlinear eigensolver context
699: -  viewer - the viewer

701:    Options Database Key:
702: .  -nep_view_vectors - output eigenvectors.

704:    Notes:
705:    If PETSc was configured with real scalars, complex conjugate eigenvectors
706:    will be viewed as two separate real vectors, one containing the real part
707:    and another one containing the imaginary part.

709:    If left eigenvectors were computed with a two-sided eigensolver, the right
710:    and left eigenvectors are interleaved, that is, the vectors are output in
711:    the following order X0, Y0, X1, Y1, X2, Y2, ...

713:    Level: intermediate

715: .seealso: NEPSolve(), NEPValuesView(), NEPErrorView()
716: @*/
717: PetscErrorCode NEPVectorsView(NEP nep,PetscViewer viewer)
718: {
719:   PetscInt       i,k;
720:   Vec            xr,xi=NULL;

723:   if (!viewer) PetscViewerASCIIGetStdout(PetscObjectComm((PetscObject)nep),&viewer);
726:   NEPCheckSolved(nep,1);
727:   if (nep->nconv) {
728:     NEPComputeVectors(nep);
729:     BVCreateVec(nep->V,&xr);
730: #if !defined(PETSC_USE_COMPLEX)
731:     BVCreateVec(nep->V,&xi);
732: #endif
733:     for (i=0;i<nep->nconv;i++) {
734:       k = nep->perm[i];
735:       BV_GetEigenvector(nep->V,k,nep->eigi[k],xr,xi);
736:       SlepcViewEigenvector(viewer,xr,xi,"X",i,(PetscObject)nep);
737:       if (nep->twosided) {
738:         BV_GetEigenvector(nep->W,k,nep->eigi[k],xr,xi);
739:         SlepcViewEigenvector(viewer,xr,xi,"Y",i,(PetscObject)nep);
740:       }
741:     }
742:     VecDestroy(&xr);
743: #if !defined(PETSC_USE_COMPLEX)
744:     VecDestroy(&xi);
745: #endif
746:   }
747:   return 0;
748: }

750: /*@
751:    NEPVectorsViewFromOptions - Processes command line options to determine if/how
752:    the computed eigenvectors are to be viewed.

754:    Collective on nep

756:    Input Parameter:
757: .  nep - the nonlinear eigensolver context

759:    Level: developer

761: .seealso: NEPVectorsView()
762: @*/
763: PetscErrorCode NEPVectorsViewFromOptions(NEP nep)
764: {
765:   PetscViewer       viewer;
766:   PetscBool         flg = PETSC_FALSE;
767:   static PetscBool  incall = PETSC_FALSE;
768:   PetscViewerFormat format;

770:   if (incall) return 0;
771:   incall = PETSC_TRUE;
772:   PetscOptionsGetViewer(PetscObjectComm((PetscObject)nep),((PetscObject)nep)->options,((PetscObject)nep)->prefix,"-nep_view_vectors",&viewer,&format,&flg);
773:   if (flg) {
774:     PetscViewerPushFormat(viewer,format);
775:     NEPVectorsView(nep,viewer);
776:     PetscViewerPopFormat(viewer);
777:     PetscViewerDestroy(&viewer);
778:   }
779:   incall = PETSC_FALSE;
780:   return 0;
781: }