slepc4py.SLEPc.NEP#

class slepc4py.SLEPc.NEP#

Bases: Object

NEP.

Enumerations

`CISSExtraction`	NEP CISS extraction technique.
`Conv`	NEP convergence test.
`ConvergedReason`	NEP convergence reasons.
`ErrorType`	NEP error type to assess accuracy of computed solutions.
`ProblemType`	NEP problem type.
`Refine`	NEP refinement strategy.
`RefineScheme`	NEP scheme for solving linear systems during iterative refinement.
`Stop`	NEP stopping test.
`Type`	NEP type.
`Which`	NEP desired part of spectrum.

Methods Summary

`appendOptionsPrefix`([prefix])	Append to the prefix used for searching for all NEP options in the database.
`applyResolvent`(omega, v, r[, rg])	Apply the resolvent \(T^{-1}(z)\) to a given vector.
`cancelMonitor`()	Clear all monitors for a `NEP` object.
`computeError`(i[, etype])	Compute the error associated with the i-th computed eigenpair.
`create`([comm])	Create the NEP object.
`destroy`()	Destroy the NEP object.
`errorView`([etype, viewer])	Display the errors associated with the computed solution.
`getBV`()	Get the basis vectors object associated to the eigensolver.
`getCISSExtraction`()	Get the extraction technique used in the CISS solver.
`getCISSKSPs`()	Get the list of linear solver objects associated with the CISS solver.
`getCISSRefinement`()	Get the values of various refinement parameters in the CISS solver.
`getCISSSizes`()	Get the values of various size parameters in the CISS solver.
`getCISSThreshold`()	Get the values of various threshold parameters in the CISS solver.
`getConverged`()	Get the number of converged eigenpairs.
`getConvergedReason`()	Get the reason why the `solve()` iteration was stopped.
`getConvergenceTest`()	Get the method used to compute the error estimate used in the convergence test.
`getDS`()	Get the direct solver associated to the eigensolver.
`getDimensions`()	Get the number of eigenvalues to compute.
`getEigenpair`(i[, Vr, Vi])	Get the i-th solution of the eigenproblem as computed by `solve()`.
`getErrorEstimate`(i)	Get the error estimate associated to the i-th computed eigenpair.
`getFunction`()	Get the function to compute the nonlinear Function \(T(\lambda)\).
`getInterpolInterpolation`()	Get the tolerance and maximum degree for the interpolation polynomial.
`getInterpolPEP`()	Get the associated polynomial eigensolver object.
`getIterationNumber`()	Get the current iteration number.
`getJacobian`()	Get the function to compute the Jacobian \(T'(\lambda)\) and J.
`getLeftEigenvector`(i, Wr[, Wi])	Get the i-th left eigenvector as computed by `solve()`.
`getMonitor`()	Get the list of monitor functions.
`getNArnoldiKSP`()	Get the linear solver object associated with the nonlinear eigensolver.
`getNArnoldiLagPreconditioner`()	Get how often the preconditioner is rebuilt.
`getNLEIGSEPS`()	Get the linear eigensolver object associated with the nonlinear eigensolver.
`getNLEIGSFullBasis`()	Get the flag that indicates if NLEIGS is using the full-basis variant.
`getNLEIGSInterpolation`()	Get the tolerance and maximum degree for the interpolation polynomial.
`getNLEIGSKSPs`()	Get the list of linear solver objects associated with the NLEIGS solver.
`getNLEIGSLocking`()	Get the locking flag used in the NLEIGS method.
`getNLEIGSRKShifts`()	Get the list of shifts used in the Rational Krylov method.
`getNLEIGSRestart`()	Get the restart parameter used in the NLEIGS method.
`getOptionsPrefix`()	Get the prefix used for searching for all NEP options in the database.
`getProblemType`()	Get the problem type from the `NEP` object.
`getRG`()	Get the region object associated to the eigensolver.
`getRIIConstCorrectionTol`()	Get the constant tolerance flag.
`getRIIDeflationThreshold`()	Get the threshold value that controls deflation.
`getRIIHermitian`()	Get if the Hermitian version must be used by the solver.
`getRIIKSP`()	Get the linear solver object associated with the nonlinear eigensolver.
`getRIILagPreconditioner`()	Get how often the preconditioner is rebuilt.
`getRIIMaximumIterations`()	Get the maximum number of inner iterations of RII.
`getRefine`()	Get the refinement strategy used by the NEP object.
`getRefineKSP`()	Get the `KSP` object used by the eigensolver in the refinement phase.
`getSLPDeflationThreshold`()	Get the threshold value that controls deflation.
`getSLPEPS`()	Get the linear eigensolver object associated with the nonlinear eigensolver.
`getSLPEPSLeft`()	Get the left eigensolver.
`getSLPKSP`()	Get the linear solver object associated with the nonlinear eigensolver.
`getSplitOperator`()	Get the operator of the nonlinear eigenvalue problem in split form.
`getSplitPreconditioner`()	Get the operator of the split preconditioner.
`getStoppingTest`()	Get the stopping function.
`getTarget`()	Get the value of the target.
`getTolerances`()	Get the tolerance and maximum iteration count.
`getTrackAll`()	Get the flag indicating whether all residual norms must be computed.
`getTwoSided`()	Get the flag indicating if a two-sided variant is being used.
`getType`()	Get the NEP type of this object.
`getWhichEigenpairs`()	Get which portion of the spectrum is to be sought.
`reset`()	Reset the NEP object.
`setBV`(bv)	Set the basis vectors object associated to the eigensolver.
`setCISSExtraction`(extraction)	Set the extraction technique used in the CISS solver.
`setCISSRefinement`([inner, blsize])	Set the values of various refinement parameters in the CISS solver.
`setCISSSizes`([ip, bs, ms, npart, bsmax, ...])	Set the values of various size parameters in the CISS solver.
`setCISSThreshold`([delta, spur])	Set the values of various threshold parameters in the CISS solver.
`setConvergenceTest`(conv)	Set how to compute the error estimate used in the convergence test.
`setDS`(ds)	Set a direct solver object associated to the eigensolver.
`setDimensions`([nev, ncv, mpd])	Set the number of eigenvalues to compute.
`setFromOptions`()	Set NEP options from the options database.
`setFunction`(function[, F, P, args, kargs])	Set the function to compute the nonlinear Function \(T(\lambda)\).
`setInitialSpace`(space)	Set the initial space from which the eigensolver starts to iterate.
`setInterpolInterpolation`([tol, deg])	Set the tolerance and maximum degree for the interpolation polynomial.
`setInterpolPEP`(pep)	Set a polynomial eigensolver object associated to the nonlinear eigensolver.
`setJacobian`(jacobian[, J, args, kargs])	Set the function to compute the Jacobian \(T'(\lambda)\).
`setMonitor`(monitor[, args, kargs])	Append a monitor function to the list of monitors.
`setNArnoldiKSP`(ksp)	Set a linear solver object associated to the nonlinear eigensolver.
`setNArnoldiLagPreconditioner`(lag)	Set when the preconditioner is rebuilt in the nonlinear solve.
`setNLEIGSEPS`(eps)	Set a linear eigensolver object associated to the nonlinear eigensolver.
`setNLEIGSFullBasis`([fullbasis])	Set TOAR-basis (default) or full-basis variants of the NLEIGS method.
`setNLEIGSInterpolation`([tol, deg])	Set the tolerance and maximum degree for the interpolation polynomial.
`setNLEIGSLocking`(lock)	Toggle between locking and non-locking variants of the NLEIGS method.
`setNLEIGSRKShifts`(shifts)	Set a list of shifts to be used in the Rational Krylov method.
`setNLEIGSRestart`(keep)	Set the restart parameter for the NLEIGS method.
`setOptionsPrefix`([prefix])	Set the prefix used for searching for all NEP options in the database.
`setProblemType`(problem_type)	Set the type of the eigenvalue problem.
`setRG`(rg)	Set a region object associated to the eigensolver.
`setRIIConstCorrectionTol`(cct)	Set a flag to keep the tolerance used in the linear solver constant.
`setRIIDeflationThreshold`(deftol)	Set the threshold used to switch between deflated and non-deflated.
`setRIIHermitian`(herm)	Set a flag to use the Hermitian version of the solver.
`setRIIKSP`(ksp)	Set a linear solver object associated to the nonlinear eigensolver.
`setRIILagPreconditioner`(lag)	Set when the preconditioner is rebuilt in the nonlinear solve.
`setRIIMaximumIterations`(its)	Set the max.
`setRefine`(ref[, npart, tol, its, scheme])	Set the refinement strategy used by the NEP object.
`setSLPDeflationThreshold`(deftol)	Set the threshold used to switch between deflated and non-deflated.
`setSLPEPS`(eps)	Set a linear eigensolver object associated to the nonlinear eigensolver.
`setSLPEPSLeft`(eps)	Set a linear eigensolver object associated to the nonlinear eigensolver.
`setSLPKSP`(ksp)	Set a linear solver object associated to the nonlinear eigensolver.
`setSplitOperator`(A, f[, structure])	Set the operator of the nonlinear eigenvalue problem in split form.
`setSplitPreconditioner`(P[, structure])	Set the operator in split form.
`setStoppingTest`(stopping[, args, kargs])	Set a function to decide when to stop the outer iteration of the eigensolver.
`setTarget`(target)	Set the value of the target.
`setTolerances`([tol, maxit])	Set the tolerance and max.
`setTrackAll`(trackall)	Set if the solver must compute the residual of all approximate eigenpairs.
`setTwoSided`(twosided)	Set the solver to use a two-sided variant.
`setType`(nep_type)	Set the particular solver to be used in the NEP object.
`setUp`()	Set up all the necessary internal data structures.
`setWhichEigenpairs`(which)	Set which portion of the spectrum is to be sought.
`solve`()	Solve the eigensystem.
`valuesView`([viewer])	Display the computed eigenvalues in a viewer.
`vectorsView`([viewer])	Output computed eigenvectors to a viewer.
`view`([viewer])	Print the NEP data structure.

Attributes Summary

`bv`	The basis vectors (BV) object associated.
`ds`	The direct solver (DS) object associated.
`max_it`	The maximum iteration count used by the NEP convergence tests.
`problem_type`	The problem type from the NEP object.
`rg`	The region (RG) object associated.
`target`	The value of the target.
`tol`	The tolerance used by the NEP convergence tests.
`track_all`	Compute the residual of all approximate eigenpairs.
`which`	The portion of the spectrum to be sought.

Methods Documentation

appendOptionsPrefix(prefix=None)#

Append to the prefix used for searching for all NEP options in the database.

Logically collective.

Parameters:: prefix (str | None) – The prefix string to prepend to all NEP option requests.
Return type:: None

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:289 <slepc4py/SLEPc/NEP.pyx#L289>`

applyResolvent(omega, v, r, rg=None)#

Apply the resolvent \(T^{-1}(z)\) to a given vector.

Collective.

Parameters:

omega (Scalar) – Value where the resolvent must be evaluated.
v (Vec) – Input vector.
r (Vec) – Placeholder for the result vector.
rg (RG | None) – Region.

Return type:

None

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:1339 <slepc4py/SLEPc/NEP.pyx#L1339>`

cancelMonitor()#

Clear all monitors for a NEP object.

Logically collective.

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:821 <slepc4py/SLEPc/NEP.pyx#L821>`

Return type:: None

computeError(i, etype=None)#

Compute the error associated with the i-th computed eigenpair.

Collective.

Compute the error (based on the residual norm) associated with the i-th computed eigenpair.

Parameters:

i (int) – Index of the solution to be considered.
etype (ErrorType | None) – The error type to compute.

Returns:

The error bound, computed in various ways from the residual norm \(\|T(\lambda)x\|_2\) where \(\lambda\) is the eigenvalue and \(x\) is the eigenvector.

Return type:

:py:any:`float`

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:978 <slepc4py/SLEPc/NEP.pyx#L978>`

create(comm=None)#

Create the NEP object.

Collective.

Parameters:: comm (Comm | None) – MPI communicator. If not provided, it defaults to all processes.
Return type:: Self

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:212 <slepc4py/SLEPc/NEP.pyx#L212>`

destroy()#

Destroy the NEP object.

Collective.

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:194 <slepc4py/SLEPc/NEP.pyx#L194>`

Return type:: Self

errorView(etype=None, viewer=None)#

Display the errors associated with the computed solution.

Collective.

Display the eigenvalues and the errors associated with the computed solution

Parameters:

etype (ErrorType | None) – The error type to compute.
viewer (petsc4py.PETSc.Viewer | None) – Visualization context; if not provided, the standard output is used.

Return type:

None

Notes

By default, this function checks the error of all eigenpairs and prints the eigenvalues if all of them are below the requested tolerance. If the viewer has format ASCII_INFO_DETAIL then a table with eigenvalues and corresponding errors is printed.

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:1007 <slepc4py/SLEPc/NEP.pyx#L1007>`

getBV()#

Get the basis vectors object associated to the eigensolver.

Not collective.

Returns:: The basis vectors context.
Return type:: :py:any:`BV`

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:653 <slepc4py/SLEPc/NEP.pyx#L653>`

getCISSExtraction()#

Get the extraction technique used in the CISS solver.

Not collective.

Returns:: The extraction technique.
Return type:: :py:any:`CISSExtraction`

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:2068 <slepc4py/SLEPc/NEP.pyx#L2068>`

getCISSKSPs()#

Get the list of linear solver objects associated with the CISS solver.

Collective.

Returns:: The linear solver objects.
Return type:: :py:any:`list` of petsc4py.PETSc.KSP

Notes

The number of petsc4py.PETSc.KSP solvers is equal to the number of integration points divided by the number of partitions. This value is halved in the case of real matrices with a region centered at the real axis.

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:2237 <slepc4py/SLEPc/NEP.pyx#L2237>`

getCISSRefinement()#

Get the values of various refinement parameters in the CISS solver.

Not collective.

Returns:

inner (:py:any:`int`) – Number of iterative refinement iterations (inner loop).
blsize (:py:any:`int`) – Number of iterative refinement iterations (blocksize loop).

Return type:

tuple[int, int]

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:2219 <slepc4py/SLEPc/NEP.pyx#L2219>`

getCISSSizes()#

Get the values of various size parameters in the CISS solver.

Not collective.

Returns:

ip (:py:any:`int`) – Number of integration points.
bs (:py:any:`int`) – Block size.
ms (:py:any:`int`) – Moment size.
npart (:py:any:`int`) – Number of partitions when splitting the communicator.
bsmax (:py:any:`int`) – Maximum block size.
realmats (:py:any:`bool`) – True if A and B are real.

Return type:

tuple[int, int, int, int, int, bool]

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:2133 <slepc4py/SLEPc/NEP.pyx#L2133>`

getCISSThreshold()#

Get the values of various threshold parameters in the CISS solver.

Not collective.

Returns:

delta (:py:any:`float`) – Threshold for numerical rank.
spur (:py:any:`float`) – Spurious threshold (to discard spurious eigenpairs.

Return type:

tuple[float, float]

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:2182 <slepc4py/SLEPc/NEP.pyx#L2182>`

getConverged()#

Get the number of converged eigenpairs.

Not collective.

Returns:: Number of converged eigenpairs.
Return type:: :py:any:`int`

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:885 <slepc4py/SLEPc/NEP.pyx#L885>`

getConvergedReason()#

Get the reason why the solve() iteration was stopped.

Not collective.

Returns:: Negative value indicates diverged, positive value converged.
Return type:: :py:any:`ConvergedReason`

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:869 <slepc4py/SLEPc/NEP.pyx#L869>`

getConvergenceTest()#

Get the method used to compute the error estimate used in the convergence test.

Not collective.

Returns:: The method used to compute the error estimate used in the convergence test.
Return type:: :py:any:`Conv`

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:452 <slepc4py/SLEPc/NEP.pyx#L452>`

getDS()#

Get the direct solver associated to the eigensolver.

Not collective.

Returns:: The direct solver context.
Return type:: :py:any:`DS`

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:711 <slepc4py/SLEPc/NEP.pyx#L711>`

getDimensions()#

Get the number of eigenvalues to compute.

Not collective.

Get the number of eigenvalues to compute, and the dimension of the subspace.

Returns:

nev (:py:any:`int`) – Number of eigenvalues to compute.
ncv (:py:any:`int`) – Maximum dimension of the subspace to be used by the solver.
mpd (:py:any:`int`) – Maximum dimension allowed for the projected problem.

Return type:

tuple[int, int, int]

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:598 <slepc4py/SLEPc/NEP.pyx#L598>`

getEigenpair(i, Vr=None, Vi=None)#

Get the i-th solution of the eigenproblem as computed by solve().

Collective.

The solution consists of both the eigenvalue and the eigenvector.

Parameters:

i (int) – Index of the solution to be obtained.
Vr (Vec | None) – Placeholder for the returned eigenvector (real part).
Vi (Vec | None) – Placeholder for the returned eigenvector (imaginary part).

Returns:

The computed eigenvalue.

Return type:

:py:any:`complex`

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:900 <slepc4py/SLEPc/NEP.pyx#L900>`

getErrorEstimate(i)#

Get the error estimate associated to the i-th computed eigenpair.

Not collective.

Parameters:: i (int) – Index of the solution to be considered.
Returns:: Error estimate.
Return type:: :py:any:`float`

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:958 <slepc4py/SLEPc/NEP.pyx#L958>`

getFunction()#

Get the function to compute the nonlinear Function \(T(\lambda)\).

Collective.

Get the function to compute the nonlinear Function \(T(\lambda)\) and the matrix.

Parameters:

F – Function matrix
P – preconditioner matrix (usually the same as the F)
function – Function evaluation routine

Return type:

tuple[petsc4py.PETSc.Mat, petsc4py.PETSc.Mat, NEPFunction]

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:1104 <slepc4py/SLEPc/NEP.pyx#L1104>`

getInterpolInterpolation()#

Get the tolerance and maximum degree for the interpolation polynomial.

Not collective.

Returns:

tol (:py:any:`float`) – The tolerance to stop computing polynomial coefficients.
deg (:py:any:`int`) – The maximum degree of interpolation.

Return type:

tuple[float, int]

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:1799 <slepc4py/SLEPc/NEP.pyx#L1799>`

getInterpolPEP()#

Get the associated polynomial eigensolver object.

Collective.

Get the polynomial eigensolver object associated with the nonlinear eigensolver.

Returns:: The polynomial eigensolver.
Return type:: :py:any:`PEP`

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:1758 <slepc4py/SLEPc/NEP.pyx#L1758>`

getIterationNumber()#

Get the current iteration number.

Not collective.

If the call to solve() is complete, then it returns the number of iterations carried out by the solution method.

Returns:: Iteration number.
Return type:: :py:any:`int`

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:851 <slepc4py/SLEPc/NEP.pyx#L851>`

getJacobian()#

Get the function to compute the Jacobian \(T'(\lambda)\) and J.

Collective.

Get the function to compute the Jacobian \(T'(\lambda)\) and the matrix.

Parameters:

J – Jacobian matrix
jacobian – Jacobian evaluation routine

Return type:

tuple[petsc4py.PETSc.Mat, NEPJacobian]

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:1162 <slepc4py/SLEPc/NEP.pyx#L1162>`

getLeftEigenvector(i, Wr, Wi=None)#

Get the i-th left eigenvector as computed by solve().

Collective.

Parameters:

i (int) – Index of the solution to be obtained.
Wr (Vec) – Placeholder for the returned eigenvector (real part).
Wi (Vec | None) – Placeholder for the returned eigenvector (imaginary part).

Return type:

None

Notes

The index i should be a value between 0 and nconv-1 (see getConverged()). Eigensolutions are indexed according to the ordering criterion established with setWhichEigenpairs().

Left eigenvectors are available only if the twosided flag was set with setTwoSided().

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:929 <slepc4py/SLEPc/NEP.pyx#L929>`

getMonitor()#

Get the list of monitor functions.

Not collective.

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:813 <slepc4py/SLEPc/NEP.pyx#L813>`

Return type:: NEPMonitorFunction

getNArnoldiKSP()#

Get the linear solver object associated with the nonlinear eigensolver.

Collective.

Returns:: The linear solver object.
Return type:: petsc4py.PETSc.KSP

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:1691 <slepc4py/SLEPc/NEP.pyx#L1691>`

getNArnoldiLagPreconditioner()#

Get how often the preconditioner is rebuilt.

Not collective.

Returns:: The lag parameter.
Return type:: :py:any:`int`

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:1728 <slepc4py/SLEPc/NEP.pyx#L1728>`

getNLEIGSEPS()#

Get the linear eigensolver object associated with the nonlinear eigensolver.

Collective.

Returns:: The linear eigensolver.
Return type:: :py:any:`EPS`

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:1978 <slepc4py/SLEPc/NEP.pyx#L1978>`

getNLEIGSFullBasis()#

Get the flag that indicates if NLEIGS is using the full-basis variant.

Not collective.

Returns:: True if the full-basis variant must be selected.
Return type:: :py:any:`bool`

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:1950 <slepc4py/SLEPc/NEP.pyx#L1950>`

getNLEIGSInterpolation()#

Get the tolerance and maximum degree for the interpolation polynomial.

Not collective.

Get the tolerance and maximum degree when building the interpolation via divided differences.

Returns:

tol (:py:any:`float`) – The tolerance to stop computing divided differences.
deg (:py:any:`int`) – The maximum degree of interpolation.

Return type:

tuple[float, int]

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:1912 <slepc4py/SLEPc/NEP.pyx#L1912>`

getNLEIGSKSPs()#

Get the list of linear solver objects associated with the NLEIGS solver.

Collective.

Returns:: The linear solver objects.
Return type:: :py:any:`list` of petsc4py.PETSc.KSP

Notes

The number of petsc4py.PETSc.KSP solvers is equal to the number of shifts provided by the user, or 1 if the user did not provide shifts.

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:2031 <slepc4py/SLEPc/NEP.pyx#L2031>`

getNLEIGSLocking()#

Get the locking flag used in the NLEIGS method.

Not collective.

Returns:: The locking flag.
Return type:: :py:any:`bool`

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:1875 <slepc4py/SLEPc/NEP.pyx#L1875>`

getNLEIGSRKShifts()#

Get the list of shifts used in the Rational Krylov method.

Not collective.

Returns:: The shift values.
Return type:: :py:any:`ArrayScalar`

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:2010 <slepc4py/SLEPc/NEP.pyx#L2010>`

getNLEIGSRestart()#

Get the restart parameter used in the NLEIGS method.

Not collective.

Returns:: The number of vectors to be kept at restart.
Return type:: :py:any:`float`

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:1839 <slepc4py/SLEPc/NEP.pyx#L1839>`

getOptionsPrefix()#

Get the prefix used for searching for all NEP options in the database.

Not collective.

Returns:: The prefix string set for this NEP object.
Return type:: :py:any:`str`

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:259 <slepc4py/SLEPc/NEP.pyx#L259>`

getProblemType()#

Get the problem type from the NEP object.

Not collective.

Returns:: The problem type that was previously set.
Return type:: :py:any:`ProblemType`

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:315 <slepc4py/SLEPc/NEP.pyx#L315>`

getRG()#

Get the region object associated to the eigensolver.

Not collective.

Returns:: The region context.
Return type:: :py:any:`RG`

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:682 <slepc4py/SLEPc/NEP.pyx#L682>`

getRIIConstCorrectionTol()#

Get the constant tolerance flag.

Not collective.

Returns:: If True, the petsc4py.PETSc.KSP relative tolerance is constant.
Return type:: :py:any:`bool`

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:1413 <slepc4py/SLEPc/NEP.pyx#L1413>`

getRIIDeflationThreshold()#

Get the threshold value that controls deflation.

Not collective.

Returns:: The threshold value.
Return type:: :py:any:`float`

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:1512 <slepc4py/SLEPc/NEP.pyx#L1512>`

getRIIHermitian()#

Get if the Hermitian version must be used by the solver.

Not collective.

Get the flag about using the Hermitian version of the scalar nonlinear equation.

Returns:: If True, the Hermitian version is used.
Return type:: :py:any:`bool`

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:1477 <slepc4py/SLEPc/NEP.pyx#L1477>`

getRIIKSP()#

Get the linear solver object associated with the nonlinear eigensolver.

Collective.

Returns:: The linear solver object.
Return type:: petsc4py.PETSc.KSP

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:1540 <slepc4py/SLEPc/NEP.pyx#L1540>`

getRIILagPreconditioner()#

Get how often the preconditioner is rebuilt.

Not collective.

Returns:: The lag parameter.
Return type:: :py:any:`int`

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:1384 <slepc4py/SLEPc/NEP.pyx#L1384>`

getRIIMaximumIterations()#

Get the maximum number of inner iterations of RII.

Not collective.

Returns:: Maximum inner iterations.
Return type:: :py:any:`int`

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:1445 <slepc4py/SLEPc/NEP.pyx#L1445>`

getRefine()#

Get the refinement strategy used by the NEP object.

Not collective.

Get the refinement strategy used by the NEP object and the associated parameters.

Returns:

ref (:py:any:`Refine`) – The refinement type.
npart (:py:any:`int`) – The number of partitions of the communicator.
tol (:py:any:`float`) – The convergence tolerance.
its (:py:any:`int`) – The maximum number of refinement iterations.
scheme (:py:any:`RefineScheme`) – Scheme for solving linear systems

Return type:

tuple[Refine, int, float, int, RefineScheme]

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:483 <slepc4py/SLEPc/NEP.pyx#L483>`

getRefineKSP()#

Get the KSP object used by the eigensolver in the refinement phase.

Collective.

Returns:: The linear solver object.
Return type:: petsc4py.PETSc.KSP

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:553 <slepc4py/SLEPc/NEP.pyx#L553>`

getSLPDeflationThreshold()#

Get the threshold value that controls deflation.

Not collective.

Returns:: The threshold value.
Return type:: :py:any:`float`

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:1572 <slepc4py/SLEPc/NEP.pyx#L1572>`

getSLPEPS()#

Get the linear eigensolver object associated with the nonlinear eigensolver.

Collective.

Returns:: The linear eigensolver.
Return type:: :py:any:`EPS`

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:1600 <slepc4py/SLEPc/NEP.pyx#L1600>`

getSLPEPSLeft()#

Get the left eigensolver.

Collective.

Returns:: The linear eigensolver.
Return type:: :py:any:`EPS`

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:1631 <slepc4py/SLEPc/NEP.pyx#L1631>`

getSLPKSP()#

Get the linear solver object associated with the nonlinear eigensolver.

Collective.

Returns:: The linear solver object.
Return type:: petsc4py.PETSc.KSP

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:1660 <slepc4py/SLEPc/NEP.pyx#L1660>`

getSplitOperator()#

Get the operator of the nonlinear eigenvalue problem in split form.

Collective.

Returns:

A (:py:any:`list` of :py:any:`petsc4py.PETSc.Mat`) – Coefficient matrices of the split form.
f (:py:any:`list` of :py:any:`FN`) – Scalar functions of the split form.
structure (:py:any:`petsc4py.PETSc.Mat.Structure`) – Structure flag for matrices.

Return type:

tuple[list[petsc4py.PETSc.Mat], list[FN], petsc4py.PETSc.Mat.Structure]

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:1218 <slepc4py/SLEPc/NEP.pyx#L1218>`

getSplitPreconditioner()#

Get the operator of the split preconditioner.

Not collective.

Returns:

P (:py:any:`list` of :py:any:`petsc4py.PETSc.Mat`) – Coefficient matrices of the split preconditioner.
structure (:py:any:`petsc4py.PETSc.Mat.Structure`) – Structure flag for matrices.

Return type:

tuple[list[petsc4py.PETSc.Mat], petsc4py.PETSc.Mat.Structure]

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:1279 <slepc4py/SLEPc/NEP.pyx#L1279>`

getStoppingTest()#

Get the stopping function.

Not collective.

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:782 <slepc4py/SLEPc/NEP.pyx#L782>`

Return type:: NEPStoppingFunction

getTarget()#

Get the value of the target.

Not collective.

Returns:: The value of the target.
Return type:: :py:any:`Scalar`

Notes

If the target was not set by the user, then zero is returned.

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:373 <slepc4py/SLEPc/NEP.pyx#L373>`

getTolerances()#

Get the tolerance and maximum iteration count.

Not collective.

Get the tolerance and maximum iteration count used by the default NEP convergence tests.

Returns:

tol (:py:any:`float`) – The convergence tolerance.
maxit (:py:any:`int`) – The maximum number of iterations.

Return type:

tuple[float, int]

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:412 <slepc4py/SLEPc/NEP.pyx#L412>`

getTrackAll()#

Get the flag indicating whether all residual norms must be computed.

Not collective.

Returns:: Whether the solver compute all residuals or not.
Return type:: :py:any:`bool`

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:569 <slepc4py/SLEPc/NEP.pyx#L569>`

getTwoSided()#

Get the flag indicating if a two-sided variant is being used.

Not collective.

Get the flag indicating whether a two-sided variant of the algorithm is being used or not.

Returns:: Whether the two-sided variant is to be used or not.
Return type:: :py:any:`bool`

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:1304 <slepc4py/SLEPc/NEP.pyx#L1304>`

getType()#

Get the NEP type of this object.

Not collective.

Returns:: The solver currently being used.
Return type:: :py:any:`str`

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:244 <slepc4py/SLEPc/NEP.pyx#L244>`

getWhichEigenpairs()#

Get which portion of the spectrum is to be sought.

Not collective.

Returns:: The portion of the spectrum to be sought by the solver.
Return type:: :py:any:`Which`

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:344 <slepc4py/SLEPc/NEP.pyx#L344>`

reset()#

Reset the NEP object.

Collective.

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:204 <slepc4py/SLEPc/NEP.pyx#L204>`

Return type:: None

setBV(bv)#

Set the basis vectors object associated to the eigensolver.

Collective.

Parameters:: bv (BV) – The basis vectors context.
Return type:: None

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:669 <slepc4py/SLEPc/NEP.pyx#L669>`

setCISSExtraction(extraction)#

Set the extraction technique used in the CISS solver.

Logically collective.

Parameters:: extraction (CISSExtraction) – The extraction technique.
Return type:: None

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:2054 <slepc4py/SLEPc/NEP.pyx#L2054>`

setCISSRefinement(inner=None, blsize=None)#

Set the values of various refinement parameters in the CISS solver.

Logically collective.

Parameters:

inner (int | None) – Number of iterative refinement iterations (inner loop).
blsize (int | None) – Number of iterative refinement iterations (blocksize loop).

Return type:

None

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:2200 <slepc4py/SLEPc/NEP.pyx#L2200>`

setCISSSizes(ip=None, bs=None, ms=None, npart=None, bsmax=None, realmats=False)#

Set the values of various size parameters in the CISS solver.

Logically collective.

Parameters:

ip (int | None) – Number of integration points.
bs (int | None) – Block size.
ms (int | None) – Moment size.
npart (int | None) – Number of partitions when splitting the communicator.
bsmax (int | None) – Maximum block size.
realmats (bool) – True if A and B are real.

Return type:

None

Notes

The default number of partitions is 1. This means the internal petsc4py.PETSc.KSP object is shared among all processes of the NEP communicator. Otherwise, the communicator is split into npart communicators, so that npart petsc4py.PETSc.KSP solves proceed simultaneously.

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:2083 <slepc4py/SLEPc/NEP.pyx#L2083>`

setCISSThreshold(delta=None, spur=None)#

Set the values of various threshold parameters in the CISS solver.

Logically collective.

Parameters:

delta (float | None) – Threshold for numerical rank.
spur (float | None) – Spurious threshold (to discard spurious eigenpairs).

Return type:

None

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:2163 <slepc4py/SLEPc/NEP.pyx#L2163>`

setConvergenceTest(conv)#

Set how to compute the error estimate used in the convergence test.

Logically collective.

Parameters:: conv (Conv) – The method used to compute the error estimate used in the convergence test.
Return type:: None

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:468 <slepc4py/SLEPc/NEP.pyx#L468>`

setDS(ds)#

Set a direct solver object associated to the eigensolver.

Collective.

Parameters:: ds (DS) – The direct solver context.
Return type:: None

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:727 <slepc4py/SLEPc/NEP.pyx#L727>`

setDimensions(nev=None, ncv=None, mpd=None)#

Set the number of eigenvalues to compute.

Logically collective.

Set the number of eigenvalues to compute and the dimension of the subspace.

Parameters:

nev (int | None) – Number of eigenvalues to compute.
ncv (int | None) – Maximum dimension of the subspace to be used by the solver.
mpd (int | None) – Maximum dimension allowed for the projected problem.

Return type:

None

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:622 <slepc4py/SLEPc/NEP.pyx#L622>`

setFromOptions()#

Set NEP options from the options database.

Collective.

This routine must be called before setUp() if the user is to be allowed to set the solver type.

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:304 <slepc4py/SLEPc/NEP.pyx#L304>`

Return type:: None

setFunction(function, F=None, P=None, args=None, kargs=None)#

Set the function to compute the nonlinear Function \(T(\lambda)\).

Collective.

Set the function to compute the nonlinear Function \(T(\lambda)\) as well as the location to store the matrix.

Parameters:

function (NEPFunction) – Function evaluation routine
F (petsc4py.PETSc.Mat | None) – Function matrix
P (petsc4py.PETSc.Mat | None) – preconditioner matrix (usually the same as F)
args (tuple[Any, ...] | None)
kargs (dict[str, Any] | None)

Return type:

None

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:1068 <slepc4py/SLEPc/NEP.pyx#L1068>`

setInitialSpace(space)#

Set the initial space from which the eigensolver starts to iterate.

Collective.

Parameters:: space (Vec) – The initial space
Return type:: None

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:742 <slepc4py/SLEPc/NEP.pyx#L742>`

setInterpolInterpolation(tol=None, deg=None)#

Set the tolerance and maximum degree for the interpolation polynomial.

Collective.

Set the tolerance and maximum degree when building the interpolation polynomial.

Parameters:

tol (float | None) – The tolerance to stop computing polynomial coefficients.
deg (int | None) – The maximum degree of interpolation.

Return type:

None

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:1777 <slepc4py/SLEPc/NEP.pyx#L1777>`

setInterpolPEP(pep)#

Set a polynomial eigensolver object associated to the nonlinear eigensolver.

Collective.

Parameters:: pep (PEP) – The polynomial eigensolver.
Return type:: None

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:1745 <slepc4py/SLEPc/NEP.pyx#L1745>`

setJacobian(jacobian, J=None, args=None, kargs=None)#

Set the function to compute the Jacobian \(T'(\lambda)\).

Collective.

Set the function to compute the Jacobian \(T'(\lambda)\) as well as the location to store the matrix.

Parameters:

jacobian (NEPJacobian) – Jacobian evaluation routine
J (petsc4py.PETSc.Mat | None) – Jacobian matrix
args (tuple[Any, ...] | None)
kargs (dict[str, Any] | None)

Return type:

None

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:1130 <slepc4py/SLEPc/NEP.pyx#L1130>`

setMonitor(monitor, args=None, kargs=None)#

Append a monitor function to the list of monitors.

Logically collective.

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:792 <slepc4py/SLEPc/NEP.pyx#L792>`

Parameters:

monitor (NEPMonitorFunction | None)
args (tuple[Any, ...] | None)
kargs (dict[str, Any] | None)

Return type:

None

setNArnoldiKSP(ksp)#

Set a linear solver object associated to the nonlinear eigensolver.

Collective.

Parameters:: ksp (petsc4py.PETSc.KSP) – The linear solver object.
Return type:: None

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:1678 <slepc4py/SLEPc/NEP.pyx#L1678>`

setNArnoldiLagPreconditioner(lag)#

Set when the preconditioner is rebuilt in the nonlinear solve.

Logically collective.

Parameters:: lag (int) – 0 indicates NEVER rebuild, 1 means rebuild every time the Jacobian is computed within the nonlinear iteration, 2 means every second time the Jacobian is built, etc.
Return type:: None

Notes

The default is 1. The preconditioner is ALWAYS built in the first iteration of a nonlinear solve.

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:1707 <slepc4py/SLEPc/NEP.pyx#L1707>`

setNLEIGSEPS(eps)#

Set a linear eigensolver object associated to the nonlinear eigensolver.

Collective.

Parameters:: eps (EPS) – The linear eigensolver.
Return type:: None

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:1965 <slepc4py/SLEPc/NEP.pyx#L1965>`

setNLEIGSFullBasis(fullbasis=True)#

Set TOAR-basis (default) or full-basis variants of the NLEIGS method.

Logically collective.

Toggle between TOAR-basis (default) and full-basis variants of the NLEIGS method.

Parameters:: fullbasis (bool) – True if the full-basis variant must be selected.
Return type:: None

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:1933 <slepc4py/SLEPc/NEP.pyx#L1933>`

setNLEIGSInterpolation(tol=None, deg=None)#

Set the tolerance and maximum degree for the interpolation polynomial.

Collective.

Set the tolerance and maximum degree when building the interpolation via divided differences.

Parameters:

tol (float | None) – The tolerance to stop computing divided differences.
deg (int | None) – The maximum degree of interpolation.

Return type:

None

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:1890 <slepc4py/SLEPc/NEP.pyx#L1890>`

setNLEIGSLocking(lock)#

Toggle between locking and non-locking variants of the NLEIGS method.

Logically collective.

Parameters:: lock (bool) – True if the locking variant must be selected.
Return type:: None

Notes

The default is to lock converged eigenpairs when the method restarts. This behaviour can be changed so that all directions are kept in the working subspace even if already converged to working accuracy (the non-locking variant).

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:1854 <slepc4py/SLEPc/NEP.pyx#L1854>`

setNLEIGSRKShifts(shifts)#

Set a list of shifts to be used in the Rational Krylov method.

Collective.

Parameters:: shifts (Sequence[TypeAliasForwardRef('~slepc4py.typing.Scalar')]) – Values specifying the shifts.
Return type:: None

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:1994 <slepc4py/SLEPc/NEP.pyx#L1994>`

setNLEIGSRestart(keep)#

Set the restart parameter for the NLEIGS method.

Logically collective.

The proportion of basis vectors that must be kept after restart.

Parameters:: keep (float) – The number of vectors to be kept at restart.
Return type:: None

Notes

Allowed values are in the range [0.1,0.9]. The default is 0.5.

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:1819 <slepc4py/SLEPc/NEP.pyx#L1819>`

setOptionsPrefix(prefix=None)#

Set the prefix used for searching for all NEP options in the database.

Logically collective.

Parameters:: prefix (str | None) – The prefix string to prepend to all NEP option requests.
Return type:: None

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:274 <slepc4py/SLEPc/NEP.pyx#L274>`

setProblemType(problem_type)#

Set the type of the eigenvalue problem.

Logically collective.

Parameters:: problem_type (ProblemType) – The problem type to be set.
Return type:: None

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:330 <slepc4py/SLEPc/NEP.pyx#L330>`

setRG(rg)#

Set a region object associated to the eigensolver.

Collective.

Parameters:: rg (RG) – The region context.
Return type:: None

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:698 <slepc4py/SLEPc/NEP.pyx#L698>`

setRIIConstCorrectionTol(cct)#

Set a flag to keep the tolerance used in the linear solver constant.

Logically collective.

Parameters:: cct (bool) – If True, the petsc4py.PETSc.KSP relative tolerance is constant.
Return type:: None

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:1399 <slepc4py/SLEPc/NEP.pyx#L1399>`

setRIIDeflationThreshold(deftol)#

Set the threshold used to switch between deflated and non-deflated.

Logically collective.

Set the threshold value used to switch between deflated and non-deflated iteration.

Parameters:: deftol (float) – The threshold value.
Return type:: None

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:1495 <slepc4py/SLEPc/NEP.pyx#L1495>`

setRIIHermitian(herm)#

Set a flag to use the Hermitian version of the solver.

Logically collective.

Set a flag to indicate if the Hermitian version of the scalar nonlinear equation must be used by the solver.

Parameters:: herm (bool) – If True, the Hermitian version is used.
Return type:: None

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:1460 <slepc4py/SLEPc/NEP.pyx#L1460>`

setRIIKSP(ksp)#

Set a linear solver object associated to the nonlinear eigensolver.

Collective.

Parameters:: ksp (petsc4py.PETSc.KSP) – The linear solver object.
Return type:: None

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:1527 <slepc4py/SLEPc/NEP.pyx#L1527>`

setRIILagPreconditioner(lag)#

Set when the preconditioner is rebuilt in the nonlinear solve.

Logically collective.

Parameters:: lag (int) – 0 indicates NEVER rebuild, 1 means rebuild every time the Jacobian is computed within the nonlinear iteration, 2 means every second time the Jacobian is built, etc.
Return type:: None

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:1368 <slepc4py/SLEPc/NEP.pyx#L1368>`

setRIIMaximumIterations(its)#

Set the max. number of inner iterations to be used in the RII solver.

Logically collective.

These are the Newton iterations related to the computation of the nonlinear Rayleigh functional.

Parameters:: its (int) – Maximum inner iterations.
Return type:: None

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:1428 <slepc4py/SLEPc/NEP.pyx#L1428>`

setRefine(ref, npart=None, tol=None, its=None, scheme=None)#

Set the refinement strategy used by the NEP object.

Logically collective.

Set the refinement strategy used by the NEP object and the associated parameters.

Parameters:

ref (Refine) – The refinement type.
npart (int | None) – The number of partitions of the communicator.
tol (float | None) – The convergence tolerance.
its (int | None) – The maximum number of refinement iterations.
scheme (RefineScheme | None) – Scheme for linear system solves

Return type:

None

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:513 <slepc4py/SLEPc/NEP.pyx#L513>`

setSLPDeflationThreshold(deftol)#

Set the threshold used to switch between deflated and non-deflated.

Logically collective.

Parameters:: deftol (float) – The threshold value.
Return type:: None

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:1558 <slepc4py/SLEPc/NEP.pyx#L1558>`

setSLPEPS(eps)#

Set a linear eigensolver object associated to the nonlinear eigensolver.

Collective.

Parameters:: eps (EPS) – The linear eigensolver.
Return type:: None

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:1587 <slepc4py/SLEPc/NEP.pyx#L1587>`

setSLPEPSLeft(eps)#

Set a linear eigensolver object associated to the nonlinear eigensolver.

Collective.

Used to compute left eigenvectors in the two-sided variant of SLP.

Parameters:: eps (EPS) – The linear eigensolver.
Return type:: None

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:1616 <slepc4py/SLEPc/NEP.pyx#L1616>`

setSLPKSP(ksp)#

Set a linear solver object associated to the nonlinear eigensolver.

Collective.

Parameters:: ksp (petsc4py.PETSc.KSP) – The linear solver object.
Return type:: None

:sources:`Source code at slepc4py/SLEPc/NEP.pyx:1647 <slepc4py/SLEPc/NEP.pyx#L1647>`

setSplitOperator(A, f, structure=None)#

Set the operator of the nonlinear eigenvalue problem in split form.

Collective.

Parameters:

A (petsc4py.PETSc.Mat | list[petsc4py.PETSc.Mat]) – Coefficient matrices of the split form.
f (FN | list[FN]) – Scalar functions of the split form.
structure (petsc4py.PETSc.Mat.Structure | None) – Structure flag for matrices.

Return type: