int testSlaterPotWithECS() {
PrintTimeStamp(PETSC_COMM_SELF, "ECS", NULL);
MPI_Comm comm = PETSC_COMM_SELF;
BPS bps; BPSCreate(comm, &bps); BPSSetLine(bps, 100.0, 101);
CScaling scaler; CScalingCreate(comm, &scaler);
CScalingSetSharpECS(scaler, 60.0, 20.0*M_PI/180.0);
int order = 5;
BSS bss; BSSCreate(comm, &bss); BSSSetKnots(bss, order, bps);
BSSSetCScaling(bss, scaler); BSSSetUp(bss);
Pot slater; PotCreate(comm, &slater); PotSetSlater(slater, 7.5, 2, 1.0);
if(getenv("SHOW_DEBUG"))
BSSView(bss, PETSC_VIEWER_STDOUT_SELF);
Mat H; BSSCreateR1Mat(bss, &H);
Mat V; BSSCreateR1Mat(bss, &V); BSSPotR1Mat(bss, slater, V);
Mat S; BSSCreateR1Mat(bss, &S); BSSSR1Mat(bss, S);
BSSD2R1Mat(bss, H);
MatScale(H, -0.5);
MatAXPY(H, 1.0, V, DIFFERENT_NONZERO_PATTERN);
EEPS eps; EEPSCreate(comm, &eps);
EEPSSetOperators(eps, H, S);
EEPSSetTarget(eps, 3.4);
EPSSetDimensions(eps->eps, 10, PETSC_DEFAULT, PETSC_DEFAULT);
EPSSetTolerances(eps->eps, PETSC_DEFAULT, 1000);
// EPSSetType(eps, EPSARNOLDI);
EEPSSolve(eps);
PetscInt nconv;
PetscScalar kr;
EPSGetConverged(eps->eps, &nconv);
ASSERT_TRUE(nconv > 0);
if(getenv("SHOW_DEBUG"))
for(int i = 0; i < nconv; i++) {
EPSGetEigenpair(eps->eps, i, &kr, NULL, NULL, NULL);
PetscPrintf(comm, "%f, %f\n", PetscRealPart(kr), PetscImaginaryPart(kr));
}
EPSGetEigenpair(eps->eps, 0, &kr, NULL, NULL, NULL);
PFDestroy(&slater); BSSDestroy(&bss); EEPSDestroy(&eps);
MatDestroy(&H); MatDestroy(&V); MatDestroy(&S);
// ASSERT_DOUBLE_NEAR(-0.0127745, PetscImaginaryPart(kr), pow(10.0, -4.0));
// ASSERT_DOUBLE_NEAR(3.4263903, PetscRealPart(kr), pow(10.0, -4.0));
return 0;
}
PetscErrorCode NEPSetUp_SLP(NEP nep)
{
PetscErrorCode ierr;
NEP_SLP *ctx = (NEP_SLP*)nep->data;
ST st;
PetscBool istrivial;
PetscFunctionBegin;
if (nep->ncv) { /* ncv set */
if (nep->ncv<nep->nev) SETERRQ(PetscObjectComm((PetscObject)nep),1,"The value of ncv must be at least nev");
} else if (nep->mpd) { /* mpd set */
nep->ncv = PetscMin(nep->n,nep->nev+nep->mpd);
} else { /* neither set: defaults depend on nev being small or large */
if (nep->nev<500) nep->ncv = PetscMin(nep->n,PetscMax(2*nep->nev,nep->nev+15));
else {
nep->mpd = 500;
nep->ncv = PetscMin(nep->n,nep->nev+nep->mpd);
}
}
if (!nep->mpd) nep->mpd = nep->ncv;
if (nep->ncv>nep->nev+nep->mpd) SETERRQ(PetscObjectComm((PetscObject)nep),1,"The value of ncv must not be larger than nev+mpd");
if (nep->nev>1) { ierr = PetscInfo(nep,"Warning: requested more than one eigenpair but SLP can only compute one\n");CHKERRQ(ierr); }
if (!nep->max_it) nep->max_it = PetscMax(5000,2*nep->n/nep->ncv);
if (!nep->max_funcs) nep->max_funcs = nep->max_it;
ierr = RGIsTrivial(nep->rg,&istrivial);CHKERRQ(ierr);
if (!istrivial) SETERRQ(PetscObjectComm((PetscObject)nep),PETSC_ERR_SUP,"This solver does not support region filtering");
if (!ctx->eps) { ierr = NEPSLPGetEPS(nep,&ctx->eps);CHKERRQ(ierr); }
ierr = EPSSetWhichEigenpairs(ctx->eps,EPS_TARGET_MAGNITUDE);CHKERRQ(ierr);
ierr = EPSSetTarget(ctx->eps,0.0);CHKERRQ(ierr);
ierr = EPSGetST(ctx->eps,&st);CHKERRQ(ierr);
ierr = STSetType(st,STSINVERT);CHKERRQ(ierr);
ierr = EPSSetDimensions(ctx->eps,1,nep->ncv?nep->ncv:PETSC_DEFAULT,nep->mpd?nep->mpd:PETSC_DEFAULT);CHKERRQ(ierr);
ierr = EPSSetTolerances(ctx->eps,nep->rtol==PETSC_DEFAULT?SLEPC_DEFAULT_TOL/10.0:nep->rtol/10.0,nep->max_it?nep->max_it:PETSC_DEFAULT);CHKERRQ(ierr);
ierr = NEPAllocateSolution(nep,0);CHKERRQ(ierr);
ierr = NEPSetWorkVecs(nep,1);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
int main(int argc,char **argv)
{
Mat A; /* operator matrix */
EPS eps; /* eigenproblem solver context */
EPSType type;
PetscMPIInt nproc, myproc;
PetscInt nev;
PetscErrorCode ierr;
SlepcInitialize(&argc, &argv, (char*)0, 0);
ierr = MPI_Comm_size(PETSC_COMM_WORLD,&nproc); CHKERRQ(ierr);
ierr = MPI_Comm_rank(PETSC_COMM_WORLD,&myproc); CHKERRQ(ierr);
int L = 8;
ierr = PetscOptionsGetInt(NULL,"-L", &L, NULL); CHKERRQ(ierr);
PetscInt N_global = 1 << L;
PetscInt N_local = N_global / nproc;
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Compute the operator matrix that defines the eigensystem, Ax=kx
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
model m;
m.comm = PETSC_COMM_WORLD;
m.L = L;
m.buffer = new double[N_local];
if (m.buffer == 0) {
MPI_Abort(MPI_COMM_WORLD, 4);
}
for (int i=0; i<L; ++i) {
m.lattice.push_back(std::make_pair(i, (i+1)%L));
}
ierr = MatCreateShell(PETSC_COMM_WORLD, N_local, N_local, N_global, N_global, &m, &A); CHKERRQ(ierr);
ierr = MatSetFromOptions(A); CHKERRQ(ierr);
ierr = MatShellSetOperation(A,MATOP_MULT,(void(*)())MatMult_myMat); CHKERRQ(ierr);
ierr = MatShellSetOperation(A,MATOP_MULT_TRANSPOSE,(void(*)())MatMult_myMat); CHKERRQ(ierr);
ierr = MatShellSetOperation(A,MATOP_GET_DIAGONAL,(void(*)())MatGetDiagonal_myMat); CHKERRQ(ierr);
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Create the eigensolver and set various options
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
/*
Create eigensolver context
*/
ierr = EPSCreate(PETSC_COMM_WORLD,&eps); CHKERRQ(ierr);
/*
Set operators. In this case, it is a standard eigenvalue problem
*/
ierr = EPSSetOperators(eps,A,NULL); CHKERRQ(ierr);
ierr = EPSSetProblemType(eps,EPS_HEP); CHKERRQ(ierr);
ierr = EPSSetDimensions(eps, 5, 100, 100); CHKERRQ(ierr);
ierr = EPSSetTolerances(eps, (PetscScalar) 1e-1, (PetscInt) 100); CHKERRQ(ierr);
//Vec v0;
//MatGetVecs(A, &v0, NULL);
//VecSet(v0,1.0);
//EPSSetInitialSpace(eps,1,&v0);
/*
Set solver parameters at runtime
*/
ierr = EPSSetFromOptions(eps); CHKERRQ(ierr);
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Solve the eigensystem
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
ierr = EPSSolve(eps);CHKERRQ(ierr);
/*
Optional: Get some information from the solver and display it
*/
ierr = EPSGetType(eps,&type); CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD," Solution method: %s\n\n",type); CHKERRQ(ierr);
ierr = EPSGetDimensions(eps,&nev,NULL,NULL); CHKERRQ(ierr);
ierr = PetscPrintf(PETSC_COMM_WORLD," Number of requested eigenvalues: %D\n",nev); CHKERRQ(ierr);
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Display solution and clean up
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
ierr = EPSPrintSolution(eps,NULL); CHKERRQ(ierr);
ierr = EPSDestroy(&eps); CHKERRQ(ierr);
ierr = MatDestroy(&A); CHKERRQ(ierr);
ierr = SlepcFinalize();
return 0;
}
void TrustRegionSolver3::calcSmallestEigVal(double &oEigVal, FloatArray &oEigVec, PetscSparseMtrx &K) {
PetscErrorCode ierr;
ST st;
double eig_rtol = 1.0e-3;
int max_iter = 10000;
int nroot = 1;
if ( !epsInit ) {
/*
* Create eigensolver context
*/
#ifdef __PARALLEL_MODE
MPI_Comm comm = engngModel->giveParallelComm();
#else
MPI_Comm comm = PETSC_COMM_SELF;
#endif
ierr = EPSCreate(comm, & eps);
checkPetscError(ierr);
epsInit = true;
}
ierr = EPSSetOperators( eps, * K.giveMtrx(), NULL );
checkPetscError(ierr);
ierr = EPSSetProblemType(eps, EPS_NHEP);
checkPetscError(ierr);
ierr = EPSGetST(eps, & st);
checkPetscError(ierr);
// ierr = STSetType(st, STCAYLEY);
// ierr = STSetType(st, STSINVERT);
ierr = STSetType(st, STSHIFT);
checkPetscError(ierr);
ierr = STSetMatStructure(st, SAME_NONZERO_PATTERN);
checkPetscError(ierr);
ierr = EPSSetTolerances(eps, ( PetscReal ) eig_rtol, max_iter);
checkPetscError(ierr);
ierr = EPSSetDimensions(eps, ( PetscInt ) nroot, PETSC_DECIDE, PETSC_DECIDE);
checkPetscError(ierr);
ierr = EPSSetWhichEigenpairs(eps, EPS_SMALLEST_REAL);
checkPetscError(ierr);
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
* Solve the eigensystem
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
EPSConvergedReason eig_reason;
int eig_nconv, eig_nite;
ierr = EPSSolve(eps);
checkPetscError(ierr);
ierr = EPSGetConvergedReason(eps, & eig_reason);
checkPetscError(ierr);
ierr = EPSGetIterationNumber(eps, & eig_nite);
checkPetscError(ierr);
// printf("SLEPcSolver::solve EPSConvergedReason: %d, number of iterations: %d\n", eig_reason, eig_nite);
ierr = EPSGetConverged(eps, & eig_nconv);
checkPetscError(ierr);
double smallest_eig_val = 1.0e20;
if ( eig_nconv > 0 ) {
// printf("SLEPcSolver :: solveYourselfAt: Convergence reached for RTOL=%20.15f\n", eig_rtol);
FloatArray eig_vals(nroot);
PetscScalar kr;
Vec Vr;
K.createVecGlobal(& Vr);
FloatArray Vr_loc;
for ( int i = 0; i < eig_nconv && i < nroot; i++ ) {
// PetscErrorCode EPSGetEigenpair(EPS eps,PetscInt i,PetscScalar *eigr,PetscScalar *eigi,Vec Vr,Vec Vi)
ierr = EPSGetEigenpair(eps, i, & kr, PETSC_NULL, Vr, PETSC_NULL);
checkPetscError(ierr);
//Store the eigenvalue
eig_vals(i) = kr;
if(kr < smallest_eig_val) {
smallest_eig_val = kr;
K.scatterG2L(Vr, Vr_loc);
oEigVec = Vr_loc;
}
}
ierr = VecDestroy(& Vr);
checkPetscError(ierr);
} else {
// OOFEM_ERROR("No converged eigenpairs.\n");
printf("Warning: No converged eigenpairs.\n");
smallest_eig_val = 1.0;
}
oEigVal = smallest_eig_val;
}
NM_Status
SLEPcSolver :: solve(SparseMtrx &a, SparseMtrx &b, FloatArray &_eigv, FloatMatrix &_r, double rtol, int nroot)
{
FILE *outStream;
PetscErrorCode ierr;
int size;
ST st;
outStream = domain->giveEngngModel()->giveOutputStream();
// first check whether Lhs is defined
if ( a->giveNumberOfRows() != a->giveNumberOfColumns() ||
b->giveNumberOfRows() != b->giveNumberOfRows() ||
a->giveNumberOfColumns() != b->giveNumberOfColumns() ) {
OOFEM_ERROR("matrices size mismatch");
}
A = dynamic_cast< PetscSparseMtrx * >(&a);
B = dynamic_cast< PetscSparseMtrx * >(&b);
if ( !A || !B ) {
OOFEM_ERROR("PetscSparseMtrx Expected");
}
size = engngModel->giveParallelContext( A->giveDomainIndex() )->giveNumberOfNaturalEqs(); // A->giveLeqs();
_r.resize(size, nroot);
_eigv.resize(nroot);
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
* Create the eigensolver and set various options
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
int nconv, nite;
EPSConvergedReason reason;
#ifdef TIME_REPORT
Timer timer;
timer.startTimer();
#endif
if ( !epsInit ) {
/*
* Create eigensolver context
*/
#ifdef __PARALLEL_MODE
MPI_Comm comm = engngModel->giveParallelComm();
#else
MPI_Comm comm = PETSC_COMM_SELF;
#endif
ierr = EPSCreate(comm, & eps);
CHKERRQ(ierr);
epsInit = true;
}
/*
* Set operators. In this case, it is a generalized eigenvalue problem
*/
ierr = EPSSetOperators( eps, * A->giveMtrx(), * B->giveMtrx() );
CHKERRQ(ierr);
ierr = EPSSetProblemType(eps, EPS_GHEP);
CHKERRQ(ierr);
ierr = EPSGetST(eps, & st);
CHKERRQ(ierr);
ierr = STSetType(st, STSINVERT);
CHKERRQ(ierr);
ierr = STSetMatStructure(st, SAME_NONZERO_PATTERN);
CHKERRQ(ierr);
ierr = EPSSetTolerances(eps, ( PetscReal ) rtol, PETSC_DECIDE);
CHKERRQ(ierr);
ierr = EPSSetDimensions(eps, ( PetscInt ) nroot, PETSC_DECIDE, PETSC_DECIDE);
CHKERRQ(ierr);
ierr = EPSSetWhichEigenpairs(eps, EPS_SMALLEST_MAGNITUDE);
CHKERRQ(ierr);
/*
* Set solver parameters at runtime
*/
ierr = EPSSetFromOptions(eps);
CHKERRQ(ierr);
/* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
* Solve the eigensystem
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
ierr = EPSSolve(eps);
CHKERRQ(ierr);
ierr = EPSGetConvergedReason(eps, & reason);
CHKERRQ(ierr);
ierr = EPSGetIterationNumber(eps, & nite);
CHKERRQ(ierr);
OOFEM_LOG_INFO("SLEPcSolver::solve EPSConvergedReason: %d, number of iterations: %d\n", reason, nite);
ierr = EPSGetConverged(eps, & nconv);
CHKERRQ(ierr);
if ( nconv > 0 ) {
fprintf(outStream, "SLEPcSolver :: solveYourselfAt: Convergence reached for RTOL=%20.15f", rtol);
PetscScalar kr;
Vec Vr;
ierr = MatGetVecs(* B->giveMtrx(), PETSC_NULL, & Vr);
CHKERRQ(ierr);
FloatArray Vr_loc;
for ( int i = 0; i < nconv && i < nroot; i++ ) {
ierr = EPSGetEigenpair(eps, nconv - i - 1, & kr, PETSC_NULL, Vr, PETSC_NULL);
CHKERRQ(ierr);
//Store the eigenvalue
_eigv->at(i + 1) = kr;
//Store the eigenvector
A->scatterG2L(Vr, Vr_loc);
for ( int j = 0; j < size; j++ ) {
_r->at(j + 1, i + 1) = Vr_loc.at(j + 1);
}
}
ierr = VecDestroy(Vr);
CHKERRQ(ierr);
} else {
OOFEM_ERROR("No converged eigenpairs");
}
#ifdef TIME_REPORT
timer.stopTimer();
OOFEM_LOG_INFO( "SLEPcSolver info: user time consumed by solution: %.2fs\n", timer.getUtime() );
#endif
return NM_Success;
}
bool eigenSolver::solve(int numEigenValues, std::string which)
{
if(!_A) return false;
Mat A = _A->getMatrix();
Mat B = _B ? _B->getMatrix() : PETSC_NULL;
PetscInt N, M;
_try(MatAssemblyBegin(A, MAT_FINAL_ASSEMBLY));
_try(MatAssemblyEnd(A, MAT_FINAL_ASSEMBLY));
_try(MatGetSize(A, &N, &M));
PetscInt N2, M2;
if (_B) {
_try(MatAssemblyBegin(B, MAT_FINAL_ASSEMBLY));
_try(MatAssemblyEnd(B, MAT_FINAL_ASSEMBLY));
_try(MatGetSize(B, &N2, &M2));
}
// generalized eigenvalue problem A x - \lambda B x = 0
EPS eps;
_try(EPSCreate(PETSC_COMM_WORLD, &eps));
_try(EPSSetOperators(eps, A, B));
if(_hermitian)
_try(EPSSetProblemType(eps, _B ? EPS_GHEP : EPS_HEP));
else
_try(EPSSetProblemType(eps, _B ? EPS_GNHEP : EPS_NHEP));
// set some default options
_try(EPSSetDimensions(eps, numEigenValues, PETSC_DECIDE, PETSC_DECIDE));
_try(EPSSetTolerances(eps, 1.e-7, 20));//1.e-7 20
_try(EPSSetType(eps, EPSKRYLOVSCHUR)); //default
//_try(EPSSetType(eps, EPSARNOLDI));
//_try(EPSSetType(eps, EPSARPACK));
//_try(EPSSetType(eps, EPSPOWER));
// override these options at runtime, petsc-style
_try(EPSSetFromOptions(eps));
// force options specified directly as arguments
if(numEigenValues)
_try(EPSSetDimensions(eps, numEigenValues, PETSC_DECIDE, PETSC_DECIDE));
if(which == "smallest")
_try(EPSSetWhichEigenpairs(eps, EPS_SMALLEST_MAGNITUDE));
else if(which == "smallestReal")
_try(EPSSetWhichEigenpairs(eps, EPS_SMALLEST_REAL));
else if(which == "largest")
_try(EPSSetWhichEigenpairs(eps, EPS_LARGEST_MAGNITUDE));
// print info
#if (SLEPC_VERSION_RELEASE == 0 || (SLEPC_VERSION_MAJOR > 3 || (SLEPC_VERSION_MAJOR == 3 && SLEPC_VERSION_MINOR >= 4)))
EPSType type;
#else
const EPSType type;
#endif
_try(EPSGetType(eps, &type));
Msg::Debug("SLEPc solution method: %s", type);
PetscInt nev;
_try(EPSGetDimensions(eps, &nev, PETSC_NULL, PETSC_NULL));
Msg::Debug("SLEPc number of requested eigenvalues: %d", nev);
PetscReal tol;
PetscInt maxit;
_try(EPSGetTolerances(eps, &tol, &maxit));
Msg::Debug("SLEPc stopping condition: tol=%g, maxit=%d", tol, maxit);
// solve
Msg::Info("SLEPc solving...");
double t1 = Cpu();
_try(EPSSolve(eps));
// check convergence
int its;
_try(EPSGetIterationNumber(eps, &its));
EPSConvergedReason reason;
_try(EPSGetConvergedReason(eps, &reason));
if(reason == EPS_CONVERGED_TOL){
double t2 = Cpu();
Msg::Debug("SLEPc converged in %d iterations (%g s)", its, t2-t1);
}
else if(reason == EPS_DIVERGED_ITS)
Msg::Error("SLEPc diverged after %d iterations", its);
else if(reason == EPS_DIVERGED_BREAKDOWN)
Msg::Error("SLEPc generic breakdown in method");
#if (SLEPC_VERSION_MAJOR < 3 || (SLEPC_VERSION_MAJOR == 3 && SLEPC_VERSION_MINOR < 2))
else if(reason == EPS_DIVERGED_NONSYMMETRIC)
Msg::Error("The operator is nonsymmetric");
#endif
// get number of converged approximate eigenpairs
PetscInt nconv;
_try(EPSGetConverged(eps, &nconv));
Msg::Debug("SLEPc number of converged eigenpairs: %d", nconv);
// ignore additional eigenvalues if we get more than what we asked
if(nconv > nev) nconv = nev;
if (nconv > 0) {
Vec xr, xi;
_try(MatGetVecs(A, PETSC_NULL, &xr));
_try(MatGetVecs(A, PETSC_NULL, &xi));
Msg::Debug(" Re[EigenValue] Im[EigenValue]"
" Relative error");
for (int i = 0; i < nconv; i++){
PetscScalar kr, ki;
_try(EPSGetEigenpair(eps, i, &kr, &ki, xr, xi));
PetscReal error;
_try(EPSComputeRelativeError(eps, i, &error));
#if defined(PETSC_USE_COMPLEX)
PetscReal re = PetscRealPart(kr);
PetscReal im = PetscImaginaryPart(kr);
#else
PetscReal re = kr;
PetscReal im = ki;
#endif
Msg::Debug("EIG %03d %s%.16e %s%.16e %3.6e",
i, (re < 0) ? "" : " ", re, (im < 0) ? "" : " ", im, error);
// store eigenvalues and eigenvectors
_eigenValues.push_back(std::complex<double>(re, im));
PetscScalar *tmpr, *tmpi;
_try(VecGetArray(xr, &tmpr));
_try(VecGetArray(xi, &tmpi));
std::vector<std::complex<double> > ev(N);
for(int i = 0; i < N; i++){
#if defined(PETSC_USE_COMPLEX)
ev[i] = tmpr[i];
#else
ev[i] = std::complex<double>(tmpr[i], tmpi[i]);
#endif
}
_eigenVectors.push_back(ev);
}
_try(VecDestroy(&xr));
_try(VecDestroy(&xi));
}
_try(EPSDestroy(&eps));
if(reason == EPS_CONVERGED_TOL){
Msg::Debug("SLEPc done");
return true;
}
else{
Msg::Warning("SLEPc failed");
return false;
}
}
std::pair<unsigned int, unsigned int>
SlepcEigenSolver<T>::_solve_generalized_helper (Mat mat_A,
Mat mat_B,
int nev, // number of requested eigenpairs
int ncv, // number of basis vectors
const double tol, // solver tolerance
const unsigned int m_its) // maximum number of iterations
{
START_LOG("solve_generalized()", "SlepcEigenSolver");
int ierr=0;
// converged eigen pairs and number of iterations
int nconv=0;
int its=0;
#ifdef DEBUG
// The relative error.
PetscReal error, re, im;
// Pointer to vectors of the real parts, imaginary parts.
PetscScalar kr, ki;
#endif
// Set operators.
ierr = EPSSetOperators (_eps, mat_A, mat_B);
LIBMESH_CHKERRABORT(ierr);
//set the problem type and the position of the spectrum
set_slepc_problem_type();
set_slepc_position_of_spectrum();
// Set eigenvalues to be computed.
#if SLEPC_VERSION_LESS_THAN(3,0,0)
ierr = EPSSetDimensions (_eps, nev, ncv);
#else
ierr = EPSSetDimensions (_eps, nev, ncv, PETSC_DECIDE);
#endif
LIBMESH_CHKERRABORT(ierr);
// Set the tolerance and maximum iterations.
ierr = EPSSetTolerances (_eps, tol, m_its);
LIBMESH_CHKERRABORT(ierr);
// Set runtime options, e.g.,
// -eps_type <type>, -eps_nev <nev>, -eps_ncv <ncv>
// Similar to PETSc, these options will override those specified
// above as long as EPSSetFromOptions() is called _after_ any
// other customization routines.
ierr = EPSSetFromOptions (_eps);
LIBMESH_CHKERRABORT(ierr);
// Solve the eigenproblem.
ierr = EPSSolve (_eps);
LIBMESH_CHKERRABORT(ierr);
// Get the number of iterations.
ierr = EPSGetIterationNumber (_eps, &its);
LIBMESH_CHKERRABORT(ierr);
// Get number of converged eigenpairs.
ierr = EPSGetConverged(_eps,&nconv);
LIBMESH_CHKERRABORT(ierr);
#ifdef DEBUG
// ierr = PetscPrintf(this->comm().get(),
// "\n Number of iterations: %d\n"
// " Number of converged eigenpairs: %d\n\n", its, nconv);
// Display eigenvalues and relative errors.
ierr = PetscPrintf(this->comm().get(),
" k ||Ax-kx||/|kx|\n"
" ----------------- -----------------\n" );
LIBMESH_CHKERRABORT(ierr);
for(int i=0; i<nconv; i++ )
{
ierr = EPSGetEigenpair(_eps, i, &kr, &ki, PETSC_NULL, PETSC_NULL);
LIBMESH_CHKERRABORT(ierr);
ierr = EPSComputeRelativeError(_eps, i, &error);
LIBMESH_CHKERRABORT(ierr);
#ifdef LIBMESH_USE_COMPLEX_NUMBERS
re = PetscRealPart(kr);
im = PetscImaginaryPart(kr);
#else
re = kr;
im = ki;
#endif
if (im != .0)
{
ierr = PetscPrintf(this->comm().get()," %9f%+9f i %12f\n", re, im, error);
LIBMESH_CHKERRABORT(ierr);
}
else
{
ierr = PetscPrintf(this->comm().get()," %12f %12f\n", re, error);
LIBMESH_CHKERRABORT(ierr);
}
}
ierr = PetscPrintf(this->comm().get(),"\n" );
LIBMESH_CHKERRABORT(ierr);
#endif // DEBUG
STOP_LOG("solve_generalized()", "SlepcEigenSolver");
// return the number of converged eigenpairs
// and the number of iterations
return std::make_pair(nconv, its);
}
PetscErrorCode PEPSetUp_Linear(PEP pep)
{
PetscErrorCode ierr;
PEP_LINEAR *ctx = (PEP_LINEAR*)pep->data;
PetscInt i=0;
EPSWhich which;
PetscBool trackall,istrivial,flg;
PetscScalar sigma;
/* function tables */
PetscErrorCode (*fcreate[][2])(MPI_Comm,PEP_LINEAR*,Mat*) = {
{ MatCreateExplicit_Linear_N1A, MatCreateExplicit_Linear_N1B }, /* N1 */
{ MatCreateExplicit_Linear_N2A, MatCreateExplicit_Linear_N2B }, /* N2 */
{ MatCreateExplicit_Linear_S1A, MatCreateExplicit_Linear_S1B }, /* S1 */
{ MatCreateExplicit_Linear_S2A, MatCreateExplicit_Linear_S2B }, /* S2 */
{ MatCreateExplicit_Linear_H1A, MatCreateExplicit_Linear_H1B }, /* H1 */
{ MatCreateExplicit_Linear_H2A, MatCreateExplicit_Linear_H2B } /* H2 */
};
PetscErrorCode (*fmult[][2])(Mat,Vec,Vec) = {
{ MatMult_Linear_N1A, MatMult_Linear_N1B },
{ MatMult_Linear_N2A, MatMult_Linear_N2B },
{ MatMult_Linear_S1A, MatMult_Linear_S1B },
{ MatMult_Linear_S2A, MatMult_Linear_S2B },
{ MatMult_Linear_H1A, MatMult_Linear_H1B },
{ MatMult_Linear_H2A, MatMult_Linear_H2B }
};
PetscErrorCode (*fgetdiagonal[][2])(Mat,Vec) = {
{ MatGetDiagonal_Linear_N1A, MatGetDiagonal_Linear_N1B },
{ MatGetDiagonal_Linear_N2A, MatGetDiagonal_Linear_N2B },
{ MatGetDiagonal_Linear_S1A, MatGetDiagonal_Linear_S1B },
{ MatGetDiagonal_Linear_S2A, MatGetDiagonal_Linear_S2B },
{ MatGetDiagonal_Linear_H1A, MatGetDiagonal_Linear_H1B },
{ MatGetDiagonal_Linear_H2A, MatGetDiagonal_Linear_H2B }
};
PetscFunctionBegin;
if (!ctx->cform) ctx->cform = 1;
if (!pep->which) pep->which = PEP_LARGEST_MAGNITUDE;
if (pep->basis!=PEP_BASIS_MONOMIAL) SETERRQ(PetscObjectComm((PetscObject)pep),PETSC_ERR_SUP,"Solver not implemented for non-monomial bases");
if (pep->nmat!=3) SETERRQ(PetscObjectComm((PetscObject)pep),PETSC_ERR_SUP,"Solver only available for quadratic problems");
if (pep->scale==PEP_SCALE_DIAGONAL || pep->scale==PEP_SCALE_BOTH) SETERRQ(PetscObjectComm((PetscObject)pep),PETSC_ERR_SUP,"Diagonal scaling not allowed in PEP linear solver");
ierr = STGetTransform(pep->st,&flg);CHKERRQ(ierr);
if (flg) SETERRQ(PetscObjectComm((PetscObject)pep),PETSC_ERR_SUP,"ST transformation flag not allowed for PEP linear solver");
/* compute scale factor if no set by user */
ierr = PEPComputeScaleFactor(pep);CHKERRQ(ierr);
ierr = STGetOperators(pep->st,0,&ctx->K);CHKERRQ(ierr);
ierr = STGetOperators(pep->st,1,&ctx->C);CHKERRQ(ierr);
ierr = STGetOperators(pep->st,2,&ctx->M);CHKERRQ(ierr);
ctx->sfactor = pep->sfactor;
ierr = MatDestroy(&ctx->A);CHKERRQ(ierr);
ierr = MatDestroy(&ctx->B);CHKERRQ(ierr);
ierr = VecDestroy(&ctx->x1);CHKERRQ(ierr);
ierr = VecDestroy(&ctx->x2);CHKERRQ(ierr);
ierr = VecDestroy(&ctx->y1);CHKERRQ(ierr);
ierr = VecDestroy(&ctx->y2);CHKERRQ(ierr);
switch (pep->problem_type) {
case PEP_GENERAL: i = 0; break;
case PEP_HERMITIAN: i = 2; break;
case PEP_GYROSCOPIC: i = 4; break;
default: SETERRQ(PetscObjectComm((PetscObject)pep),1,"Wrong value of pep->problem_type");
}
i += ctx->cform-1;
if (ctx->explicitmatrix) {
ctx->x1 = ctx->x2 = ctx->y1 = ctx->y2 = NULL;
ierr = (*fcreate[i][0])(PetscObjectComm((PetscObject)pep),ctx,&ctx->A);CHKERRQ(ierr);
ierr = (*fcreate[i][1])(PetscObjectComm((PetscObject)pep),ctx,&ctx->B);CHKERRQ(ierr);
} else {
ierr = VecCreateMPIWithArray(PetscObjectComm((PetscObject)pep),1,pep->nloc,pep->n,NULL,&ctx->x1);CHKERRQ(ierr);
ierr = VecCreateMPIWithArray(PetscObjectComm((PetscObject)pep),1,pep->nloc,pep->n,NULL,&ctx->x2);CHKERRQ(ierr);
ierr = VecCreateMPIWithArray(PetscObjectComm((PetscObject)pep),1,pep->nloc,pep->n,NULL,&ctx->y1);CHKERRQ(ierr);
ierr = VecCreateMPIWithArray(PetscObjectComm((PetscObject)pep),1,pep->nloc,pep->n,NULL,&ctx->y2);CHKERRQ(ierr);
ierr = PetscLogObjectParent((PetscObject)pep,(PetscObject)ctx->x1);CHKERRQ(ierr);
ierr = PetscLogObjectParent((PetscObject)pep,(PetscObject)ctx->x2);CHKERRQ(ierr);
ierr = PetscLogObjectParent((PetscObject)pep,(PetscObject)ctx->y1);CHKERRQ(ierr);
ierr = PetscLogObjectParent((PetscObject)pep,(PetscObject)ctx->y2);CHKERRQ(ierr);
ierr = MatCreateShell(PetscObjectComm((PetscObject)pep),2*pep->nloc,2*pep->nloc,2*pep->n,2*pep->n,ctx,&ctx->A);CHKERRQ(ierr);
ierr = MatShellSetOperation(ctx->A,MATOP_MULT,(void(*)(void))fmult[i][0]);CHKERRQ(ierr);
ierr = MatShellSetOperation(ctx->A,MATOP_GET_DIAGONAL,(void(*)(void))fgetdiagonal[i][0]);CHKERRQ(ierr);
ierr = MatCreateShell(PetscObjectComm((PetscObject)pep),2*pep->nloc,2*pep->nloc,2*pep->n,2*pep->n,ctx,&ctx->B);CHKERRQ(ierr);
ierr = MatShellSetOperation(ctx->B,MATOP_MULT,(void(*)(void))fmult[i][1]);CHKERRQ(ierr);
ierr = MatShellSetOperation(ctx->B,MATOP_GET_DIAGONAL,(void(*)(void))fgetdiagonal[i][1]);CHKERRQ(ierr);
}
ierr = PetscLogObjectParent((PetscObject)pep,(PetscObject)ctx->A);CHKERRQ(ierr);
ierr = PetscLogObjectParent((PetscObject)pep,(PetscObject)ctx->B);CHKERRQ(ierr);
if (!ctx->eps) { ierr = PEPLinearGetEPS(pep,&ctx->eps);CHKERRQ(ierr); }
ierr = EPSSetOperators(ctx->eps,ctx->A,ctx->B);CHKERRQ(ierr);
if (pep->problem_type==PEP_HERMITIAN) {
ierr = EPSSetProblemType(ctx->eps,EPS_GHIEP);CHKERRQ(ierr);
} else {
ierr = EPSSetProblemType(ctx->eps,EPS_GNHEP);CHKERRQ(ierr);
}
switch (pep->which) {
case PEP_LARGEST_MAGNITUDE: which = EPS_LARGEST_MAGNITUDE; break;
case PEP_SMALLEST_MAGNITUDE: which = EPS_SMALLEST_MAGNITUDE; break;
case PEP_LARGEST_REAL: which = EPS_LARGEST_REAL; break;
case PEP_SMALLEST_REAL: which = EPS_SMALLEST_REAL; break;
case PEP_LARGEST_IMAGINARY: which = EPS_LARGEST_IMAGINARY; break;
case PEP_SMALLEST_IMAGINARY: which = EPS_SMALLEST_IMAGINARY; break;
case PEP_TARGET_MAGNITUDE: which = EPS_TARGET_MAGNITUDE; break;
case PEP_TARGET_REAL: which = EPS_TARGET_REAL; break;
case PEP_TARGET_IMAGINARY: which = EPS_TARGET_IMAGINARY; break;
default: SETERRQ(PetscObjectComm((PetscObject)pep),1,"Wrong value of which");
}
ierr = EPSSetWhichEigenpairs(ctx->eps,which);CHKERRQ(ierr);
ierr = EPSSetDimensions(ctx->eps,pep->nev,pep->ncv?pep->ncv:PETSC_DEFAULT,pep->mpd?pep->mpd:PETSC_DEFAULT);CHKERRQ(ierr);
ierr = EPSSetTolerances(ctx->eps,pep->tol==PETSC_DEFAULT?SLEPC_DEFAULT_TOL/10.0:pep->tol/10.0,pep->max_it?pep->max_it:PETSC_DEFAULT);CHKERRQ(ierr);
ierr = RGIsTrivial(pep->rg,&istrivial);CHKERRQ(ierr);
if (!istrivial) { ierr = EPSSetRG(ctx->eps,pep->rg);CHKERRQ(ierr); }
/* Transfer the trackall option from pep to eps */
ierr = PEPGetTrackAll(pep,&trackall);CHKERRQ(ierr);
ierr = EPSSetTrackAll(ctx->eps,trackall);CHKERRQ(ierr);
/* temporary change of target */
if (pep->sfactor!=1.0) {
ierr = EPSGetTarget(ctx->eps,&sigma);CHKERRQ(ierr);
ierr = EPSSetTarget(ctx->eps,sigma/pep->sfactor);CHKERRQ(ierr);
}
ierr = EPSSetUp(ctx->eps);CHKERRQ(ierr);
ierr = EPSGetDimensions(ctx->eps,NULL,&pep->ncv,&pep->mpd);CHKERRQ(ierr);
ierr = EPSGetTolerances(ctx->eps,NULL,&pep->max_it);CHKERRQ(ierr);
if (pep->nini>0) { ierr = PetscInfo(pep,"Ignoring initial vectors\n");CHKERRQ(ierr); }
ierr = PEPAllocateSolution(pep,0);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
/*@
EPSSetFromOptions - Sets EPS options from the options database.
This routine must be called before EPSSetUp() if the user is to be
allowed to set the solver type.
Collective on EPS
Input Parameters:
. eps - the eigensolver context
Notes:
To see all options, run your program with the -help option.
Level: beginner
@*/
PetscErrorCode EPSSetFromOptions(EPS eps)
{
PetscErrorCode ierr;
char type[256],monfilename[PETSC_MAX_PATH_LEN];
PetscBool flg,flg1,flg2,flg3;
PetscReal r,array[2]={0,0};
PetscScalar s;
PetscInt i,j,k;
PetscViewer monviewer;
SlepcConvMonitor ctx;
PetscFunctionBegin;
PetscValidHeaderSpecific(eps,EPS_CLASSID,1);
if (!EPSRegisterAllCalled) { ierr = EPSRegisterAll();CHKERRQ(ierr); }
ierr = PetscObjectOptionsBegin((PetscObject)eps);CHKERRQ(ierr);
ierr = PetscOptionsFList("-eps_type","Eigenvalue Problem Solver method","EPSSetType",EPSList,(char*)(((PetscObject)eps)->type_name?((PetscObject)eps)->type_name:EPSKRYLOVSCHUR),type,256,&flg);CHKERRQ(ierr);
if (flg) {
ierr = EPSSetType(eps,type);CHKERRQ(ierr);
}
/*
Set the type if it was never set.
*/
if (!((PetscObject)eps)->type_name) {
ierr = EPSSetType(eps,EPSKRYLOVSCHUR);CHKERRQ(ierr);
}
ierr = PetscOptionsBoolGroupBegin("-eps_hermitian","hermitian eigenvalue problem","EPSSetProblemType",&flg);CHKERRQ(ierr);
if (flg) { ierr = EPSSetProblemType(eps,EPS_HEP);CHKERRQ(ierr); }
ierr = PetscOptionsBoolGroup("-eps_gen_hermitian","generalized hermitian eigenvalue problem","EPSSetProblemType",&flg);CHKERRQ(ierr);
if (flg) { ierr = EPSSetProblemType(eps,EPS_GHEP);CHKERRQ(ierr); }
ierr = PetscOptionsBoolGroup("-eps_non_hermitian","non-hermitian eigenvalue problem","EPSSetProblemType",&flg);CHKERRQ(ierr);
if (flg) { ierr = EPSSetProblemType(eps,EPS_NHEP);CHKERRQ(ierr); }
ierr = PetscOptionsBoolGroup("-eps_gen_non_hermitian","generalized non-hermitian eigenvalue problem","EPSSetProblemType",&flg);CHKERRQ(ierr);
if (flg) { ierr = EPSSetProblemType(eps,EPS_GNHEP);CHKERRQ(ierr); }
ierr = PetscOptionsBoolGroup("-eps_pos_gen_non_hermitian","generalized non-hermitian eigenvalue problem with positive semi-definite B","EPSSetProblemType",&flg);CHKERRQ(ierr);
if (flg) { ierr = EPSSetProblemType(eps,EPS_PGNHEP);CHKERRQ(ierr); }
ierr = PetscOptionsBoolGroupEnd("-eps_gen_indefinite","generalized hermitian-indefinite eigenvalue problem","EPSSetProblemType",&flg);CHKERRQ(ierr);
if (flg) { ierr = EPSSetProblemType(eps,EPS_GHIEP);CHKERRQ(ierr); }
ierr = PetscOptionsBoolGroupBegin("-eps_ritz","Rayleigh-Ritz extraction","EPSSetExtraction",&flg);CHKERRQ(ierr);
if (flg) { ierr = EPSSetExtraction(eps,EPS_RITZ);CHKERRQ(ierr); }
ierr = PetscOptionsBoolGroup("-eps_harmonic","harmonic Ritz extraction","EPSSetExtraction",&flg);CHKERRQ(ierr);
if (flg) { ierr = EPSSetExtraction(eps,EPS_HARMONIC);CHKERRQ(ierr); }
ierr = PetscOptionsBoolGroup("-eps_harmonic_relative","relative harmonic Ritz extraction","EPSSetExtraction",&flg);CHKERRQ(ierr);
if (flg) { ierr = EPSSetExtraction(eps,EPS_HARMONIC_RELATIVE);CHKERRQ(ierr); }
ierr = PetscOptionsBoolGroup("-eps_harmonic_right","right harmonic Ritz extraction","EPSSetExtraction",&flg);CHKERRQ(ierr);
if (flg) { ierr = EPSSetExtraction(eps,EPS_HARMONIC_RIGHT);CHKERRQ(ierr); }
ierr = PetscOptionsBoolGroup("-eps_harmonic_largest","largest harmonic Ritz extraction","EPSSetExtraction",&flg);CHKERRQ(ierr);
if (flg) { ierr = EPSSetExtraction(eps,EPS_HARMONIC_LARGEST);CHKERRQ(ierr); }
ierr = PetscOptionsBoolGroup("-eps_refined","refined Ritz extraction","EPSSetExtraction",&flg);CHKERRQ(ierr);
if (flg) { ierr = EPSSetExtraction(eps,EPS_REFINED);CHKERRQ(ierr); }
ierr = PetscOptionsBoolGroupEnd("-eps_refined_harmonic","refined harmonic Ritz extraction","EPSSetExtraction",&flg);CHKERRQ(ierr);
if (flg) { ierr = EPSSetExtraction(eps,EPS_REFINED_HARMONIC);CHKERRQ(ierr); }
ierr = PetscOptionsEnum("-eps_balance","Balancing method","EPSSetBalance",EPSBalanceTypes,(PetscEnum)eps->balance,(PetscEnum*)&eps->balance,NULL);CHKERRQ(ierr);
j = eps->balance_its;
ierr = PetscOptionsInt("-eps_balance_its","Number of iterations in balancing","EPSSetBalance",eps->balance_its,&j,&flg1);CHKERRQ(ierr);
r = eps->balance_cutoff;
ierr = PetscOptionsReal("-eps_balance_cutoff","Cutoff value in balancing","EPSSetBalance",eps->balance_cutoff,&r,&flg2);CHKERRQ(ierr);
if (flg1 || flg2) {
ierr = EPSSetBalance(eps,eps->balance,j,r);CHKERRQ(ierr);
}
i = eps->max_it? eps->max_it: PETSC_DEFAULT;
ierr = PetscOptionsInt("-eps_max_it","Maximum number of iterations","EPSSetTolerances",eps->max_it,&i,&flg1);CHKERRQ(ierr);
r = eps->tol;
ierr = PetscOptionsReal("-eps_tol","Tolerance","EPSSetTolerances",eps->tol==PETSC_DEFAULT?SLEPC_DEFAULT_TOL:eps->tol,&r,&flg2);CHKERRQ(ierr);
if (flg1 || flg2) {
ierr = EPSSetTolerances(eps,r,i);CHKERRQ(ierr);
}
ierr = PetscOptionsBoolGroupBegin("-eps_conv_eig","Relative error convergence test","EPSSetConvergenceTest",&flg);CHKERRQ(ierr);
if (flg) { ierr = EPSSetConvergenceTest(eps,EPS_CONV_EIG);CHKERRQ(ierr); }
ierr = PetscOptionsBoolGroup("-eps_conv_norm","Convergence test relative to the eigenvalue and the matrix norms","EPSSetConvergenceTest",&flg);CHKERRQ(ierr);
if (flg) { ierr = EPSSetConvergenceTest(eps,EPS_CONV_NORM);CHKERRQ(ierr); }
ierr = PetscOptionsBoolGroup("-eps_conv_abs","Absolute error convergence test","EPSSetConvergenceTest",&flg);CHKERRQ(ierr);
if (flg) { ierr = EPSSetConvergenceTest(eps,EPS_CONV_ABS);CHKERRQ(ierr); }
ierr = PetscOptionsBoolGroupEnd("-eps_conv_user","User-defined convergence test","EPSSetConvergenceTest",&flg);CHKERRQ(ierr);
if (flg) { ierr = EPSSetConvergenceTest(eps,EPS_CONV_USER);CHKERRQ(ierr); }
i = eps->nev;
ierr = PetscOptionsInt("-eps_nev","Number of eigenvalues to compute","EPSSetDimensions",eps->nev,&i,&flg1);CHKERRQ(ierr);
j = eps->ncv? eps->ncv: PETSC_DEFAULT;
ierr = PetscOptionsInt("-eps_ncv","Number of basis vectors","EPSSetDimensions",eps->ncv,&j,&flg2);CHKERRQ(ierr);
k = eps->mpd? eps->mpd: PETSC_DEFAULT;
ierr = PetscOptionsInt("-eps_mpd","Maximum dimension of projected problem","EPSSetDimensions",eps->mpd,&k,&flg3);CHKERRQ(ierr);
if (flg1 || flg2 || flg3) {
ierr = EPSSetDimensions(eps,i,j,k);CHKERRQ(ierr);
}
/* -----------------------------------------------------------------------*/
/*
Cancels all monitors hardwired into code before call to EPSSetFromOptions()
*/
flg = PETSC_FALSE;
ierr = PetscOptionsBool("-eps_monitor_cancel","Remove any hardwired monitor routines","EPSMonitorCancel",flg,&flg,NULL);CHKERRQ(ierr);
if (flg) {
ierr = EPSMonitorCancel(eps);CHKERRQ(ierr);
}
/*
Prints approximate eigenvalues and error estimates at each iteration
*/
ierr = PetscOptionsString("-eps_monitor","Monitor first unconverged approximate eigenvalue and error estimate","EPSMonitorSet","stdout",monfilename,PETSC_MAX_PATH_LEN,&flg);CHKERRQ(ierr);
if (flg) {
ierr = PetscViewerASCIIOpen(PetscObjectComm((PetscObject)eps),monfilename,&monviewer);CHKERRQ(ierr);
ierr = EPSMonitorSet(eps,EPSMonitorFirst,monviewer,(PetscErrorCode (*)(void**))PetscViewerDestroy);CHKERRQ(ierr);
}
ierr = PetscOptionsString("-eps_monitor_conv","Monitor approximate eigenvalues and error estimates as they converge","EPSMonitorSet","stdout",monfilename,PETSC_MAX_PATH_LEN,&flg);CHKERRQ(ierr);
if (flg) {
ierr = PetscNew(&ctx);CHKERRQ(ierr);
ierr = PetscViewerASCIIOpen(PetscObjectComm((PetscObject)eps),monfilename,&ctx->viewer);CHKERRQ(ierr);
ierr = EPSMonitorSet(eps,EPSMonitorConverged,ctx,(PetscErrorCode (*)(void**))SlepcConvMonitorDestroy);CHKERRQ(ierr);
}
ierr = PetscOptionsString("-eps_monitor_all","Monitor approximate eigenvalues and error estimates","EPSMonitorSet","stdout",monfilename,PETSC_MAX_PATH_LEN,&flg);CHKERRQ(ierr);
if (flg) {
ierr = PetscViewerASCIIOpen(PetscObjectComm((PetscObject)eps),monfilename,&monviewer);CHKERRQ(ierr);
ierr = EPSMonitorSet(eps,EPSMonitorAll,monviewer,(PetscErrorCode (*)(void**))PetscViewerDestroy);CHKERRQ(ierr);
ierr = EPSSetTrackAll(eps,PETSC_TRUE);CHKERRQ(ierr);
}
flg = PETSC_FALSE;
ierr = PetscOptionsBool("-eps_monitor_lg","Monitor first unconverged approximate eigenvalue and error estimate graphically","EPSMonitorSet",flg,&flg,NULL);CHKERRQ(ierr);
if (flg) {
ierr = EPSMonitorSet(eps,EPSMonitorLG,NULL,NULL);CHKERRQ(ierr);
}
flg = PETSC_FALSE;
ierr = PetscOptionsBool("-eps_monitor_lg_all","Monitor error estimates graphically","EPSMonitorSet",flg,&flg,NULL);CHKERRQ(ierr);
if (flg) {
ierr = EPSMonitorSet(eps,EPSMonitorLGAll,NULL,NULL);CHKERRQ(ierr);
ierr = EPSSetTrackAll(eps,PETSC_TRUE);CHKERRQ(ierr);
}
/* -----------------------------------------------------------------------*/
ierr = PetscOptionsBoolGroupBegin("-eps_largest_magnitude","compute largest eigenvalues in magnitude","EPSSetWhichEigenpairs",&flg);CHKERRQ(ierr);
if (flg) { ierr = EPSSetWhichEigenpairs(eps,EPS_LARGEST_MAGNITUDE);CHKERRQ(ierr); }
ierr = PetscOptionsBoolGroup("-eps_smallest_magnitude","compute smallest eigenvalues in magnitude","EPSSetWhichEigenpairs",&flg);CHKERRQ(ierr);
if (flg) { ierr = EPSSetWhichEigenpairs(eps,EPS_SMALLEST_MAGNITUDE);CHKERRQ(ierr); }
ierr = PetscOptionsBoolGroup("-eps_largest_real","compute largest real parts","EPSSetWhichEigenpairs",&flg);CHKERRQ(ierr);
if (flg) { ierr = EPSSetWhichEigenpairs(eps,EPS_LARGEST_REAL);CHKERRQ(ierr); }
ierr = PetscOptionsBoolGroup("-eps_smallest_real","compute smallest real parts","EPSSetWhichEigenpairs",&flg);CHKERRQ(ierr);
if (flg) { ierr = EPSSetWhichEigenpairs(eps,EPS_SMALLEST_REAL);CHKERRQ(ierr); }
ierr = PetscOptionsBoolGroup("-eps_largest_imaginary","compute largest imaginary parts","EPSSetWhichEigenpairs",&flg);CHKERRQ(ierr);
if (flg) { ierr = EPSSetWhichEigenpairs(eps,EPS_LARGEST_IMAGINARY);CHKERRQ(ierr); }
ierr = PetscOptionsBoolGroup("-eps_smallest_imaginary","compute smallest imaginary parts","EPSSetWhichEigenpairs",&flg);CHKERRQ(ierr);
if (flg) { ierr = EPSSetWhichEigenpairs(eps,EPS_SMALLEST_IMAGINARY);CHKERRQ(ierr); }
ierr = PetscOptionsBoolGroup("-eps_target_magnitude","compute nearest eigenvalues to target","EPSSetWhichEigenpairs",&flg);CHKERRQ(ierr);
if (flg) { ierr = EPSSetWhichEigenpairs(eps,EPS_TARGET_MAGNITUDE);CHKERRQ(ierr); }
ierr = PetscOptionsBoolGroup("-eps_target_real","compute eigenvalues with real parts close to target","EPSSetWhichEigenpairs",&flg);CHKERRQ(ierr);
if (flg) { ierr = EPSSetWhichEigenpairs(eps,EPS_TARGET_REAL);CHKERRQ(ierr); }
ierr = PetscOptionsBoolGroup("-eps_target_imaginary","compute eigenvalues with imaginary parts close to target","EPSSetWhichEigenpairs",&flg);CHKERRQ(ierr);
if (flg) { ierr = EPSSetWhichEigenpairs(eps,EPS_TARGET_IMAGINARY);CHKERRQ(ierr); }
ierr = PetscOptionsBoolGroupEnd("-eps_all","compute all eigenvalues in an interval","EPSSetWhichEigenpairs",&flg);CHKERRQ(ierr);
if (flg) { ierr = EPSSetWhichEigenpairs(eps,EPS_ALL);CHKERRQ(ierr); }
ierr = PetscOptionsScalar("-eps_target","Value of the target","EPSSetTarget",eps->target,&s,&flg);CHKERRQ(ierr);
if (flg) {
if (eps->which!=EPS_TARGET_REAL && eps->which!=EPS_TARGET_IMAGINARY) {
ierr = EPSSetWhichEigenpairs(eps,EPS_TARGET_MAGNITUDE);CHKERRQ(ierr);
}
ierr = EPSSetTarget(eps,s);CHKERRQ(ierr);
}
k = 2;
ierr = PetscOptionsRealArray("-eps_interval","Computational interval (two real values separated with a comma without spaces)","EPSSetInterval",array,&k,&flg);CHKERRQ(ierr);
if (flg) {
if (k<2) SETERRQ(PetscObjectComm((PetscObject)eps),PETSC_ERR_ARG_SIZ,"Must pass two values in -eps_interval (comma-separated without spaces)");
ierr = EPSSetWhichEigenpairs(eps,EPS_ALL);CHKERRQ(ierr);
ierr = EPSSetInterval(eps,array[0],array[1]);CHKERRQ(ierr);
}
ierr = PetscOptionsBool("-eps_true_residual","Compute true residuals explicitly","EPSSetTrueResidual",eps->trueres,&eps->trueres,NULL);CHKERRQ(ierr);
ierr = PetscOptionsName("-eps_view","Print detailed information on solver used","EPSView",0);CHKERRQ(ierr);
ierr = PetscOptionsName("-eps_plot_eigs","Make a plot of the computed eigenvalues","EPSSolve",0);CHKERRQ(ierr);
if (eps->ops->setfromoptions) {
ierr = (*eps->ops->setfromoptions)(eps);CHKERRQ(ierr);
}
ierr = PetscObjectProcessOptionsHandlers((PetscObject)eps);CHKERRQ(ierr);
ierr = PetscOptionsEnd();CHKERRQ(ierr);
if (!eps->V) { ierr = EPSGetBV(eps,&eps->V);CHKERRQ(ierr); }
ierr = BVSetFromOptions(eps->V);CHKERRQ(ierr);
if (!eps->rg) { ierr = EPSGetRG(eps,&eps->rg);CHKERRQ(ierr); }
ierr = RGSetFromOptions(eps->rg);CHKERRQ(ierr);
if (!eps->ds) { ierr = EPSGetDS(eps,&eps->ds);CHKERRQ(ierr); }
ierr = DSSetFromOptions(eps->ds);CHKERRQ(ierr);
ierr = STSetFromOptions(eps->st);CHKERRQ(ierr);
ierr = PetscRandomSetFromOptions(eps->rand);CHKERRQ(ierr);
PetscFunctionReturn(0);
}
