LCOV - code coverage report
Current view: top level - nep/impls/rii - rii.c (source / functions) Hit Total Coverage
Test: SLEPc Lines: 383 409 93.6 %
Date: 2021-08-02 00:32:28 Functions: 30 31 96.8 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*
       2             :    - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
       3             :    SLEPc - Scalable Library for Eigenvalue Problem Computations
       4             :    Copyright (c) 2002-2021, Universitat Politecnica de Valencia, Spain
       5             : 
       6             :    This file is part of SLEPc.
       7             :    SLEPc is distributed under a 2-clause BSD license (see LICENSE).
       8             :    - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
       9             : */
      10             : /*
      11             :    SLEPc nonlinear eigensolver: "rii"
      12             : 
      13             :    Method: Residual inverse iteration
      14             : 
      15             :    Algorithm:
      16             : 
      17             :        Simple residual inverse iteration with varying shift.
      18             : 
      19             :    References:
      20             : 
      21             :        [1] A. Neumaier, "Residual inverse iteration for the nonlinear
      22             :            eigenvalue problem", SIAM J. Numer. Anal. 22(5):914-923, 1985.
      23             : */
      24             : 
      25             : #include <slepc/private/nepimpl.h>         /*I "slepcnep.h" I*/
      26             : #include <../src/nep/impls/nepdefl.h>
      27             : 
      28             : typedef struct {
      29             :   PetscInt  max_inner_it;     /* maximum number of Newton iterations */
      30             :   PetscInt  lag;              /* interval to rebuild preconditioner */
      31             :   PetscBool cctol;            /* constant correction tolerance */
      32             :   PetscBool herm;             /* whether the Hermitian version of the scalar equation must be used */
      33             :   PetscReal deftol;           /* tolerance for the deflation (threshold) */
      34             :   KSP       ksp;              /* linear solver object */
      35             : } NEP_RII;
      36             : 
      37          18 : PetscErrorCode NEPSetUp_RII(NEP nep)
      38             : {
      39          18 :   PetscErrorCode ierr;
      40             : 
      41          18 :   PetscFunctionBegin;
      42          18 :   if (nep->ncv!=PETSC_DEFAULT) { ierr = PetscInfo(nep,"Setting ncv = nev, ignoring user-provided value\n");CHKERRQ(ierr); }
      43          18 :   nep->ncv = nep->nev;
      44          18 :   if (nep->mpd!=PETSC_DEFAULT) { ierr = PetscInfo(nep,"Setting mpd = nev, ignoring user-provided value\n");CHKERRQ(ierr); }
      45          18 :   nep->mpd = nep->nev;
      46          18 :   if (nep->max_it==PETSC_DEFAULT) nep->max_it = PetscMax(5000,2*nep->n/nep->ncv);
      47          18 :   if (!nep->which) nep->which = NEP_TARGET_MAGNITUDE;
      48          18 :   if (nep->which!=NEP_TARGET_MAGNITUDE) SETERRQ(PetscObjectComm((PetscObject)nep),PETSC_ERR_SUP,"This solver supports only target magnitude eigenvalues");
      49          18 :   NEPCheckUnsupported(nep,NEP_FEATURE_REGION | NEP_FEATURE_TWOSIDED);
      50          18 :   ierr = NEPAllocateSolution(nep,0);CHKERRQ(ierr);
      51          18 :   ierr = NEPSetWorkVecs(nep,2);CHKERRQ(ierr);
      52          18 :   PetscFunctionReturn(0);
      53             : }
      54             : 
      55          18 : PetscErrorCode NEPSolve_RII(NEP nep)
      56             : {
      57          18 :   PetscErrorCode     ierr;
      58          18 :   NEP_RII            *ctx = (NEP_RII*)nep->data;
      59          18 :   Mat                T,Tp,H;
      60          18 :   Vec                uu,u,r,delta,t;
      61          18 :   PetscScalar        lambda,lambda2,sigma,a1,a2,corr,*Ap;
      62          18 :   const PetscScalar  *Hp;
      63          18 :   PetscReal          nrm,resnorm=1.0,ktol=0.1,perr,rtol;
      64          18 :   PetscBool          skip=PETSC_FALSE,lock=PETSC_FALSE;
      65          18 :   PetscInt           inner_its,its=0,ldh,ldds,i,j;
      66          18 :   NEP_EXT_OP         extop=NULL;
      67          18 :   KSPConvergedReason kspreason;
      68             : 
      69          18 :   PetscFunctionBegin;
      70             :   /* get initial approximation of eigenvalue and eigenvector */
      71          18 :   ierr = NEPGetDefaultShift(nep,&sigma);CHKERRQ(ierr);
      72          18 :   lambda = sigma;
      73          18 :   if (!nep->nini) {
      74          16 :     ierr = BVSetRandomColumn(nep->V,0);CHKERRQ(ierr);
      75          16 :     ierr = BVNormColumn(nep->V,0,NORM_2,&nrm);CHKERRQ(ierr);
      76          16 :     ierr = BVScaleColumn(nep->V,0,1.0/nrm);CHKERRQ(ierr);
      77             :   }
      78          18 :   if (!ctx->ksp) { ierr = NEPRIIGetKSP(nep,&ctx->ksp);CHKERRQ(ierr); }
      79          18 :   ierr = NEPDeflationInitialize(nep,nep->V,ctx->ksp,PETSC_FALSE,nep->nev,&extop);CHKERRQ(ierr);
      80          18 :   ierr = NEPDeflationCreateVec(extop,&u);CHKERRQ(ierr);
      81          18 :   ierr = VecDuplicate(u,&r);CHKERRQ(ierr);
      82          18 :   ierr = VecDuplicate(u,&delta);CHKERRQ(ierr);
      83          18 :   ierr = BVGetColumn(nep->V,0,&uu);CHKERRQ(ierr);
      84          18 :   ierr = NEPDeflationCopyToExtendedVec(extop,uu,NULL,u,PETSC_FALSE);CHKERRQ(ierr);
      85          18 :   ierr = BVRestoreColumn(nep->V,0,&uu);CHKERRQ(ierr);
      86             : 
      87             :   /* prepare linear solver */
      88          18 :   ierr = NEPDeflationSolveSetUp(extop,sigma);CHKERRQ(ierr);
      89          18 :   ierr = KSPGetTolerances(ctx->ksp,&rtol,NULL,NULL,NULL);CHKERRQ(ierr);
      90             : 
      91          18 :   ierr = VecCopy(u,r);CHKERRQ(ierr);
      92          18 :   ierr = NEPDeflationFunctionSolve(extop,r,u);CHKERRQ(ierr);
      93          18 :   ierr = VecNorm(u,NORM_2,&nrm);CHKERRQ(ierr);
      94          18 :   ierr = VecScale(u,1.0/nrm);CHKERRQ(ierr);
      95             : 
      96             :   /* Restart loop */
      97         313 :   while (nep->reason == NEP_CONVERGED_ITERATING) {
      98         295 :     its++;
      99             : 
     100             :     /* Use Newton's method to compute nonlinear Rayleigh functional. Current eigenvalue
     101             :        estimate as starting value. */
     102         295 :     inner_its=0;
     103         295 :     lambda2 = lambda;
     104         680 :     do {
     105         680 :       ierr = NEPDeflationComputeFunction(extop,lambda,&T);CHKERRQ(ierr);
     106         680 :       ierr = MatMult(T,u,r);CHKERRQ(ierr);
     107         680 :       if (!ctx->herm) {
     108         529 :         ierr = NEPDeflationFunctionSolve(extop,r,delta);CHKERRQ(ierr);
     109         529 :         ierr = KSPGetConvergedReason(ctx->ksp,&kspreason);CHKERRQ(ierr);
     110         529 :         if (kspreason<0) {
     111           0 :           ierr = PetscInfo1(nep,"iter=%D, linear solve failed\n",nep->its);CHKERRQ(ierr);
     112             :         }
     113         529 :         t = delta;
     114         151 :       } else t = r;
     115         680 :       ierr = VecDot(t,u,&a1);CHKERRQ(ierr);
     116         680 :       ierr = NEPDeflationComputeJacobian(extop,lambda,&Tp);CHKERRQ(ierr);
     117         680 :       ierr = MatMult(Tp,u,r);CHKERRQ(ierr);
     118         680 :       if (!ctx->herm) {
     119         529 :         ierr = NEPDeflationFunctionSolve(extop,r,delta);CHKERRQ(ierr);
     120         529 :         ierr = KSPGetConvergedReason(ctx->ksp,&kspreason);CHKERRQ(ierr);
     121         529 :         if (kspreason<0) {
     122           0 :           ierr = PetscInfo1(nep,"iter=%D, linear solve failed\n",nep->its);CHKERRQ(ierr);
     123             :         }
     124         529 :         t = delta;
     125         151 :       } else t = r;
     126         680 :       ierr = VecDot(t,u,&a2);CHKERRQ(ierr);
     127         680 :       corr = a1/a2;
     128         680 :       lambda = lambda - corr;
     129         680 :       inner_its++;
     130         680 :     } while (PetscAbsScalar(corr)/PetscAbsScalar(lambda)>PETSC_SQRT_MACHINE_EPSILON && inner_its<ctx->max_inner_it);
     131             : 
     132             :     /* form residual,  r = T(lambda)*u */
     133         295 :     ierr = NEPDeflationComputeFunction(extop,lambda,&T);CHKERRQ(ierr);
     134         295 :     ierr = MatMult(T,u,r);CHKERRQ(ierr);
     135             : 
     136             :     /* convergence test */
     137         295 :     perr = nep->errest[nep->nconv];
     138         295 :     ierr = VecNorm(r,NORM_2,&resnorm);CHKERRQ(ierr);
     139         295 :     ierr = (*nep->converged)(nep,lambda,0,resnorm,&nep->errest[nep->nconv],nep->convergedctx);CHKERRQ(ierr);
     140         295 :     nep->eigr[nep->nconv] = lambda;
     141         295 :     if (its>1 && (nep->errest[nep->nconv]<=nep->tol || nep->errest[nep->nconv]<=ctx->deftol)) {
     142          30 :       if (nep->errest[nep->nconv]<=ctx->deftol && !extop->ref && nep->nconv) {
     143           4 :         ierr = NEPDeflationExtractEigenpair(extop,nep->nconv,u,lambda,nep->ds);CHKERRQ(ierr);
     144           4 :         ierr = NEPDeflationSetRefine(extop,PETSC_TRUE);CHKERRQ(ierr);
     145           4 :         ierr = MatMult(T,u,r);CHKERRQ(ierr);
     146           4 :         ierr = VecNorm(r,NORM_2,&resnorm);CHKERRQ(ierr);
     147           4 :         ierr = (*nep->converged)(nep,lambda,0,resnorm,&nep->errest[nep->nconv],nep->convergedctx);CHKERRQ(ierr);
     148           4 :         if (nep->errest[nep->nconv]<=nep->tol) lock = PETSC_TRUE;
     149          26 :       } else if (nep->errest[nep->nconv]<=nep->tol) lock = PETSC_TRUE;
     150             :     }
     151         266 :     if (lock) {
     152          29 :       ierr = NEPDeflationSetRefine(extop,PETSC_FALSE);CHKERRQ(ierr);
     153          29 :       nep->nconv = nep->nconv + 1;
     154          29 :       ierr = NEPDeflationLocking(extop,u,lambda);CHKERRQ(ierr);
     155          29 :       nep->its += its;
     156          29 :       skip = PETSC_TRUE;
     157          29 :       lock = PETSC_FALSE;
     158             :     }
     159         295 :     ierr = (*nep->stopping)(nep,nep->its+its,nep->max_it,nep->nconv,nep->nev,&nep->reason,nep->stoppingctx);CHKERRQ(ierr);
     160         295 :     if (!skip || nep->reason>0) {
     161         284 :       ierr = NEPMonitor(nep,nep->its+its,nep->nconv,nep->eigr,nep->eigi,nep->errest,(nep->reason>0)?nep->nconv:nep->nconv+1);CHKERRQ(ierr);
     162             :     }
     163             : 
     164         295 :     if (nep->reason == NEP_CONVERGED_ITERATING) {
     165         277 :       if (!skip) {
     166             :         /* update preconditioner and set adaptive tolerance */
     167         266 :         if (ctx->lag && !(its%ctx->lag) && its>=2*ctx->lag && perr && nep->errest[nep->nconv]>.5*perr) {
     168          31 :           ierr = NEPDeflationSolveSetUp(extop,lambda2);CHKERRQ(ierr);
     169             :         }
     170         266 :         if (!ctx->cctol) {
     171         258 :           ktol = PetscMax(ktol/2.0,rtol);
     172         258 :           ierr = KSPSetTolerances(ctx->ksp,ktol,PETSC_DEFAULT,PETSC_DEFAULT,PETSC_DEFAULT);CHKERRQ(ierr);
     173             :         }
     174             : 
     175             :         /* eigenvector correction: delta = T(sigma)\r */
     176         266 :         ierr = NEPDeflationFunctionSolve(extop,r,delta);CHKERRQ(ierr);
     177         266 :         ierr = KSPGetConvergedReason(ctx->ksp,&kspreason);CHKERRQ(ierr);
     178         266 :         if (kspreason<0) {
     179           0 :           ierr = PetscInfo1(nep,"iter=%D, linear solve failed, stopping solve\n",nep->its);CHKERRQ(ierr);
     180           0 :           nep->reason = NEP_DIVERGED_LINEAR_SOLVE;
     181           0 :           break;
     182             :         }
     183             : 
     184             :         /* update eigenvector: u = u - delta */
     185         266 :         ierr = VecAXPY(u,-1.0,delta);CHKERRQ(ierr);
     186             : 
     187             :         /* normalize eigenvector */
     188         266 :         ierr = VecNormalize(u,NULL);CHKERRQ(ierr);
     189             :       } else {
     190          11 :         its = -1;
     191          11 :         ierr = NEPDeflationSetRandomVec(extop,u);CHKERRQ(ierr);
     192          11 :         ierr = NEPDeflationSolveSetUp(extop,sigma);CHKERRQ(ierr);
     193          11 :         ierr = VecCopy(u,r);CHKERRQ(ierr);
     194          11 :         ierr = NEPDeflationFunctionSolve(extop,r,u);CHKERRQ(ierr);
     195          11 :         ierr = VecNorm(u,NORM_2,&nrm);CHKERRQ(ierr);
     196          11 :         ierr = VecScale(u,1.0/nrm);CHKERRQ(ierr);
     197          11 :         lambda = sigma;
     198          11 :         skip = PETSC_FALSE;
     199             :       }
     200             :     }
     201             :   }
     202          18 :   ierr = NEPDeflationGetInvariantPair(extop,NULL,&H);CHKERRQ(ierr);
     203          18 :   ierr = MatGetSize(H,NULL,&ldh);CHKERRQ(ierr);
     204          18 :   ierr = DSSetType(nep->ds,DSNHEP);CHKERRQ(ierr);
     205          18 :   ierr = DSReset(nep->ds);CHKERRQ(ierr);
     206          18 :   ierr = DSAllocate(nep->ds,PetscMax(nep->nconv,1));CHKERRQ(ierr);
     207          18 :   ierr = DSGetLeadingDimension(nep->ds,&ldds);CHKERRQ(ierr);
     208          18 :   ierr = MatDenseGetArrayRead(H,&Hp);CHKERRQ(ierr);
     209          18 :   ierr = DSGetArray(nep->ds,DS_MAT_A,&Ap);CHKERRQ(ierr);
     210          47 :   for (j=0;j<nep->nconv;j++)
     211          90 :     for (i=0;i<nep->nconv;i++) Ap[j*ldds+i] = Hp[j*ldh+i];
     212          18 :   ierr = DSRestoreArray(nep->ds,DS_MAT_A,&Ap);CHKERRQ(ierr);
     213          18 :   ierr = MatDenseRestoreArrayRead(H,&Hp);CHKERRQ(ierr);
     214          18 :   ierr = MatDestroy(&H);CHKERRQ(ierr);
     215          18 :   ierr = DSSetDimensions(nep->ds,nep->nconv,0,nep->nconv);CHKERRQ(ierr);
     216          18 :   ierr = DSSolve(nep->ds,nep->eigr,nep->eigi);CHKERRQ(ierr);
     217          18 :   ierr = NEPDeflationReset(extop);CHKERRQ(ierr);
     218          18 :   ierr = VecDestroy(&u);CHKERRQ(ierr);
     219          18 :   ierr = VecDestroy(&r);CHKERRQ(ierr);
     220          18 :   ierr = VecDestroy(&delta);CHKERRQ(ierr);
     221          18 :   PetscFunctionReturn(0);
     222             : }
     223             : 
     224          16 : PetscErrorCode NEPSetFromOptions_RII(PetscOptionItems *PetscOptionsObject,NEP nep)
     225             : {
     226          16 :   PetscErrorCode ierr;
     227          16 :   NEP_RII        *ctx = (NEP_RII*)nep->data;
     228          16 :   PetscBool      flg;
     229          16 :   PetscInt       i;
     230          16 :   PetscReal      r;
     231             : 
     232          16 :   PetscFunctionBegin;
     233          16 :   ierr = PetscOptionsHead(PetscOptionsObject,"NEP RII Options");CHKERRQ(ierr);
     234             : 
     235          16 :     i = 0;
     236          16 :     ierr = PetscOptionsInt("-nep_rii_max_it","Maximum number of Newton iterations for updating Rayleigh functional","NEPRIISetMaximumIterations",ctx->max_inner_it,&i,&flg);CHKERRQ(ierr);
     237          16 :     if (flg) { ierr = NEPRIISetMaximumIterations(nep,i);CHKERRQ(ierr); }
     238             : 
     239          16 :     ierr = PetscOptionsBool("-nep_rii_const_correction_tol","Constant correction tolerance for the linear solver","NEPRIISetConstCorrectionTol",ctx->cctol,&ctx->cctol,NULL);CHKERRQ(ierr);
     240             : 
     241          16 :     ierr = PetscOptionsBool("-nep_rii_hermitian","Use Hermitian version of the scalar nonlinear equation","NEPRIISetHermitian",ctx->herm,&ctx->herm,NULL);CHKERRQ(ierr);
     242             : 
     243          16 :     i = 0;
     244          16 :     ierr = PetscOptionsInt("-nep_rii_lag_preconditioner","Interval to rebuild preconditioner","NEPRIISetLagPreconditioner",ctx->lag,&i,&flg);CHKERRQ(ierr);
     245          16 :     if (flg) { ierr = NEPRIISetLagPreconditioner(nep,i);CHKERRQ(ierr); }
     246             : 
     247          16 :     r = 0.0;
     248          16 :     ierr = PetscOptionsReal("-nep_rii_deflation_threshold","Tolerance used as a threshold for including deflated eigenpairs","NEPRIISetDeflationThreshold",ctx->deftol,&r,&flg);CHKERRQ(ierr);
     249          16 :     if (flg) { ierr = NEPRIISetDeflationThreshold(nep,r);CHKERRQ(ierr); }
     250             : 
     251          16 :   ierr = PetscOptionsTail();CHKERRQ(ierr);
     252             : 
     253          16 :   if (!ctx->ksp) { ierr = NEPRIIGetKSP(nep,&ctx->ksp);CHKERRQ(ierr); }
     254          16 :   ierr = KSPSetFromOptions(ctx->ksp);CHKERRQ(ierr);
     255          16 :   PetscFunctionReturn(0);
     256             : }
     257             : 
     258           1 : static PetscErrorCode NEPRIISetMaximumIterations_RII(NEP nep,PetscInt its)
     259             : {
     260           1 :   NEP_RII *ctx = (NEP_RII*)nep->data;
     261             : 
     262           1 :   PetscFunctionBegin;
     263           1 :   if (its==PETSC_DEFAULT) ctx->max_inner_it = 10;
     264             :   else {
     265           1 :     if (its<=0) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_OUTOFRANGE,"Number of iterations must be >0");
     266           1 :     ctx->max_inner_it = its;
     267             :   }
     268           1 :   PetscFunctionReturn(0);
     269             : }
     270             : 
     271             : /*@
     272             :    NEPRIISetMaximumIterations - Sets the maximum number of inner iterations to be
     273             :    used in the RII solver. These are the Newton iterations related to the computation
     274             :    of the nonlinear Rayleigh functional.
     275             : 
     276             :    Logically Collective on nep
     277             : 
     278             :    Input Parameters:
     279             : +  nep - nonlinear eigenvalue solver
     280             : -  its - maximum inner iterations
     281             : 
     282             :    Level: advanced
     283             : 
     284             : .seealso: NEPRIIGetMaximumIterations()
     285             : @*/
     286           1 : PetscErrorCode NEPRIISetMaximumIterations(NEP nep,PetscInt its)
     287             : {
     288           1 :   PetscErrorCode ierr;
     289             : 
     290           1 :   PetscFunctionBegin;
     291           1 :   PetscValidHeaderSpecific(nep,NEP_CLASSID,1);
     292           2 :   PetscValidLogicalCollectiveInt(nep,its,2);
     293           1 :   ierr = PetscTryMethod(nep,"NEPRIISetMaximumIterations_C",(NEP,PetscInt),(nep,its));CHKERRQ(ierr);
     294           1 :   PetscFunctionReturn(0);
     295             : }
     296             : 
     297           1 : static PetscErrorCode NEPRIIGetMaximumIterations_RII(NEP nep,PetscInt *its)
     298             : {
     299           1 :   NEP_RII *ctx = (NEP_RII*)nep->data;
     300             : 
     301           1 :   PetscFunctionBegin;
     302           1 :   *its = ctx->max_inner_it;
     303           1 :   PetscFunctionReturn(0);
     304             : }
     305             : 
     306             : /*@
     307             :    NEPRIIGetMaximumIterations - Gets the maximum number of inner iterations of RII.
     308             : 
     309             :    Not Collective
     310             : 
     311             :    Input Parameter:
     312             : .  nep - nonlinear eigenvalue solver
     313             : 
     314             :    Output Parameter:
     315             : .  its - maximum inner iterations
     316             : 
     317             :    Level: advanced
     318             : 
     319             : .seealso: NEPRIISetMaximumIterations()
     320             : @*/
     321           1 : PetscErrorCode NEPRIIGetMaximumIterations(NEP nep,PetscInt *its)
     322             : {
     323           1 :   PetscErrorCode ierr;
     324             : 
     325           1 :   PetscFunctionBegin;
     326           1 :   PetscValidHeaderSpecific(nep,NEP_CLASSID,1);
     327           1 :   PetscValidIntPointer(its,2);
     328           1 :   ierr = PetscUseMethod(nep,"NEPRIIGetMaximumIterations_C",(NEP,PetscInt*),(nep,its));CHKERRQ(ierr);
     329           1 :   PetscFunctionReturn(0);
     330             : }
     331             : 
     332           3 : static PetscErrorCode NEPRIISetLagPreconditioner_RII(NEP nep,PetscInt lag)
     333             : {
     334           3 :   NEP_RII *ctx = (NEP_RII*)nep->data;
     335             : 
     336           3 :   PetscFunctionBegin;
     337           3 :   if (lag<0) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_ARG_OUTOFRANGE,"Lag must be non-negative");
     338           3 :   ctx->lag = lag;
     339           3 :   PetscFunctionReturn(0);
     340             : }
     341             : 
     342             : /*@
     343             :    NEPRIISetLagPreconditioner - Determines when the preconditioner is rebuilt in the
     344             :    nonlinear solve.
     345             : 
     346             :    Logically Collective on nep
     347             : 
     348             :    Input Parameters:
     349             : +  nep - nonlinear eigenvalue solver
     350             : -  lag - 0 indicates NEVER rebuild, 1 means rebuild every time the Jacobian is
     351             :           computed within the nonlinear iteration, 2 means every second time
     352             :           the Jacobian is built, etc.
     353             : 
     354             :    Options Database Keys:
     355             : .  -nep_rii_lag_preconditioner <lag> - the lag value
     356             : 
     357             :    Notes:
     358             :    The default is 1.
     359             :    The preconditioner is ALWAYS built in the first iteration of a nonlinear solve.
     360             : 
     361             :    Level: intermediate
     362             : 
     363             : .seealso: NEPRIIGetLagPreconditioner()
     364             : @*/
     365          18 : PetscErrorCode NEPRIISetLagPreconditioner(NEP nep,PetscInt lag)
     366             : {
     367          18 :   PetscErrorCode ierr;
     368             : 
     369          18 :   PetscFunctionBegin;
     370          18 :   PetscValidHeaderSpecific(nep,NEP_CLASSID,1);
     371          36 :   PetscValidLogicalCollectiveInt(nep,lag,2);
     372          18 :   ierr = PetscTryMethod(nep,"NEPRIISetLagPreconditioner_C",(NEP,PetscInt),(nep,lag));CHKERRQ(ierr);
     373          18 :   PetscFunctionReturn(0);
     374             : }
     375             : 
     376           1 : static PetscErrorCode NEPRIIGetLagPreconditioner_RII(NEP nep,PetscInt *lag)
     377             : {
     378           1 :   NEP_RII *ctx = (NEP_RII*)nep->data;
     379             : 
     380           1 :   PetscFunctionBegin;
     381           1 :   *lag = ctx->lag;
     382           1 :   PetscFunctionReturn(0);
     383             : }
     384             : 
     385             : /*@
     386             :    NEPRIIGetLagPreconditioner - Indicates how often the preconditioner is rebuilt.
     387             : 
     388             :    Not Collective
     389             : 
     390             :    Input Parameter:
     391             : .  nep - nonlinear eigenvalue solver
     392             : 
     393             :    Output Parameter:
     394             : .  lag - the lag parameter
     395             : 
     396             :    Level: intermediate
     397             : 
     398             : .seealso: NEPRIISetLagPreconditioner()
     399             : @*/
     400           1 : PetscErrorCode NEPRIIGetLagPreconditioner(NEP nep,PetscInt *lag)
     401             : {
     402           1 :   PetscErrorCode ierr;
     403             : 
     404           1 :   PetscFunctionBegin;
     405           1 :   PetscValidHeaderSpecific(nep,NEP_CLASSID,1);
     406           1 :   PetscValidIntPointer(lag,2);
     407           1 :   ierr = PetscUseMethod(nep,"NEPRIIGetLagPreconditioner_C",(NEP,PetscInt*),(nep,lag));CHKERRQ(ierr);
     408           1 :   PetscFunctionReturn(0);
     409             : }
     410             : 
     411           1 : static PetscErrorCode NEPRIISetConstCorrectionTol_RII(NEP nep,PetscBool cct)
     412             : {
     413           1 :   NEP_RII *ctx = (NEP_RII*)nep->data;
     414             : 
     415           1 :   PetscFunctionBegin;
     416           1 :   ctx->cctol = cct;
     417           1 :   PetscFunctionReturn(0);
     418             : }
     419             : 
     420             : /*@
     421             :    NEPRIISetConstCorrectionTol - Sets a flag to keep the tolerance used
     422             :    in the linear solver constant.
     423             : 
     424             :    Logically Collective on nep
     425             : 
     426             :    Input Parameters:
     427             : +  nep - nonlinear eigenvalue solver
     428             : -  cct - a boolean value
     429             : 
     430             :    Options Database Keys:
     431             : .  -nep_rii_const_correction_tol <bool> - set the boolean flag
     432             : 
     433             :    Notes:
     434             :    By default, an exponentially decreasing tolerance is set in the KSP used
     435             :    within the nonlinear iteration, so that each Newton iteration requests
     436             :    better accuracy than the previous one. The constant correction tolerance
     437             :    flag stops this behaviour.
     438             : 
     439             :    Level: intermediate
     440             : 
     441             : .seealso: NEPRIIGetConstCorrectionTol()
     442             : @*/
     443           1 : PetscErrorCode NEPRIISetConstCorrectionTol(NEP nep,PetscBool cct)
     444             : {
     445           1 :   PetscErrorCode ierr;
     446             : 
     447           1 :   PetscFunctionBegin;
     448           1 :   PetscValidHeaderSpecific(nep,NEP_CLASSID,1);
     449           2 :   PetscValidLogicalCollectiveBool(nep,cct,2);
     450           1 :   ierr = PetscTryMethod(nep,"NEPRIISetConstCorrectionTol_C",(NEP,PetscBool),(nep,cct));CHKERRQ(ierr);
     451           1 :   PetscFunctionReturn(0);
     452             : }
     453             : 
     454           1 : static PetscErrorCode NEPRIIGetConstCorrectionTol_RII(NEP nep,PetscBool *cct)
     455             : {
     456           1 :   NEP_RII *ctx = (NEP_RII*)nep->data;
     457             : 
     458           1 :   PetscFunctionBegin;
     459           1 :   *cct = ctx->cctol;
     460           1 :   PetscFunctionReturn(0);
     461             : }
     462             : 
     463             : /*@
     464             :    NEPRIIGetConstCorrectionTol - Returns the constant tolerance flag.
     465             : 
     466             :    Not Collective
     467             : 
     468             :    Input Parameter:
     469             : .  nep - nonlinear eigenvalue solver
     470             : 
     471             :    Output Parameter:
     472             : .  cct - the value of the constant tolerance flag
     473             : 
     474             :    Level: intermediate
     475             : 
     476             : .seealso: NEPRIISetConstCorrectionTol()
     477             : @*/
     478           1 : PetscErrorCode NEPRIIGetConstCorrectionTol(NEP nep,PetscBool *cct)
     479             : {
     480           1 :   PetscErrorCode ierr;
     481             : 
     482           1 :   PetscFunctionBegin;
     483           1 :   PetscValidHeaderSpecific(nep,NEP_CLASSID,1);
     484           1 :   PetscValidBoolPointer(cct,2);
     485           1 :   ierr = PetscUseMethod(nep,"NEPRIIGetConstCorrectionTol_C",(NEP,PetscBool*),(nep,cct));CHKERRQ(ierr);
     486           1 :   PetscFunctionReturn(0);
     487             : }
     488             : 
     489           1 : static PetscErrorCode NEPRIISetHermitian_RII(NEP nep,PetscBool herm)
     490             : {
     491           1 :   NEP_RII *ctx = (NEP_RII*)nep->data;
     492             : 
     493           1 :   PetscFunctionBegin;
     494           1 :   ctx->herm = herm;
     495           1 :   PetscFunctionReturn(0);
     496             : }
     497             : 
     498             : /*@
     499             :    NEPRIISetHermitian - Sets a flag to indicate if the Hermitian version of the
     500             :    scalar nonlinear equation must be used by the solver.
     501             : 
     502             :    Logically Collective on nep
     503             : 
     504             :    Input Parameters:
     505             : +  nep  - nonlinear eigenvalue solver
     506             : -  herm - a boolean value
     507             : 
     508             :    Options Database Keys:
     509             : .  -nep_rii_hermitian <bool> - set the boolean flag
     510             : 
     511             :    Notes:
     512             :    By default, the scalar nonlinear equation x'*inv(T(sigma))*T(z)*x=0 is solved
     513             :    at each step of the nonlinear iteration. When this flag is set the simpler
     514             :    form x'*T(z)*x=0 is used, which is supposed to be valid only for Hermitian
     515             :    problems.
     516             : 
     517             :    Level: intermediate
     518             : 
     519             : .seealso: NEPRIIGetHermitian()
     520             : @*/
     521           1 : PetscErrorCode NEPRIISetHermitian(NEP nep,PetscBool herm)
     522             : {
     523           1 :   PetscErrorCode ierr;
     524             : 
     525           1 :   PetscFunctionBegin;
     526           1 :   PetscValidHeaderSpecific(nep,NEP_CLASSID,1);
     527           2 :   PetscValidLogicalCollectiveBool(nep,herm,2);
     528           1 :   ierr = PetscTryMethod(nep,"NEPRIISetHermitian_C",(NEP,PetscBool),(nep,herm));CHKERRQ(ierr);
     529           1 :   PetscFunctionReturn(0);
     530             : }
     531             : 
     532           1 : static PetscErrorCode NEPRIIGetHermitian_RII(NEP nep,PetscBool *herm)
     533             : {
     534           1 :   NEP_RII *ctx = (NEP_RII*)nep->data;
     535             : 
     536           1 :   PetscFunctionBegin;
     537           1 :   *herm = ctx->herm;
     538           1 :   PetscFunctionReturn(0);
     539             : }
     540             : 
     541             : /*@
     542             :    NEPRIIGetHermitian - Returns the flag about using the Hermitian version of
     543             :    the scalar nonlinear equation.
     544             : 
     545             :    Not Collective
     546             : 
     547             :    Input Parameter:
     548             : .  nep - nonlinear eigenvalue solver
     549             : 
     550             :    Output Parameter:
     551             : .  herm - the value of the hermitian flag
     552             : 
     553             :    Level: intermediate
     554             : 
     555             : .seealso: NEPRIISetHermitian()
     556             : @*/
     557           1 : PetscErrorCode NEPRIIGetHermitian(NEP nep,PetscBool *herm)
     558             : {
     559           1 :   PetscErrorCode ierr;
     560             : 
     561           1 :   PetscFunctionBegin;
     562           1 :   PetscValidHeaderSpecific(nep,NEP_CLASSID,1);
     563           1 :   PetscValidBoolPointer(herm,2);
     564           1 :   ierr = PetscUseMethod(nep,"NEPRIIGetHermitian_C",(NEP,PetscBool*),(nep,herm));CHKERRQ(ierr);
     565           1 :   PetscFunctionReturn(0);
     566             : }
     567             : 
     568           2 : static PetscErrorCode NEPRIISetDeflationThreshold_RII(NEP nep,PetscReal deftol)
     569             : {
     570           2 :   NEP_RII *ctx = (NEP_RII*)nep->data;
     571             : 
     572           2 :   PetscFunctionBegin;
     573           2 :   ctx->deftol = deftol;
     574           2 :   PetscFunctionReturn(0);
     575             : }
     576             : 
     577             : /*@
     578             :    NEPRIISetDeflationThreshold - Sets the threshold value used to switch between
     579             :    deflated and non-deflated iteration.
     580             : 
     581             :    Logically Collective on nep
     582             : 
     583             :    Input Parameters:
     584             : +  nep    - nonlinear eigenvalue solver
     585             : -  deftol - the threshold value
     586             : 
     587             :    Options Database Keys:
     588             : .  -nep_rii_deflation_threshold <deftol> - set the threshold
     589             : 
     590             :    Notes:
     591             :    Normally, the solver iterates on the extended problem in order to deflate
     592             :    previously converged eigenpairs. If this threshold is set to a nonzero value,
     593             :    then once the residual error is below this threshold the solver will
     594             :    continue the iteration without deflation. The intention is to be able to
     595             :    improve the current eigenpair further, despite having previous eigenpairs
     596             :    with somewhat bad precision.
     597             : 
     598             :    Level: advanced
     599             : 
     600             : .seealso: NEPRIIGetDeflationThreshold()
     601             : @*/
     602           2 : PetscErrorCode NEPRIISetDeflationThreshold(NEP nep,PetscReal deftol)
     603             : {
     604           2 :   PetscErrorCode ierr;
     605             : 
     606           2 :   PetscFunctionBegin;
     607           2 :   PetscValidHeaderSpecific(nep,NEP_CLASSID,1);
     608           4 :   PetscValidLogicalCollectiveReal(nep,deftol,2);
     609           2 :   ierr = PetscTryMethod(nep,"NEPRIISetDeflationThreshold_C",(NEP,PetscReal),(nep,deftol));CHKERRQ(ierr);
     610           2 :   PetscFunctionReturn(0);
     611             : }
     612             : 
     613           1 : static PetscErrorCode NEPRIIGetDeflationThreshold_RII(NEP nep,PetscReal *deftol)
     614             : {
     615           1 :   NEP_RII *ctx = (NEP_RII*)nep->data;
     616             : 
     617           1 :   PetscFunctionBegin;
     618           1 :   *deftol = ctx->deftol;
     619           1 :   PetscFunctionReturn(0);
     620             : }
     621             : 
     622             : /*@
     623             :    NEPRIIGetDeflationThreshold - Returns the threshold value that controls deflation.
     624             : 
     625             :    Not Collective
     626             : 
     627             :    Input Parameter:
     628             : .  nep - nonlinear eigenvalue solver
     629             : 
     630             :    Output Parameter:
     631             : .  deftol - the threshold
     632             : 
     633             :    Level: advanced
     634             : 
     635             : .seealso: NEPRIISetDeflationThreshold()
     636             : @*/
     637           1 : PetscErrorCode NEPRIIGetDeflationThreshold(NEP nep,PetscReal *deftol)
     638             : {
     639           1 :   PetscErrorCode ierr;
     640             : 
     641           1 :   PetscFunctionBegin;
     642           1 :   PetscValidHeaderSpecific(nep,NEP_CLASSID,1);
     643           1 :   PetscValidRealPointer(deftol,2);
     644           1 :   ierr = PetscUseMethod(nep,"NEPRIIGetDeflationThreshold_C",(NEP,PetscReal*),(nep,deftol));CHKERRQ(ierr);
     645           1 :   PetscFunctionReturn(0);
     646             : }
     647             : 
     648           1 : static PetscErrorCode NEPRIISetKSP_RII(NEP nep,KSP ksp)
     649             : {
     650           1 :   PetscErrorCode ierr;
     651           1 :   NEP_RII        *ctx = (NEP_RII*)nep->data;
     652             : 
     653           1 :   PetscFunctionBegin;
     654           1 :   ierr = PetscObjectReference((PetscObject)ksp);CHKERRQ(ierr);
     655           1 :   ierr = KSPDestroy(&ctx->ksp);CHKERRQ(ierr);
     656           1 :   ctx->ksp = ksp;
     657           1 :   ierr = PetscLogObjectParent((PetscObject)nep,(PetscObject)ctx->ksp);CHKERRQ(ierr);
     658           1 :   nep->state = NEP_STATE_INITIAL;
     659           1 :   PetscFunctionReturn(0);
     660             : }
     661             : 
     662             : /*@
     663             :    NEPRIISetKSP - Associate a linear solver object (KSP) to the nonlinear
     664             :    eigenvalue solver.
     665             : 
     666             :    Collective on nep
     667             : 
     668             :    Input Parameters:
     669             : +  nep - eigenvalue solver
     670             : -  ksp - the linear solver object
     671             : 
     672             :    Level: advanced
     673             : 
     674             : .seealso: NEPRIIGetKSP()
     675             : @*/
     676           1 : PetscErrorCode NEPRIISetKSP(NEP nep,KSP ksp)
     677             : {
     678           1 :   PetscErrorCode ierr;
     679             : 
     680           1 :   PetscFunctionBegin;
     681           1 :   PetscValidHeaderSpecific(nep,NEP_CLASSID,1);
     682           1 :   PetscValidHeaderSpecific(ksp,KSP_CLASSID,2);
     683           1 :   PetscCheckSameComm(nep,1,ksp,2);
     684           1 :   ierr = PetscTryMethod(nep,"NEPRIISetKSP_C",(NEP,KSP),(nep,ksp));CHKERRQ(ierr);
     685           1 :   PetscFunctionReturn(0);
     686             : }
     687             : 
     688          16 : static PetscErrorCode NEPRIIGetKSP_RII(NEP nep,KSP *ksp)
     689             : {
     690          16 :   PetscErrorCode ierr;
     691          16 :   NEP_RII        *ctx = (NEP_RII*)nep->data;
     692             : 
     693          16 :   PetscFunctionBegin;
     694          16 :   if (!ctx->ksp) {
     695          16 :     ierr = KSPCreate(PetscObjectComm((PetscObject)nep),&ctx->ksp);CHKERRQ(ierr);
     696          16 :     ierr = PetscObjectIncrementTabLevel((PetscObject)ctx->ksp,(PetscObject)nep,1);CHKERRQ(ierr);
     697          16 :     ierr = KSPSetOptionsPrefix(ctx->ksp,((PetscObject)nep)->prefix);CHKERRQ(ierr);
     698          16 :     ierr = KSPAppendOptionsPrefix(ctx->ksp,"nep_rii_");CHKERRQ(ierr);
     699          16 :     ierr = PetscLogObjectParent((PetscObject)nep,(PetscObject)ctx->ksp);CHKERRQ(ierr);
     700          16 :     ierr = PetscObjectSetOptions((PetscObject)ctx->ksp,((PetscObject)nep)->options);CHKERRQ(ierr);
     701          16 :     ierr = KSPSetErrorIfNotConverged(ctx->ksp,PETSC_TRUE);CHKERRQ(ierr);
     702          27 :     ierr = KSPSetTolerances(ctx->ksp,SlepcDefaultTol(nep->tol),PETSC_DEFAULT,PETSC_DEFAULT,PETSC_DEFAULT);CHKERRQ(ierr);
     703             :   }
     704          16 :   *ksp = ctx->ksp;
     705          16 :   PetscFunctionReturn(0);
     706             : }
     707             : 
     708             : /*@
     709             :    NEPRIIGetKSP - Retrieve the linear solver object (KSP) associated with
     710             :    the nonlinear eigenvalue solver.
     711             : 
     712             :    Not Collective
     713             : 
     714             :    Input Parameter:
     715             : .  nep - nonlinear eigenvalue solver
     716             : 
     717             :    Output Parameter:
     718             : .  ksp - the linear solver object
     719             : 
     720             :    Level: advanced
     721             : 
     722             : .seealso: NEPRIISetKSP()
     723             : @*/
     724          16 : PetscErrorCode NEPRIIGetKSP(NEP nep,KSP *ksp)
     725             : {
     726          16 :   PetscErrorCode ierr;
     727             : 
     728          16 :   PetscFunctionBegin;
     729          16 :   PetscValidHeaderSpecific(nep,NEP_CLASSID,1);
     730          16 :   PetscValidPointer(ksp,2);
     731          16 :   ierr = PetscUseMethod(nep,"NEPRIIGetKSP_C",(NEP,KSP*),(nep,ksp));CHKERRQ(ierr);
     732          16 :   PetscFunctionReturn(0);
     733             : }
     734             : 
     735           0 : PetscErrorCode NEPView_RII(NEP nep,PetscViewer viewer)
     736             : {
     737           0 :   PetscErrorCode ierr;
     738           0 :   NEP_RII        *ctx = (NEP_RII*)nep->data;
     739           0 :   PetscBool      isascii;
     740             : 
     741           0 :   PetscFunctionBegin;
     742           0 :   ierr = PetscObjectTypeCompare((PetscObject)viewer,PETSCVIEWERASCII,&isascii);CHKERRQ(ierr);
     743           0 :   if (isascii) {
     744           0 :     ierr = PetscViewerASCIIPrintf(viewer,"  maximum number of inner iterations: %D\n",ctx->max_inner_it);CHKERRQ(ierr);
     745           0 :     if (ctx->cctol) {
     746           0 :       ierr = PetscViewerASCIIPrintf(viewer,"  using a constant tolerance for the linear solver\n");CHKERRQ(ierr);
     747             :     }
     748           0 :     if (ctx->herm) {
     749           0 :       ierr = PetscViewerASCIIPrintf(viewer,"  using the Hermitian version of the scalar nonlinear equation\n");CHKERRQ(ierr);
     750             :     }
     751           0 :     if (ctx->lag) {
     752           0 :       ierr = PetscViewerASCIIPrintf(viewer,"  updating the preconditioner every %D iterations\n",ctx->lag);CHKERRQ(ierr);
     753             :     }
     754           0 :     if (ctx->deftol) {
     755           0 :       ierr = PetscViewerASCIIPrintf(viewer,"  deflation threshold: %g\n",(double)ctx->deftol);CHKERRQ(ierr);
     756             :     }
     757           0 :     if (!ctx->ksp) { ierr = NEPRIIGetKSP(nep,&ctx->ksp);CHKERRQ(ierr); }
     758           0 :     ierr = PetscViewerASCIIPushTab(viewer);CHKERRQ(ierr);
     759           0 :     ierr = KSPView(ctx->ksp,viewer);CHKERRQ(ierr);
     760           0 :     ierr = PetscViewerASCIIPopTab(viewer);CHKERRQ(ierr);
     761             :   }
     762           0 :   PetscFunctionReturn(0);
     763             : }
     764             : 
     765          18 : PetscErrorCode NEPReset_RII(NEP nep)
     766             : {
     767          18 :   PetscErrorCode ierr;
     768          18 :   NEP_RII        *ctx = (NEP_RII*)nep->data;
     769             : 
     770          18 :   PetscFunctionBegin;
     771          18 :   ierr = KSPReset(ctx->ksp);CHKERRQ(ierr);
     772          18 :   PetscFunctionReturn(0);
     773             : }
     774             : 
     775          17 : PetscErrorCode NEPDestroy_RII(NEP nep)
     776             : {
     777          17 :   PetscErrorCode ierr;
     778          17 :   NEP_RII        *ctx = (NEP_RII*)nep->data;
     779             : 
     780          17 :   PetscFunctionBegin;
     781          17 :   ierr = KSPDestroy(&ctx->ksp);CHKERRQ(ierr);
     782          17 :   ierr = PetscFree(nep->data);CHKERRQ(ierr);
     783          17 :   ierr = PetscObjectComposeFunction((PetscObject)nep,"NEPRIISetMaximumIterations_C",NULL);CHKERRQ(ierr);
     784          17 :   ierr = PetscObjectComposeFunction((PetscObject)nep,"NEPRIIGetMaximumIterations_C",NULL);CHKERRQ(ierr);
     785          17 :   ierr = PetscObjectComposeFunction((PetscObject)nep,"NEPRIISetLagPreconditioner_C",NULL);CHKERRQ(ierr);
     786          17 :   ierr = PetscObjectComposeFunction((PetscObject)nep,"NEPRIIGetLagPreconditioner_C",NULL);CHKERRQ(ierr);
     787          17 :   ierr = PetscObjectComposeFunction((PetscObject)nep,"NEPRIISetConstCorrectionTol_C",NULL);CHKERRQ(ierr);
     788          17 :   ierr = PetscObjectComposeFunction((PetscObject)nep,"NEPRIIGetConstCorrectionTol_C",NULL);CHKERRQ(ierr);
     789          17 :   ierr = PetscObjectComposeFunction((PetscObject)nep,"NEPRIISetHermitian_C",NULL);CHKERRQ(ierr);
     790          17 :   ierr = PetscObjectComposeFunction((PetscObject)nep,"NEPRIIGetHermitian_C",NULL);CHKERRQ(ierr);
     791          17 :   ierr = PetscObjectComposeFunction((PetscObject)nep,"NEPRIISetDeflationThreshold_C",NULL);CHKERRQ(ierr);
     792          17 :   ierr = PetscObjectComposeFunction((PetscObject)nep,"NEPRIIGetDeflationThreshold_C",NULL);CHKERRQ(ierr);
     793          17 :   ierr = PetscObjectComposeFunction((PetscObject)nep,"NEPRIISetKSP_C",NULL);CHKERRQ(ierr);
     794          17 :   ierr = PetscObjectComposeFunction((PetscObject)nep,"NEPRIIGetKSP_C",NULL);CHKERRQ(ierr);
     795          17 :   PetscFunctionReturn(0);
     796             : }
     797             : 
     798          17 : SLEPC_EXTERN PetscErrorCode NEPCreate_RII(NEP nep)
     799             : {
     800          17 :   PetscErrorCode ierr;
     801          17 :   NEP_RII        *ctx;
     802             : 
     803          17 :   PetscFunctionBegin;
     804          17 :   ierr = PetscNewLog(nep,&ctx);CHKERRQ(ierr);
     805          17 :   nep->data = (void*)ctx;
     806          17 :   ctx->max_inner_it = 10;
     807          17 :   ctx->lag          = 1;
     808          17 :   ctx->cctol        = PETSC_FALSE;
     809          17 :   ctx->herm         = PETSC_FALSE;
     810          17 :   ctx->deftol       = 0.0;
     811             : 
     812          17 :   nep->useds = PETSC_TRUE;
     813             : 
     814          17 :   nep->ops->solve          = NEPSolve_RII;
     815          17 :   nep->ops->setup          = NEPSetUp_RII;
     816          17 :   nep->ops->setfromoptions = NEPSetFromOptions_RII;
     817          17 :   nep->ops->reset          = NEPReset_RII;
     818          17 :   nep->ops->destroy        = NEPDestroy_RII;
     819          17 :   nep->ops->view           = NEPView_RII;
     820          17 :   nep->ops->computevectors = NEPComputeVectors_Schur;
     821             : 
     822          17 :   ierr = PetscObjectComposeFunction((PetscObject)nep,"NEPRIISetMaximumIterations_C",NEPRIISetMaximumIterations_RII);CHKERRQ(ierr);
     823          17 :   ierr = PetscObjectComposeFunction((PetscObject)nep,"NEPRIIGetMaximumIterations_C",NEPRIIGetMaximumIterations_RII);CHKERRQ(ierr);
     824          17 :   ierr = PetscObjectComposeFunction((PetscObject)nep,"NEPRIISetLagPreconditioner_C",NEPRIISetLagPreconditioner_RII);CHKERRQ(ierr);
     825          17 :   ierr = PetscObjectComposeFunction((PetscObject)nep,"NEPRIIGetLagPreconditioner_C",NEPRIIGetLagPreconditioner_RII);CHKERRQ(ierr);
     826          17 :   ierr = PetscObjectComposeFunction((PetscObject)nep,"NEPRIISetConstCorrectionTol_C",NEPRIISetConstCorrectionTol_RII);CHKERRQ(ierr);
     827          17 :   ierr = PetscObjectComposeFunction((PetscObject)nep,"NEPRIIGetConstCorrectionTol_C",NEPRIIGetConstCorrectionTol_RII);CHKERRQ(ierr);
     828          17 :   ierr = PetscObjectComposeFunction((PetscObject)nep,"NEPRIISetHermitian_C",NEPRIISetHermitian_RII);CHKERRQ(ierr);
     829          17 :   ierr = PetscObjectComposeFunction((PetscObject)nep,"NEPRIIGetHermitian_C",NEPRIIGetHermitian_RII);CHKERRQ(ierr);
     830          17 :   ierr = PetscObjectComposeFunction((PetscObject)nep,"NEPRIISetDeflationThreshold_C",NEPRIISetDeflationThreshold_RII);CHKERRQ(ierr);
     831          17 :   ierr = PetscObjectComposeFunction((PetscObject)nep,"NEPRIIGetDeflationThreshold_C",NEPRIIGetDeflationThreshold_RII);CHKERRQ(ierr);
     832          17 :   ierr = PetscObjectComposeFunction((PetscObject)nep,"NEPRIISetKSP_C",NEPRIISetKSP_RII);CHKERRQ(ierr);
     833          17 :   ierr = PetscObjectComposeFunction((PetscObject)nep,"NEPRIIGetKSP_C",NEPRIIGetKSP_RII);CHKERRQ(ierr);
     834          17 :   PetscFunctionReturn(0);
     835             : }
     836             : 

Generated by: LCOV version 1.14