void ParameterList::validateParameters(
ParameterList const& validParamList,
int const depth,
EValidateUsed const validateUsed,
EValidateDefaults const validateDefaults
) const
{
typedef std::deque<ListPlusValidList> sublist_list_t;
#ifdef TEUCHOS_PARAMETER_LIST_SHOW_TRACE
RCP<FancyOStream> out = VerboseObjectBase::getDefaultOStream();
OSTab tab(out);
*out << "\n*** Entering ParameterList::validateParameters(...) for "
"this->name()=\""<<this->name()<<"\"...\n";
#endif
//
// First loop through and validate the parameters at this level.
//
// Here we generate a list of sublists that we will search next
//
sublist_list_t sublist_list;
ConstIterator itr;
for (itr = this->begin(); itr != this->end(); ++itr) {
const std::string &entryName = this->name(itr);
const ParameterEntry &theEntry = this->entry(itr);
#ifdef TEUCHOS_PARAMETER_LIST_SHOW_TRACE
OSTab tab(out);
*out << "\nentryName=\""<<entryName<<"\"\n";
#endif
if(
( theEntry.isUsed() && validateUsed!=VALIDATE_USED_ENABLED )
||
( theEntry.isDefault() && validateDefaults!=VALIDATE_DEFAULTS_ENABLED )
)
{
continue;
}
const ParameterEntry *validEntry = validParamList.getEntryPtr(entryName);
TEUCHOS_TEST_FOR_EXCEPTION_PURE_MSG(
!validEntry, Exceptions::InvalidParameterName
,"Error, the parameter {name=\""<<entryName<<"\","
"type=\""<<theEntry.getAny(false).typeName()<<"\""
",value=\""<<filterValueToString(theEntry)<<"\"}"
"\nin the parameter (sub)list \""<<this->name()<<"\""
"\nwas not found in the list of valid parameters!"
"\n\nThe valid parameters and types are:\n"
<<validParamList.currentParametersString()
);
RCP<const ParameterEntryValidator> validator;
if (nonnull(validator=validEntry->validator())) {
validator->validate(theEntry, entryName, this->name());
}
else {
const bool validType =
( validEntry!=NULL
? theEntry.getAny(false).type() == validEntry->getAny(false).type()
: false
);
TEUCHOS_TEST_FOR_EXCEPTION_PURE_MSG(
!validType, Exceptions::InvalidParameterType
,"Error, the parameter {name=\""<<entryName<<"\","
"type=\""<<theEntry.getAny(false).typeName()<<"\""
",value=\""<<filterValueToString(theEntry)<<"\"}"
"\nin the parameter (sub)list \""<<this->name()<<"\""
"\nexists in the list of valid parameters but has the wrong type."
"\n\nThe correct type is \""
<< validEntry->getAny(false).typeName() << "\"."
);
}
if( theEntry.isList() && depth > 0 ) {
sublist_list.push_back(
ListPlusValidList(
&getValue<ParameterList>(theEntry),&getValue<ParameterList>(*validEntry)
)
);
}
}
//
// Now loop through the sublists and validate their parameters
//
for(
sublist_list_t::const_iterator sl_itr = sublist_list.begin();
sl_itr != sublist_list.end();
++sl_itr
)
{
if (!sl_itr->validList->disableRecursiveValidation_) {
sl_itr->list->validateParameters(
*sl_itr->validList
,depth-1
,validateUsed
,validateDefaults
);
}
}
#ifdef TEUCHOS_PARAMETER_LIST_SHOW_TRACE
*out << "\n*** Existing ParameterList::validateParameters(...) for "
"this->name()=\""<<this->name()<<"\"...\n";
#endif
}
void ParameterList::validateParametersAndSetDefaults(
ParameterList const& validParamList,
int const depth
)
{
typedef std::deque<ListPlusValidList> sublist_list_t;
#ifdef TEUCHOS_PARAMETER_LIST_SHOW_TRACE
RCP<FancyOStream> out = VerboseObjectBase::getDefaultOStream();
OSTab tab(out);
*out << "\n*** Entering ParameterList::validateParametersAndSetDefaults(...) "
"for this->name()=\""<<this->name()<<"\"...\n";
#endif
//
// A) loop through and validate the parameters at this level.
//
// Here we generate a list of sublists that we will search next
//
sublist_list_t sublist_list;
{
Iterator itr;
for (itr = this->nonconstBegin(); itr != this->nonconstEnd(); ++itr) {
const std::string &entryName = this->name(itr);
ParameterEntry &theEntry = this->nonconstEntry(itr);
#ifdef TEUCHOS_PARAMETER_LIST_SHOW_TRACE
OSTab tab(out);
*out << "\nentryName=\""<<entryName<<"\"\n";
#endif
const ParameterEntry *validEntry = validParamList.getEntryPtr(entryName);
TEUCHOS_TEST_FOR_EXCEPTION_PURE_MSG(
!validEntry, Exceptions::InvalidParameterName
,"Error, the parameter {name=\""<<entryName<<"\","
"type=\""<<theEntry.getAny(false).typeName()<<"\""
",value=\""<<filterValueToString(theEntry)<<"\"}"
"\nin the parameter (sub)list \""<<this->name()<<"\""
"\nwas not found in the list of valid parameters!"
"\n\nThe valid parameters and types are:\n"
<<validParamList.currentParametersString()
);
RCP<const ParameterEntryValidator> validator;
if (nonnull(validator=validEntry->validator())) {
validator->validateAndModify(entryName, this->name(), &theEntry);
theEntry.setValidator(validator);
}
else {
const bool validType =
( validEntry!=NULL
? theEntry.getAny(false).type() == validEntry->getAny(false).type()
: false
);
TEUCHOS_TEST_FOR_EXCEPTION_PURE_MSG(
!validType, Exceptions::InvalidParameterType
,"Error, the parameter {name=\""<<entryName<<"\","
"type=\""<<theEntry.getAny(false).typeName()<<"\""
",value=\""<<filterValueToString(theEntry)<<"\"}"
"\nin the parameter (sub)list \""<<this->name()<<"\""
"\nexists in the list of valid parameters but has the wrong type."
"\n\nThe correct type is \""
<< validEntry->getAny(false).typeName() << "\"."
);
// Note: If there is no validator for this item, then we can not
// validate the value of the parameter, only its type!
}
if( theEntry.isList() && depth > 0 ) {
sublist_list.push_back(
ListPlusValidList(
&getValue<ParameterList>(theEntry),
&getValue<ParameterList>(*validEntry)
)
);
}
}
}
//
// B) Loop through the valid parameters at this level that are not set in
// *this, and set their defaults.
//
{
ConstIterator itr;
for (itr = validParamList.begin(); itr != validParamList.end(); ++itr) {
const std::string &validEntryName = validParamList.name(itr);
const ParameterEntry &validEntry = validParamList.entry(itr);
const ParameterEntry *theEntry = this->getEntryPtr(validEntryName);
if (!theEntry) {
// This entry does not exist, so add it. Here we will only set the
// value of the entry and its validator and and leave off the
// documentation. The reason that the validator is set is so that it
// can be used to extract and validate entries in the transformed list
// *this without having to refer back to the valid parameter list.
ParameterEntry newEntry;
newEntry.setAnyValue(
validEntry.getAny(),
true // isDefault
);
newEntry.setValidator(validEntry.validator());
this->setEntry(validEntryName,newEntry);
}
}
}
//
// C) Loop through the sublists and validate their parameters and set their
// defaults!
//
for (
sublist_list_t::iterator sl_itr = sublist_list.begin();
sl_itr != sublist_list.end();
++sl_itr
)
{
if (!sl_itr->validList->disableRecursiveValidation_) {
sl_itr->list->validateParametersAndSetDefaults(*sl_itr->validList,depth-1);
}
}
#ifdef TEUCHOS_PARAMETER_LIST_SHOW_TRACE
*out << "\n*** Existing ParameterList::validateParametersAndSetDefaults(...) "
"for this->name()=\""<<this->name()<<"\"...\n";
#endif
}
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[])
{
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[])
{
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[])
{
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[])
{
#ifdef HAVE_MPI
// Initialize MPI
MPI_Init(&argc,&argv);
Epetra_MpiComm Comm(MPI_COMM_WORLD);
#else
Epetra_SerialComm Comm;
#endif
bool testFailed;
bool verbose = false;
CommandLineProcessor cmdp(false,true);
cmdp.setOption("verbose","quiet",&verbose,"Print messages and results.");
cmdp.setOption("debug","quiet",&verbose,"Print messages and results.");
if (cmdp.parse(argc,argv) != CommandLineProcessor::PARSE_SUCCESSFUL) {
#ifdef HAVE_MPI
MPI_Finalize();
#endif
return -1;
}
// create the output manager
RCP< OutputManager<ScalarType> > printer = rcp( new BasicOutputManager<ScalarType>() );
if (verbose) printer->stream(Errors) << Anasazi_Version() << endl << endl;
const int veclength = 99;
// 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] = veclength+1;
// 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
const int nev = 4;
RCP<Epetra_MultiVector> ivec = rcp( new Epetra_MultiVector(K->OperatorDomainMap(), nev) );
ivec->Random();
//
// Create eigenproblem: one standard and one generalized
RCP<BasicEigenproblem<ScalarType,MV,OP> > probstd = rcp( new BasicEigenproblem<ScalarType, MV, OP>(K, ivec) );
RCP<BasicEigenproblem<ScalarType,MV,OP> > probgen = rcp( new BasicEigenproblem<ScalarType, MV, OP>(K, M, ivec) );
//
// Inform the eigenproblem that the operator A is symmetric
probstd->setHermitian(true);
probgen->setHermitian(true);
//
// Set the number of eigenvalues requested
probstd->setNEV( nev );
probgen->setNEV( nev );
//
// Inform the eigenproblem that you are finishing passing it information
if ( probstd->setProblem() != true || probgen->setProblem() != true ) {
if (verbose) {
printer->stream(Errors) << "Anasazi::BasicEigenproblem::SetProblem() returned with error." << endl
<< "End Result: TEST FAILED" << endl;
}
#ifdef HAVE_MPI
MPI_Finalize() ;
#endif
return -1;
}
// create the orthogonalization managers: one standard and one M-based
RCP< MatOrthoManager<ScalarType,MV,OP> > orthostd = rcp( new SVQBOrthoManager<ScalarType,MV,OP>() );
RCP< MatOrthoManager<ScalarType,MV,OP> > orthogen = rcp( new SVQBOrthoManager<ScalarType,MV,OP>(M) );
// create the sort manager
RCP< SortManager<MagnitudeType> > sorter = rcp( new BasicSort<MagnitudeType>("LM") );
// create the parameter list specifying blocksize > nev and full orthogonalization
ParameterList pls;
// begin testing
testFailed = false;
try
{
if (verbose) printer->stream(Errors) << "Testing solver(default,default) with standard eigenproblem..." << endl;
testsolver(probstd,printer,orthostd,sorter,pls);
if (verbose) printer->stream(Errors) << "Testing solver(default,default) with generalized eigenproblem..." << endl;
testsolver(probgen,printer,orthogen,sorter,pls);
pls.set<int>("Block Size",nev);
pls.set<bool>("Full Ortho",false);
if (verbose) printer->stream(Errors) << "Testing solver(nev,false) with standard eigenproblem..." << endl;
testsolver(probstd,printer,orthostd,sorter,pls);
TEST_FOR_EXCEPTION(pls.getEntryPtr("Block Size")->isUsed() == false, get_out, "Solver did not consume parameter \"Block Size\".");
TEST_FOR_EXCEPTION(pls.getEntryPtr("Full Ortho")->isUsed() == false, get_out, "Solver did not consume parameter \"Full Ortho\".");
pls.set<bool>("Full Ortho",true);
if (verbose) printer->stream(Errors) << "Testing solver(nev,true) with standard eigenproblem..." << endl;
testsolver(probstd,printer,orthostd,sorter,pls);
pls.set<bool>("Full Ortho",false);
if (verbose) printer->stream(Errors) << "Testing solver(nev,false) with generalized eigenproblem..." << endl;
testsolver(probgen,printer,orthogen,sorter,pls);
pls.set<bool>("Full Ortho",true);
if (verbose) printer->stream(Errors) << "Testing solver(nev,true) with generalized eigenproblem..." << endl;
testsolver(probgen,printer,orthogen,sorter,pls);
pls.set<int>("Block Size",2*nev);
pls.set<bool>("Full Ortho",false);
if (verbose) printer->stream(Errors) << "Testing solver(2*nev,false) with standard eigenproblem..." << endl;
testsolver(probstd,printer,orthostd,sorter,pls);
pls.set<bool>("Full Ortho",true);
if (verbose) printer->stream(Errors) << "Testing solver(2*nev,true) with standard eigenproblem..." << endl;
testsolver(probstd,printer,orthostd,sorter,pls);
pls.set<bool>("Full Ortho",false);
if (verbose) printer->stream(Errors) << "Testing solver(2*nev,false) with generalized eigenproblem..." << endl;
testsolver(probgen,printer,orthogen,sorter,pls);
pls.set<bool>("Full Ortho",true);
if (verbose) printer->stream(Errors) << "Testing solver(2*nev,true) with generalized eigenproblem..." << endl;
testsolver(probgen,printer,orthogen,sorter,pls);
pls.set<int>("Block Size",nev/2);
pls.set<bool>("Full Ortho",false);
if (verbose) printer->stream(Errors) << "Testing solver(nev/2,false) with standard eigenproblem..." << endl;
testsolver(probstd,printer,orthostd,sorter,pls);
pls.set<bool>("Full Ortho",true);
if (verbose) printer->stream(Errors) << "Testing solver(nev/2,true) with standard eigenproblem..." << endl;
testsolver(probstd,printer,orthostd,sorter,pls);
pls.set<bool>("Full Ortho",false);
if (verbose) printer->stream(Errors) << "Testing solver(nev/2,false) with generalized eigenproblem..." << endl;
testsolver(probgen,printer,orthogen,sorter,pls);
pls.set<bool>("Full Ortho",true);
if (verbose) printer->stream(Errors) << "Testing solver(nev/2,true) with generalized eigenproblem..." << endl;
testsolver(probgen,printer,orthogen,sorter,pls);
// try with an invalid block size
pls.set<int>("Block Size",0);
if (verbose) printer->stream(Errors) << "Testing solver(0) with standard eigenproblem..." << endl;
testsolver(probstd,printer,orthostd,sorter,pls,true);
// try with a too-large block size
pls.set<int>("Num Blocks",veclength+1);
if (verbose) printer->stream(Errors) << "Testing solver(toomany) with standard eigenproblem..." << endl;
testsolver(probstd,printer,orthostd,sorter,pls,true);
// try with an unset problem
// setHermitian will mark the problem as unset
probstd->setHermitian(false);
if (verbose) printer->stream(Errors) << "Testing solver with unset eigenproblem..." << endl;
testsolver(probstd,printer,orthostd,sorter,pls,true);
// set the problem, and try with a non-Hermitian problem
if ( probstd->setProblem() != true ) {
if (verbose) {
printer->stream(Errors) << "Anasazi::BasicEigenproblem::SetProblem() returned with error." << endl
<< "End Result: TEST FAILED" << endl;
}
#ifdef HAVE_MPI
MPI_Finalize() ;
#endif
return -1;
}
if (verbose) printer->stream(Errors) << "Testing solver with non-Hermitian eigenproblem..." << endl;
testsolver(probstd,printer,orthostd,sorter,pls,true);
// fix it now
probstd->setHermitian(true);
probstd->setProblem();
// create a dummy status tester
RCP< StatusTest<ScalarType,MV,OP> > dumtester = rcp( new StatusTestMaxIters<ScalarType,MV,OP>(1) );
// try with a null problem
if (verbose) printer->stream(Errors) << "Testing solver with null eigenproblem..." << endl;
try {
RCP< LOBPCG<ScalarType,MV,OP> > solver
= rcp( new LOBPCG<ScalarType,MV,OP>(Teuchos::null,sorter,printer,dumtester,orthostd,pls) );
TEST_FOR_EXCEPTION(true,get_out,"Initializing with invalid parameters failed to throw exception.");
}
catch (const std::invalid_argument &ia) {
// caught expected exception
}
// try with a null sortman
if (verbose) printer->stream(Errors) << "Testing solver with null sort manager..." << endl;
try {
RCP< LOBPCG<ScalarType,MV,OP> > solver
= rcp( new LOBPCG<ScalarType,MV,OP>(probstd,Teuchos::null,printer,dumtester,orthostd,pls) );
TEST_FOR_EXCEPTION(true,get_out,"Initializing with invalid parameters failed to throw exception.");
}
catch (const std::invalid_argument &ia) {
// caught expected exception
}
// try with a output man problem
if (verbose) printer->stream(Errors) << "Testing solver with null output manager..." << endl;
try {
RCP< LOBPCG<ScalarType,MV,OP> > solver
= rcp( new LOBPCG<ScalarType,MV,OP>(probstd,sorter,Teuchos::null,dumtester,orthostd,pls) );
TEST_FOR_EXCEPTION(true,get_out,"Initializing with invalid parameters failed to throw exception.");
}
catch (const std::invalid_argument &ia) {
// caught expected exception
}
// try with a null status test
if (verbose) printer->stream(Errors) << "Testing solver with null status test..." << endl;
try {
RCP< LOBPCG<ScalarType,MV,OP> > solver
= rcp( new LOBPCG<ScalarType,MV,OP>(probstd,sorter,printer,Teuchos::null,orthostd,pls) );
TEST_FOR_EXCEPTION(true,get_out,"Initializing with invalid parameters failed to throw exception.");
}
catch (const std::invalid_argument &ia) {
// caught expected exception
}
// try with a null orthoman
if (verbose) printer->stream(Errors) << "Testing solver with null ortho manager..." << endl;
try {
RCP< LOBPCG<ScalarType,MV,OP> > solver
= rcp( new LOBPCG<ScalarType,MV,OP>(probstd,sorter,printer,dumtester,Teuchos::null,pls) );
TEST_FOR_EXCEPTION(true,get_out,"Initializing with invalid parameters failed to throw exception.");
}
catch (const std::invalid_argument &ia) {
// caught expected exception
}
}
catch (const get_out &go) {
printer->stream(Errors) << "Test failed: " << go.what() << endl;
testFailed = true;
}
catch (const std::exception &e) {
printer->stream(Errors) << "Caught unexpected exception: " << e.what() << endl;
testFailed = true;
}
#ifdef HAVE_MPI
MPI_Finalize() ;
#endif
if (testFailed) {
if (verbose) {
printer->stream(Errors) << endl << "End Result: TEST FAILED" << endl;
}
return -1;
}
//
// Default return value
//
if (verbose) {
printer->stream(Errors) << endl << "End Result: TEST PASSED" << endl;
}
return 0;
}
void Problem<Adapter>::setupProblemEnvironment(ParameterList *params)
{
try{
env_ = rcp(new Environment(*params, Teuchos::DefaultComm<int>::getComm()));
}
Z2_FORWARD_EXCEPTIONS
envConst_ = rcp_const_cast<const Environment>(env_);
ParameterList &processedParameters = env_->getParametersNonConst();
params_ = rcp<ParameterList>(&processedParameters, false);
#ifndef Z2_OMIT_ALL_PROFILING
ParameterList pl = *params_;
// Give a timer to the Environment if requested.
bool haveType=false, haveStream=false, haveFile=false;
int choice = MACRO_TIMERS; // default timer type
const Teuchos::ParameterEntry *pe = pl.getEntryPtr("timer_type");
if (pe){
choice = pe->getValue<int>(&choice);
haveType = true;
}
TimerType tt = static_cast<TimerType>(choice);
std::string fname;
pe = pl.getEntryPtr("timer_output_file");
if (pe){
haveFile = true;
fname = pe->getValue<std::string>(&fname);
std::ofstream *dbgFile = new std::ofstream;
if (comm_->getRank()==0){
// Using Teuchos::TimeMonitor, node 0 prints global timing info.
try{
dbgFile->open(fname.c_str(), std::ios::out|std::ios::trunc);
}
catch(std::exception &e){
throw std::runtime_error(e.what());
}
}
timer_ = rcp(new TimerManager(comm_, dbgFile, tt));
}
else{
choice = COUT_STREAM; // default output stream
pe = pl.getEntryPtr("timer_output_stream");
if (pe){
choice = pe->getValue<int>(&choice);
haveStream = true;
}
OSType outputStream = static_cast<OSType>(choice);
if (haveStream || haveType){
if (outputStream == COUT_STREAM)
timer_ = rcp(new TimerManager(comm_, &std::cout, tt));
else if (outputStream == CERR_STREAM)
timer_ = rcp(new TimerManager(comm_, &std::cerr, tt));
else if (outputStream == NULL_STREAM){
std::ofstream *of = NULL;
timer_ = rcp(new TimerManager(comm_, of, tt));
}
}
}
if (haveType || haveStream || haveFile)
env_->setTimer(timer_);
#endif
}
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;
}
