int main(int argc, char *argv[])
{
bool boolret;
int MyPID;
#ifdef HAVE_MPI
// Initialize MPI
MPI_Init(&argc,&argv);
Epetra_MpiComm Comm(MPI_COMM_WORLD);
#else
Epetra_SerialComm Comm;
#endif
MyPID = Comm.MyPID();
bool testFailed;
bool verbose = false;
bool debug = false;
bool shortrun = false;
bool insitu = false;
std::string which("LM");
CommandLineProcessor cmdp(false,true);
cmdp.setOption("verbose","quiet",&verbose,"Print messages and results.");
cmdp.setOption("debug","nodebug",&debug,"Print debugging information.");
cmdp.setOption("insitu","exsitu",&insitu,"Perform in situ restarting.");
cmdp.setOption("sort",&which,"Targetted eigenvalues (SM or LM).");
cmdp.setOption("shortrun","longrun",&shortrun,"Allow only a small number of iterations.");
if (cmdp.parse(argc,argv) != CommandLineProcessor::PARSE_SUCCESSFUL) {
#ifdef HAVE_MPI
MPI_Finalize();
#endif
return -1;
}
if (debug) verbose = true;
typedef double ScalarType;
typedef ScalarTraits<ScalarType> SCT;
typedef SCT::magnitudeType MagnitudeType;
typedef Anasazi::MultiVec<ScalarType> MV;
typedef Anasazi::Operator<ScalarType> OP;
typedef Anasazi::MultiVecTraits<ScalarType,MV> MVT;
typedef Anasazi::OperatorTraits<ScalarType,MV,OP> OPT;
const ScalarType ONE = SCT::one();
if (verbose && MyPID == 0) {
cout << Anasazi::Anasazi_Version() << endl << endl;
}
// Problem information
int space_dim = 1;
std::vector<double> brick_dim( space_dim );
brick_dim[0] = 1.0;
std::vector<int> elements( space_dim );
elements[0] = 100;
// Create problem
RCP<ModalProblem> testCase = rcp( new ModeLaplace1DQ1(Comm, brick_dim[0], elements[0]) );
//
// Get the stiffness and mass matrices
RCP<Epetra_CrsMatrix> K = rcp( const_cast<Epetra_CrsMatrix *>(testCase->getStiffness()), false );
RCP<Epetra_CrsMatrix> M = rcp( const_cast<Epetra_CrsMatrix *>(testCase->getMass()), false );
//
// Create solver for mass matrix
const int maxIterCG = 100;
const double tolCG = 1e-7;
RCP<BlockPCGSolver> opStiffness = rcp( new BlockPCGSolver(Comm, M.get(), tolCG, maxIterCG, 0) );
opStiffness->setPreconditioner( 0 );
RCP<const Anasazi::EpetraGenOp> InverseOp = rcp( new Anasazi::EpetraGenOp( opStiffness, K ) );
// Create the initial vectors
int blockSize = 3;
RCP<Anasazi::EpetraOpMultiVec> ivec = rcp( new Anasazi::EpetraOpMultiVec(K, K->OperatorDomainMap(), blockSize) );
ivec->MvRandom();
// Create eigenproblem
const int nev = 5;
RCP<Anasazi::BasicEigenproblem<ScalarType,MV,OP> > problem =
rcp( new Anasazi::BasicEigenproblem<ScalarType,MV,OP>(InverseOp, ivec) );
//
// Inform the eigenproblem that the operator InverseOp is Hermitian under an M inner-product
problem->setHermitian(true);
//
// Set the number of eigenvalues requested
problem->setNEV( nev );
//
// Inform the eigenproblem that you are done passing it information
boolret = problem->setProblem();
if (boolret != true) {
if (verbose && MyPID == 0) {
cout << "Anasazi::BasicEigenproblem::SetProblem() returned with error." << endl
<< "End Result: TEST FAILED" << endl;
}
#ifdef HAVE_MPI
MPI_Finalize() ;
#endif
return -1;
}
// Set verbosity level
int verbosity = Anasazi::Errors + Anasazi::Warnings;
if (verbose) {
verbosity += Anasazi::FinalSummary + Anasazi::TimingDetails;
}
if (debug) {
verbosity += Anasazi::Debug;
}
// Eigensolver parameters
int numBlocks;
int maxRestarts;
if (shortrun) {
maxRestarts = 25;
numBlocks = 5;
}
else {
maxRestarts = 50;
numBlocks = 10;
}
int stepSize = numBlocks*maxRestarts;
MagnitudeType tol = tolCG * 10.0;
// Create a sort manager to pass into the block Krylov-Schur solver manager
// --> Make sure the reference-counted pointer is of type Anasazi::SortManager<>
// --> The block Krylov-Schur solver manager uses Anasazi::BasicSort<> by default,
// so you can also pass in the parameter "Which", instead of a sort manager.
RCP<Anasazi::SortManager<MagnitudeType> > MySort =
rcp( new Anasazi::BasicSort<MagnitudeType>( which ) );
//
// Create parameter list to pass into the solver manager
ParameterList MyPL;
MyPL.set( "Verbosity", verbosity );
MyPL.set( "Sort Manager", MySort );
//MyPL.set( "Which", which );
MyPL.set( "Block Size", blockSize );
MyPL.set( "Num Blocks", numBlocks );
MyPL.set( "Maximum Restarts", maxRestarts );
MyPL.set( "Step Size", stepSize );
MyPL.set( "Convergence Tolerance", tol );
MyPL.set( "In Situ Restarting", insitu );
//
// Create the solver manager
Anasazi::BlockKrylovSchurSolMgr<ScalarType,MV,OP> MySolverMgr(problem, MyPL);
//
// Check that the parameters were all consumed
if (MyPL.getEntryPtr("Verbosity")->isUsed() == false ||
MyPL.getEntryPtr("Block Size")->isUsed() == false ||
MyPL.getEntryPtr("Num Blocks")->isUsed() == false ||
MyPL.getEntryPtr("Maximum Restarts")->isUsed() == false ||
MyPL.getEntryPtr("Step Size")->isUsed() == false ||
MyPL.getEntryPtr("In Situ Restarting")->isUsed() == false ||
MyPL.getEntryPtr("Convergence Tolerance")->isUsed() == false) {
if (verbose && MyPID==0) {
cout << "Failure! Unused parameters: " << endl;
MyPL.unused(cout);
}
}
// Solve the problem to the specified tolerances or length
Anasazi::ReturnType returnCode = MySolverMgr.solve();
testFailed = false;
if (returnCode != Anasazi::Converged && shortrun==false) {
testFailed = true;
}
// Get the eigenvalues and eigenvectors from the eigenproblem
Anasazi::Eigensolution<ScalarType,MV> sol = problem->getSolution();
std::vector<Anasazi::Value<ScalarType> > evals = sol.Evals;
RCP<MV> evecs = sol.Evecs;
int numev = sol.numVecs;
if (numev > 0) {
std::ostringstream os;
os.setf(std::ios::scientific, std::ios::floatfield);
os.precision(6);
// Compute the direct residual
std::vector<ScalarType> normV( numev );
SerialDenseMatrix<int,ScalarType> T(numev,numev);
for (int i=0; i<numev; i++) {
T(i,i) = evals[i].realpart;
}
RCP<OP> KOp = rcp( new Anasazi::EpetraOp( K ));
RCP<OP> MOp = rcp( new Anasazi::EpetraOp( M ));
RCP<MV> Mvecs = MVT::Clone( *evecs, numev ),
Kvecs = MVT::Clone( *evecs, numev );
OPT::Apply( *KOp, *evecs, *Kvecs );
OPT::Apply( *MOp, *evecs, *Mvecs );
MVT::MvTimesMatAddMv( -ONE, *Mvecs, T, ONE, *Kvecs );
// compute 2-norm of residuals
std::vector<MagnitudeType> resnorm(numev);
MVT::MvNorm( *Kvecs, resnorm );
os << "Number of iterations performed in BlockKrylovSchur_test.exe: " << MySolverMgr.getNumIters() << endl
<< "Direct residual norms computed in BlockKrylovSchur_test.exe" << endl
<< std::setw(20) << "Eigenvalue" << std::setw(20) << "Residual" << endl
<< "----------------------------------------" << endl;
for (int i=0; i<numev; i++) {
if ( SCT::magnitude(evals[i].realpart) != SCT::zero() ) {
resnorm[i] = SCT::magnitude( SCT::squareroot( resnorm[i] ) / evals[i].realpart );
}
else {
resnorm[i] = SCT::magnitude( SCT::squareroot( resnorm[i] ) );
}
os << std::setw(20) << evals[i].realpart << std::setw(20) << resnorm[i] << endl;
if ( resnorm[i] > tol ) {
testFailed = true;
}
}
if (verbose && MyPID==0) {
cout << endl << os.str() << endl;
}
}
#ifdef HAVE_MPI
MPI_Finalize() ;
#endif
if (testFailed) {
if (verbose && MyPID==0) {
cout << "End Result: TEST FAILED" << endl;
}
return -1;
}
//
// Default return value
//
if (verbose && MyPID==0) {
cout << "End Result: TEST PASSED" << endl;
}
return 0;
}
int main(int argc, char *argv[])
{
using Teuchos::rcp_implicit_cast;
using std::cout;
using std::endl;
bool boolret;
int MyPID;
#ifdef HAVE_MPI
// Initialize MPI
MPI_Init(&argc,&argv);
Epetra_MpiComm Comm(MPI_COMM_WORLD);
#else
Epetra_SerialComm Comm;
#endif
MyPID = Comm.MyPID();
bool testFailed = false;
bool verbose = false;
bool debug = false;
std::string filename("mhd1280b.cua");
std::string which("LR");
bool skinny = true;
bool success = true;
try {
CommandLineProcessor cmdp(false,true);
cmdp.setOption("verbose","quiet",&verbose,"Print messages and results.");
cmdp.setOption("debug","nodebug",&debug,"Print debugging information.");
cmdp.setOption("sort",&which,"Targetted eigenvalues (SR or LR).");
cmdp.setOption("skinny","hefty",&skinny,"Use a skinny (low-mem) or hefty (higher-mem) implementation of IRTR.");
if (cmdp.parse(argc,argv) != CommandLineProcessor::PARSE_SUCCESSFUL) {
#ifdef HAVE_MPI
MPI_Finalize();
#endif
return -1;
}
#ifndef HAVE_EPETRA_THYRA
if (verbose && MyPid == 0) {
cout << "Please configure Anasazi with:" << endl;
cout << "--enable-epetra-thyra" << endl;
cout << "--enable-anasazi-thyra" << endl;
}
return 0;
#endif
typedef double ScalarType;
typedef ScalarTraits<ScalarType> SCT;
typedef SCT::magnitudeType MagnitudeType;
typedef Thyra::MultiVectorBase<double> MV;
typedef Thyra::LinearOpBase<double> OP;
typedef Anasazi::MultiVecTraits<ScalarType,MV> MVT;
typedef Anasazi::OperatorTraits<ScalarType,MV,OP> OPT;
const ScalarType ONE = SCT::one();
if (verbose && MyPID == 0) {
cout << Anasazi::Anasazi_Version() << endl << endl;
}
// Problem information
int space_dim = 1;
std::vector<double> brick_dim( space_dim );
brick_dim[0] = 1.0;
std::vector<int> elements( space_dim );
elements[0] = 100;
// Create problem
RCP<ModalProblem> testCase = rcp( new ModeLaplace1DQ1(Comm, brick_dim[0], elements[0]) );
//
// Get the stiffness and mass matrices
RCP<Epetra_CrsMatrix> K = rcp( const_cast<Epetra_CrsMatrix *>(testCase->getStiffness()), false );
RCP<Epetra_CrsMatrix> M = rcp( const_cast<Epetra_CrsMatrix *>(testCase->getMass()), false );
//
// Create the initial vectors
int blockSize = 5;
//
// Get a pointer to the Epetra_Map
RCP<const Epetra_Map> Map = rcp( &K->OperatorDomainMap(), false );
//
// create an epetra multivector
RCP<Epetra_MultiVector> ivec =
rcp( new Epetra_MultiVector(K->OperatorDomainMap(), blockSize) );
ivec->Random();
// create a Thyra::VectorSpaceBase
RCP<const Thyra::VectorSpaceBase<double> > epetra_vs =
Thyra::create_VectorSpace(Map);
// create a MultiVectorBase (from the Epetra_MultiVector)
RCP<Thyra::MultiVectorBase<double> > thyra_ivec =
Thyra::create_MultiVector(ivec, epetra_vs);
// Create Thyra LinearOpBase objects from the Epetra_Operator objects
RCP<const Thyra::LinearOpBase<double> > thyra_K =
Thyra::epetraLinearOp(K);
RCP<const Thyra::LinearOpBase<double> > thyra_M =
Thyra::epetraLinearOp(M);
// Create eigenproblem
const int nev = 5;
RCP<Anasazi::BasicEigenproblem<ScalarType,MV,OP> > problem =
rcp( new Anasazi::BasicEigenproblem<ScalarType,MV,OP>(thyra_K,thyra_M,thyra_ivec) );
//
// Inform the eigenproblem that the operator K is symmetric
problem->setHermitian(true);
//
// Set the number of eigenvalues requested
problem->setNEV( nev );
//
// Inform the eigenproblem that you are done passing it information
boolret = problem->setProblem();
if (boolret != true) {
if (verbose && MyPID == 0) {
cout << "Anasazi::BasicEigenproblem::SetProblem() returned with error." << endl
<< "End Result: TEST FAILED" << endl;
}
#ifdef HAVE_MPI
MPI_Finalize() ;
#endif
return -1;
}
// Set verbosity level
int verbosity = Anasazi::Errors + Anasazi::Warnings;
if (verbose) {
verbosity += Anasazi::FinalSummary + Anasazi::TimingDetails;
}
if (debug) {
verbosity += Anasazi::Debug;
}
// Eigensolver parameters
int maxIters = 450;
MagnitudeType tol = 1.0e-6;
//
// Create parameter list to pass into the solver manager
ParameterList MyPL;
MyPL.set( "Verbosity", verbosity );
MyPL.set( "Which", which );
MyPL.set( "Block Size", blockSize );
MyPL.set( "Maximum Iterations", maxIters );
MyPL.set( "Convergence Tolerance", tol );
MyPL.set( "Skinny Solver", skinny);
//
// Create the solver manager
Anasazi::RTRSolMgr<ScalarType,MV,OP> MySolverMan(problem, MyPL);
//
// Check that the parameters were all consumed
if (MyPL.getEntryPtr("Verbosity")->isUsed() == false ||
MyPL.getEntryPtr("Which")->isUsed() == false ||
MyPL.getEntryPtr("Block Size")->isUsed() == false ||
MyPL.getEntryPtr("Maximum Iterations")->isUsed() == false ||
MyPL.getEntryPtr("Convergence Tolerance")->isUsed() == false ||
MyPL.getEntryPtr("Skinny Solver")->isUsed() == false) {
if (verbose && MyPID==0) {
cout << "Failure! Unused parameters: " << endl;
MyPL.unused(cout);
}
}
// Solve the problem to the specified tolerances or length
Anasazi::ReturnType returnCode = MySolverMan.solve();
if (returnCode != Anasazi::Converged) {
testFailed = true;
}
// Get the eigenvalues and eigenvectors from the eigenproblem
Anasazi::Eigensolution<ScalarType,MV> sol = problem->getSolution();
std::vector<Anasazi::Value<ScalarType> > evals = sol.Evals;
RCP<MV> evecs = sol.Evecs;
int numev = sol.numVecs;
if (numev > 0) {
std::ostringstream os;
os.setf(std::ios::scientific, std::ios::floatfield);
os.precision(6);
// Compute the direct residual
std::vector<ScalarType> normV( numev );
SerialDenseMatrix<int,ScalarType> T(numev,numev);
for (int i=0; i<numev; i++) {
T(i,i) = evals[i].realpart;
}
RCP<MV> Mvecs = MVT::Clone( *evecs, numev ),
Kvecs = MVT::Clone( *evecs, numev );
OPT::Apply( *thyra_K, *evecs, *Kvecs );
OPT::Apply( *thyra_M, *evecs, *Mvecs );
MVT::MvTimesMatAddMv( -ONE, *Mvecs, T, ONE, *Kvecs );
// compute M-norm of residuals
OPT::Apply( *thyra_M, *Kvecs, *Mvecs );
MVT::MvDot( *Mvecs, *Kvecs, normV );
os << "Direct residual norms computed in LOBPCGThyra_test.exe" << endl
<< std::setw(20) << "Eigenvalue" << std::setw(20) << "Residual(M)" << endl
<< "----------------------------------------" << endl;
for (int i=0; i<numev; i++) {
if ( SCT::magnitude(evals[i].realpart) != SCT::zero() ) {
normV[i] = SCT::magnitude( SCT::squareroot( normV[i] ) / evals[i].realpart );
}
else {
normV[i] = SCT::magnitude( SCT::squareroot( normV[i] ) );
}
os << std::setw(20) << evals[i].realpart << std::setw(20) << normV[i] << endl;
if ( normV[i] > tol ) {
testFailed = true;
}
}
if (verbose && MyPID==0) {
cout << endl << os.str() << endl;
}
}
}
TEUCHOS_STANDARD_CATCH_STATEMENTS(true,cout,success);
#ifdef HAVE_MPI
MPI_Finalize() ;
#endif
if (testFailed || success==false) {
if (verbose && MyPID==0) {
cout << "End Result: TEST FAILED" << endl;
}
return -1;
}
//
// Default return value
//
if (verbose && MyPID==0) {
cout << "End Result: TEST PASSED" << endl;
}
return 0;
}
int main(int argc, char *argv[])
{
using std::cout;
using std::endl;
int info = 0;
bool boolret;
int MyPID;
#ifdef HAVE_MPI
// Initialize MPI
MPI_Init(&argc,&argv);
MPI_Comm_rank( MPI_COMM_WORLD, &MyPID );
#else
MyPID = 0;
#endif
bool testFailed;
bool verbose = false;
bool debug = false;
bool shortrun = false;
bool insitu = false;
bool locking = true;
std::string filename("mhd1280b.cua");
std::string which("LM");
CommandLineProcessor cmdp(false,true);
cmdp.setOption("verbose","quiet",&verbose,"Print messages and results.");
cmdp.setOption("debug","nodebug",&debug,"Print debugging information.");
cmdp.setOption("insitu","exsitu",&insitu,"Perform in situ restarting.");
cmdp.setOption("locking","nolocking",&locking,"Perform locking.");
cmdp.setOption("filename",&filename,"Filename for Harwell-Boeing test matrix.");
cmdp.setOption("sort",&which,"Targetted eigenvalues (SM or LM).");
cmdp.setOption("shortrun","longrun",&shortrun,"Allow only a small number of iterations.");
if (cmdp.parse(argc,argv) != CommandLineProcessor::PARSE_SUCCESSFUL) {
#ifdef HAVE_MPI
MPI_Finalize();
#endif
return -1;
}
if (debug) verbose = true;
#ifndef HAVE_ANASAZI_TRIUTILS
cout << "This test requires Triutils. Please configure with --enable-triutils." << endl;
#ifdef HAVE_MPI
MPI_Finalize() ;
#endif
if (verbose && MyPID == 0) {
cout << "End Result: TEST FAILED" << endl;
}
return -1;
#endif
#ifdef HAVE_COMPLEX
typedef std::complex<double> ScalarType;
#elif HAVE_COMPLEX_H
typedef ::complex<double> ScalarType;
#else
typedef double ScalarType;
// no complex. quit with failure.
if (verbose && MyPID == 0) {
cout << "Not compiled with complex support." << endl;
cout << "End Result: TEST FAILED" << endl;
#ifdef HAVE_MPI
MPI_Finalize();
#endif
return -1;
}
#endif
typedef ScalarTraits<ScalarType> SCT;
typedef SCT::magnitudeType MagnitudeType;
typedef Anasazi::MultiVec<ScalarType> MV;
typedef Anasazi::Operator<ScalarType> OP;
typedef Anasazi::MultiVecTraits<ScalarType,MV> MVT;
typedef Anasazi::OperatorTraits<ScalarType,MV,OP> OPT;
const ScalarType ONE = SCT::one();
if (verbose && MyPID == 0) {
cout << Anasazi::Anasazi_Version() << endl << endl;
}
// Problem information
int dim,dim2,nnz;
double *dvals;
int *colptr,*rowind;
nnz = -1;
info = readHB_newmat_double(filename.c_str(),&dim,&dim2,&nnz,
&colptr,&rowind,&dvals);
if (info == 0 || nnz < 0) {
if (verbose && MyPID == 0) {
cout << "Error reading '" << filename << "'" << endl
<< "End Result: TEST FAILED" << endl;
}
#ifdef HAVE_MPI
MPI_Finalize();
#endif
return -1;
}
// Convert interleaved doubles to complex values
std::vector<ScalarType> cvals(nnz);
for (int ii=0; ii<nnz; ii++) {
cvals[ii] = ScalarType(dvals[ii*2],dvals[ii*2+1]);
}
// Build the problem matrix
RCP< const MyBetterOperator<ScalarType> > K
= rcp( new MyBetterOperator<ScalarType>(dim,colptr,nnz,rowind,&cvals[0]) );
// Create initial vectors
int blockSize = 5;
RCP<MyMultiVec<ScalarType> > ivec = rcp( new MyMultiVec<ScalarType>(dim,blockSize) );
ivec->MvRandom();
// Create eigenproblem
const int nev = 4;
RCP<Anasazi::BasicEigenproblem<ScalarType,MV,OP> > problem =
rcp( new Anasazi::BasicEigenproblem<ScalarType,MV,OP>(K,ivec) );
//
// Inform the eigenproblem that the operator K is symmetric
problem->setHermitian(true);
//
// Set the number of eigenvalues requested
problem->setNEV( nev );
//
// Inform the eigenproblem that you are done passing it information
boolret = problem->setProblem();
if (boolret != true) {
if (verbose && MyPID == 0) {
cout << "Anasazi::BasicEigenproblem::SetProblem() returned with error." << endl
<< "End Result: TEST FAILED" << endl;
}
#ifdef HAVE_MPI
MPI_Finalize() ;
#endif
return -1;
}
// Set verbosity level
int verbosity = Anasazi::Errors + Anasazi::Warnings;
if (verbose) {
verbosity += Anasazi::FinalSummary + Anasazi::TimingDetails;
}
if (debug) {
verbosity += Anasazi::Debug;
}
// Eigensolver parameters
int numBlocks = 8;
int maxRestarts;
if (shortrun) {
maxRestarts = 10;
}
else {
maxRestarts = 100;
}
MagnitudeType tol = 1.0e-6;
//
// Create parameter list to pass into the solver manager
ParameterList MyPL;
MyPL.set( "Verbosity", verbosity );
MyPL.set( "Which", which );
MyPL.set( "Block Size", blockSize );
MyPL.set( "Num Blocks", numBlocks );
MyPL.set( "Maximum Restarts", maxRestarts );
MyPL.set( "Convergence Tolerance", tol );
MyPL.set( "Use Locking", locking );
MyPL.set( "Locking Tolerance", tol/10 );
MyPL.set( "In Situ Restarting", insitu );
//
// Create the solver manager
Anasazi::BlockDavidsonSolMgr<ScalarType,MV,OP> MySolverMan(problem, MyPL);
//
// Check that the parameters were all consumed
if (MyPL.getEntryPtr("Verbosity")->isUsed() == false ||
MyPL.getEntryPtr("Which")->isUsed() == false ||
MyPL.getEntryPtr("Block Size")->isUsed() == false ||
MyPL.getEntryPtr("Num Blocks")->isUsed() == false ||
MyPL.getEntryPtr("Maximum Restarts")->isUsed() == false ||
MyPL.getEntryPtr("Convergence Tolerance")->isUsed() == false ||
MyPL.getEntryPtr("Use Locking")->isUsed() == false ||
MyPL.getEntryPtr("In Situ Restarting")->isUsed() == false ||
MyPL.getEntryPtr("Locking Tolerance")->isUsed() == false) {
if (verbose && MyPID==0) {
cout << "Failure! Unused parameters: " << endl;
MyPL.unused(cout);
}
}
// Solve the problem to the specified tolerances or length
Anasazi::ReturnType returnCode = MySolverMan.solve();
testFailed = false;
if (returnCode != Anasazi::Converged && shortrun==false) {
testFailed = true;
}
// Get the eigenvalues and eigenvectors from the eigenproblem
Anasazi::Eigensolution<ScalarType,MV> sol = problem->getSolution();
RCP<MV> evecs = sol.Evecs;
int numev = sol.numVecs;
if (numev > 0) {
std::ostringstream os;
os.setf(std::ios::scientific, std::ios::floatfield);
os.precision(6);
// Compute the direct residual
std::vector<MagnitudeType> normV( numev );
SerialDenseMatrix<int,ScalarType> T(numev,numev);
for (int i=0; i<numev; i++) {
T(i,i) = sol.Evals[i].realpart;
}
RCP<MV> Kvecs = MVT::Clone( *evecs, numev );
OPT::Apply( *K, *evecs, *Kvecs );
MVT::MvTimesMatAddMv( -ONE, *evecs, T, ONE, *Kvecs );
MVT::MvNorm( *Kvecs, normV );
os << "Direct residual norms computed in BlockDavidsonComplex_test.exe" << endl
<< std::setw(20) << "Eigenvalue" << std::setw(20) << "Residual(M)" << endl
<< "----------------------------------------" << endl;
for (int i=0; i<numev; i++) {
if ( SCT::magnitude(sol.Evals[i].realpart) != SCT::zero() ) {
normV[i] = SCT::magnitude(normV[i]/sol.Evals[i].realpart);
}
os << std::setw(20) << sol.Evals[i].realpart << std::setw(20) << normV[i] << endl;
if ( normV[i] > tol ) {
testFailed = true;
}
}
if (verbose && MyPID==0) {
cout << endl << os.str() << endl;
}
}
#ifdef HAVE_MPI
MPI_Finalize() ;
#endif
// Clean up.
std::free( dvals );
std::free( colptr );
std::free( rowind );
if (testFailed) {
if (verbose && MyPID==0) {
cout << "End Result: TEST FAILED" << endl;
}
return -1;
}
//
// Default return value
//
if (verbose && MyPID==0) {
cout << "End Result: TEST PASSED" << endl;
}
return 0;
}
int main(int argc, char *argv[])
{
bool boolret;
int MyPID;
#ifdef HAVE_MPI
// Initialize MPI
MPI_Init(&argc,&argv);
Epetra_MpiComm Comm(MPI_COMM_WORLD);
#else
Epetra_SerialComm Comm;
#endif
MyPID = Comm.MyPID();
bool testFailed;
bool verbose = false;
bool debug = false;
std::string which("LM");
CommandLineProcessor cmdp(false,true);
cmdp.setOption("verbose","quiet",&verbose,"Print messages and results.");
cmdp.setOption("debug","nodebug",&debug,"Print debugging information.");
cmdp.setOption("sort",&which,"Targetted eigenvalues (SM or LM).");
if (cmdp.parse(argc,argv) != CommandLineProcessor::PARSE_SUCCESSFUL) {
#ifdef HAVE_MPI
MPI_Finalize();
#endif
return -1;
}
if (debug) verbose = true;
typedef double ScalarType;
typedef ScalarTraits<ScalarType> SCT;
typedef SCT::magnitudeType MagnitudeType;
typedef Epetra_MultiVector MV;
typedef Epetra_Operator OP;
typedef Anasazi::MultiVecTraits<ScalarType,MV> MVT;
typedef Anasazi::OperatorTraits<ScalarType,MV,OP> OPT;
const ScalarType ONE = SCT::one();
if (verbose && MyPID == 0) {
std::cout << Anasazi::Anasazi_Version() << std::endl << std::endl;
}
// Problem information
int space_dim = 1;
std::vector<double> brick_dim( space_dim );
brick_dim[0] = 1.0;
std::vector<int> elements( space_dim );
elements[0] = 100;
// Create problem
RCP<ModalProblem> testCase = rcp( new ModeLaplace1DQ1(Comm, brick_dim[0], elements[0]) );
//
// Get the stiffness and mass matrices
RCP<Epetra_CrsMatrix> K = rcp( const_cast<Epetra_CrsMatrix *>(testCase->getStiffness()), false );
RCP<Epetra_CrsMatrix> M = rcp( const_cast<Epetra_CrsMatrix *>(testCase->getMass()), false );
//
// Create solver for mass matrix
// Note that accuracy of Davidson solution does NOT depend on how accurately the BlockPCG is solved
const int maxIterCG = 10;
const double tolCG = 1e-2;
RCP<BlockPCGSolver> opStiffness = rcp( new BlockPCGSolver(Comm, M.get(), tolCG, maxIterCG, 0) );
opStiffness->setPreconditioner( 0 );
RCP<Epetra_Operator> invStiffness = rcp( new Epetra_InvOperator(opStiffness.get()) );
// Create the initial vectors
int blockSize = 3;
RCP<Epetra_MultiVector> ivec = rcp( new Epetra_MultiVector(K->OperatorDomainMap(), blockSize) );
ivec->Random();
// Create eigenproblem
const int nev = 5;
RCP<Anasazi::BasicEigenproblem<ScalarType,MV,OP> > problem =
rcp( new Anasazi::BasicEigenproblem<ScalarType,MV,OP>() );
problem->setA(K);
problem->setM(M);
problem->setPrec(invStiffness);
problem->setInitVec(ivec);
//
// Set the number of eigenvalues requested
problem->setNEV( nev );
//
// Inform the eigenproblem that you are done passing it information
boolret = problem->setProblem();
if (boolret != true) {
if (verbose && MyPID == 0) {
std::cout << "Anasazi::BasicEigenproblem::SetProblem() returned with error." << std::endl
<< "End Result: TEST FAILED" << std::endl;
}
#ifdef HAVE_MPI
MPI_Finalize() ;
#endif
return -1;
}
// Set verbosity level
int verbosity = Anasazi::Errors + Anasazi::Warnings;
if (verbose) {
verbosity += Anasazi::FinalSummary + Anasazi::TimingDetails;
}
if (debug) {
verbosity += Anasazi::Debug;
}
// Eigensolver parameters
int maxRestarts = 25;
int maxDim = 50;
MagnitudeType tol = 1e-6;
//
// Create parameter list to pass into the solver manager
ParameterList MyPL;
MyPL.set( "Verbosity", verbosity );
MyPL.set( "Which", which );
MyPL.set( "Maximum Subspace Dimension", maxDim );
MyPL.set( "Block Size", blockSize );
MyPL.set( "Maximum Restarts", maxRestarts );
MyPL.set( "Convergence Tolerance", tol );
//
// Create the solver manager
Anasazi::GeneralizedDavidsonSolMgr<ScalarType,MV,OP> MySolverMgr(problem, MyPL);
//
// Check that the parameters were all consumed
if (MyPL.getEntryPtr("Verbosity")->isUsed() == false ||
MyPL.getEntryPtr("Which")->isUsed() == false ||
MyPL.getEntryPtr("Maximum Subspace Dimension")->isUsed() == false ||
MyPL.getEntryPtr("Block Size")->isUsed() == false ||
MyPL.getEntryPtr("Maximum Restarts")->isUsed() == false ||
MyPL.getEntryPtr("Convergence Tolerance")->isUsed() == false) {
if (verbose && MyPID==0) {
std::cout << "Failure! Unused parameters: " << std::endl;
MyPL.unused(std::cout);
}
}
// Solve the problem to the specified tolerances or length
Anasazi::ReturnType returnCode = MySolverMgr.solve();
testFailed = false;
if (returnCode != Anasazi::Converged) {
testFailed = true;
}
// Get the eigenvalues and eigenvectors from the eigenproblem
Anasazi::Eigensolution<ScalarType,MV> sol = problem->getSolution();
std::vector<Anasazi::Value<ScalarType> > evals = sol.Evals;
RCP<MV> evecs = sol.Evecs;
int numev = sol.numVecs;
if (numev > 0) {
std::ostringstream os;
os.setf(std::ios::scientific, std::ios::floatfield);
os.precision(6);
// Compute the direct residual
std::vector<ScalarType> normV( numev );
SerialDenseMatrix<int,ScalarType> T(numev,numev);
for (int i=0; i<numev; i++) {
T(i,i) = evals[i].realpart;
}
RCP<MV> Mvecs = MVT::Clone( *evecs, numev );
RCP<MV> Kvecs = MVT::Clone( *evecs, numev );
OPT::Apply( *K, *evecs, *Kvecs );
OPT::Apply( *M, *evecs, *Mvecs );
MVT::MvTimesMatAddMv( -ONE, *Mvecs, T, ONE, *Kvecs );
// compute 2-norm of residuals
std::vector<MagnitudeType> resnorm(numev);
MVT::MvNorm( *Kvecs, resnorm );
os << "Number of iterations performed in GeneralizedDavidson_test.exe: " << MySolverMgr.getNumIters() << std::endl
<< "Direct residual norms computed in GeneralizedDavidson_test.exe" << std::endl
<< std::setw(20) << "Eigenvalue" << std::setw(20) << "Residual" << std::endl
<< "----------------------------------------" << std::endl;
for (int i=0; i<numev; i++) {
os << std::setw(20) << evals[i].realpart << std::setw(20) << resnorm[i] << std::endl;
if ( resnorm[i] > tol ) {
testFailed = true;
}
}
if (verbose && MyPID==0) {
std::cout << std::endl << os.str() << std::endl;
}
}
#ifdef HAVE_MPI
MPI_Finalize() ;
#endif
if (testFailed) {
if (verbose && MyPID==0) {
std::cout << "End Result: TEST FAILED" << std::endl;
}
return -1;
}
//
// Default return value
//
if (verbose && MyPID==0) {
std::cout << "End Result: TEST PASSED" << std::endl;
}
return 0;
}
int main(int argc, char *argv[])
{
bool boolret;
int MyPID;
#ifdef HAVE_MPI
// Initialize MPI
MPI_Init(&argc,&argv);
Epetra_MpiComm Comm(MPI_COMM_WORLD);
#else
Epetra_SerialComm Comm;
#endif
MyPID = Comm.MyPID();
bool testFailed;
bool verbose = false;
bool debug = false;
bool shortrun = false;
bool insitu = false;
bool locking = true;
std::string filename("mhd1280b.cua");
std::string which("LM");
int rblocks = 1;
CommandLineProcessor cmdp(false,true);
cmdp.setOption("verbose","quiet",&verbose,"Print messages and results.");
cmdp.setOption("debug","nodebug",&debug,"Print debugging information.");
cmdp.setOption("insitu","exsitu",&insitu,"Perform in situ restarting.");
cmdp.setOption("locking","nolocking",&locking,"Perform locking.");
cmdp.setOption("sort",&which,"Targetted eigenvalues (SM or LM).");
cmdp.setOption("shortrun","longrun",&shortrun,"Allow only a small number of iterations.");
cmdp.setOption("rblocks",&rblocks,"Number of blocks after restart.");
if (cmdp.parse(argc,argv) != CommandLineProcessor::PARSE_SUCCESSFUL) {
#ifdef HAVE_MPI
MPI_Finalize();
#endif
return -1;
}
if (debug) verbose = true;
typedef double ScalarType;
typedef ScalarTraits<ScalarType> SCT;
typedef SCT::magnitudeType MagnitudeType;
typedef Epetra_MultiVector MV;
typedef Epetra_Operator OP;
typedef Anasazi::MultiVecTraits<ScalarType,MV> MVT;
typedef Anasazi::OperatorTraits<ScalarType,MV,OP> OPT;
const ScalarType ONE = SCT::one();
if (verbose && MyPID == 0) {
cout << Anasazi::Anasazi_Version() << endl << endl;
}
// Problem information
int space_dim = 1;
std::vector<double> brick_dim( space_dim );
brick_dim[0] = 1.0;
std::vector<int> elements( space_dim );
elements[0] = 100;
// Create problem
RCP<ModalProblem> testCase = rcp( new ModeLaplace1DQ1(Comm, brick_dim[0], elements[0]) );
//
// Get the stiffness and mass matrices
RCP<const Epetra_CrsMatrix> K = rcp( const_cast<Epetra_CrsMatrix *>(testCase->getStiffness()), false );
RCP<const Epetra_CrsMatrix> M = rcp( const_cast<Epetra_CrsMatrix *>(testCase->getMass()), false );
//
// Create the initial vectors
int blockSize = 5;
RCP<Epetra_MultiVector> ivec = rcp( new Epetra_MultiVector(K->OperatorDomainMap(), blockSize) );
ivec->Random();
// Create eigenproblem
const int nev = 5;
RCP<Anasazi::BasicEigenproblem<ScalarType,MV,OP> > problem =
rcp( new Anasazi::BasicEigenproblem<ScalarType,MV,OP>(K,M,ivec) );
//
// Inform the eigenproblem that the operator K is symmetric
problem->setHermitian(true);
//
// Set the number of eigenvalues requested
problem->setNEV( nev );
//
// Inform the eigenproblem that you are done passing it information
boolret = problem->setProblem();
if (boolret != true) {
if (verbose && MyPID == 0) {
cout << "Anasazi::BasicEigenproblem::SetProblem() returned with error." << endl
<< "End Result: TEST FAILED" << endl;
}
#ifdef HAVE_MPI
MPI_Finalize() ;
#endif
return -1;
}
// Set verbosity level
int verbosity = Anasazi::Errors + Anasazi::Warnings;
if (verbose) {
verbosity += Anasazi::FinalSummary + Anasazi::TimingDetails;
}
if (debug) {
verbosity += Anasazi::Debug;
}
// Eigensolver parameters
int numBlocks = 8;
int maxRestarts;
if (shortrun) {
maxRestarts = 10;
}
else {
maxRestarts = 100;
}
MagnitudeType tol = 1.0e-6;
//
// Create parameter list to pass into the solver manager
ParameterList MyPL;
MyPL.set( "Verbosity", verbosity );
MyPL.set( "Which", which );
MyPL.set( "Block Size", blockSize );
MyPL.set( "Num Blocks", numBlocks );
MyPL.set( "Maximum Restarts", maxRestarts );
MyPL.set( "Convergence Tolerance", tol );
MyPL.set( "Use Locking", locking );
MyPL.set( "Locking Tolerance", tol/10 );
MyPL.set( "In Situ Restarting", insitu );
MyPL.set( "Num Restart Blocks", rblocks );
//
// Create the solver manager
Anasazi::BlockDavidsonSolMgr<ScalarType,MV,OP> MySolverMan(problem, MyPL);
//
// Check that the parameters were all consumed
if (MyPL.getEntryPtr("Verbosity")->isUsed() == false ||
MyPL.getEntryPtr("Which")->isUsed() == false ||
MyPL.getEntryPtr("Block Size")->isUsed() == false ||
MyPL.getEntryPtr("Num Blocks")->isUsed() == false ||
MyPL.getEntryPtr("Maximum Restarts")->isUsed() == false ||
MyPL.getEntryPtr("Convergence Tolerance")->isUsed() == false ||
MyPL.getEntryPtr("Use Locking")->isUsed() == false ||
MyPL.getEntryPtr("In Situ Restarting")->isUsed() == false ||
MyPL.getEntryPtr("Num Restart Blocks")->isUsed() == false ||
MyPL.getEntryPtr("Locking Tolerance")->isUsed() == false) {
if (verbose && MyPID==0) {
cout << "Failure! Unused parameters: " << endl;
MyPL.unused(cout);
}
}
// Solve the problem to the specified tolerances or length
Anasazi::ReturnType returnCode = MySolverMan.solve();
testFailed = false;
if (returnCode != Anasazi::Converged && shortrun==false) {
testFailed = true;
}
// Get the eigenvalues and eigenvectors from the eigenproblem
Anasazi::Eigensolution<ScalarType,MV> sol = problem->getSolution();
RCP<MV> evecs = sol.Evecs;
int numev = sol.numVecs;
if (numev > 0) {
std::ostringstream os;
os.setf(std::ios::scientific, std::ios::floatfield);
os.precision(6);
// Check the problem against the analytical solutions
if (verbose) {
double *revals = new double[numev];
for (int i=0; i<numev; i++) {
revals[i] = sol.Evals[i].realpart;
}
bool smallest = false;
if (which == "SM" || which == "SR") {
smallest = true;
}
testCase->eigenCheck( *evecs, revals, 0, smallest );
delete [] revals;
}
// Compute the direct residual
std::vector<ScalarType> normV( numev );
SerialDenseMatrix<int,ScalarType> T(numev,numev);
for (int i=0; i<numev; i++) {
T(i,i) = sol.Evals[i].realpart;
}
RCP<MV> Mvecs = MVT::Clone( *evecs, numev ),
Kvecs = MVT::Clone( *evecs, numev );
OPT::Apply( *K, *evecs, *Kvecs );
OPT::Apply( *M, *evecs, *Mvecs );
MVT::MvTimesMatAddMv( -ONE, *Mvecs, T, ONE, *Kvecs );
// compute M-norm of residuals
OPT::Apply( *M, *Kvecs, *Mvecs );
MVT::MvDot( *Mvecs, *Kvecs, normV );
os << "Number of iterations performed in BlockDavidson_test.exe: " << MySolverMan.getNumIters() << endl
<< "Direct residual norms computed in BlockDavidson_test.exe" << endl
<< std::setw(20) << "Eigenvalue" << std::setw(20) << "Residual(M)" << endl
<< "----------------------------------------" << endl;
for (int i=0; i<numev; i++) {
if ( SCT::magnitude(sol.Evals[i].realpart) != SCT::zero() ) {
normV[i] = SCT::magnitude( SCT::squareroot( normV[i] ) / sol.Evals[i].realpart );
}
else {
normV[i] = SCT::magnitude( SCT::squareroot( normV[i] ) );
}
os << std::setw(20) << sol.Evals[i].realpart << std::setw(20) << normV[i] << endl;
if ( normV[i] > tol ) {
testFailed = true;
}
}
if (verbose && MyPID==0) {
cout << endl << os.str() << endl;
}
}
#ifdef HAVE_MPI
MPI_Finalize() ;
#endif
if (testFailed) {
if (verbose && MyPID==0) {
cout << "End Result: TEST FAILED" << endl;
}
return -1;
}
//
// Default return value
//
if (verbose && MyPID==0) {
cout << "End Result: TEST PASSED" << endl;
}
return 0;
}
