/// \brief Parse command-line options for this test
///
/// \param argc [in] As usual in C(++)
/// \param argv [in] As usual in C(++)
/// \param allowedToPrint [in] Whether this (MPI) process is allowed
/// to print to stdout/stderr. Different per (MPI) process.
/// \param printedHelp [out] Whether this (MPI) process printed the
/// "help" display (summary of command-line options)
///
/// \return Encapsulation of command-line options
static CombineTestParameters
parseOptions (int argc,
char* argv[],
const bool allowedToPrint,
bool& printedHelp)
{
using std::cerr;
using std::endl;
printedHelp = false;
// Command-line parameters, set to their default values.
CombineTestParameters params;
try {
using Teuchos::CommandLineProcessor;
CommandLineProcessor cmdLineProc (/* throwExceptions=*/ true,
/* recognizeAllOptions=*/ true);
cmdLineProc.setDocString (docString);
cmdLineProc.setOption ("verify",
"noverify",
¶ms.verify,
"Test accuracy");
cmdLineProc.setOption ("benchmark",
"nobenchmark",
¶ms.benchmark,
"Test performance");
cmdLineProc.setOption ("debug",
"nodebug",
¶ms.debug,
"Print debugging information");
cmdLineProc.setOption ("nrows",
¶ms.numRows,
"Number of rows in the test matrix");
cmdLineProc.setOption ("ncols",
¶ms.numCols,
"Number of columns in the test matrix");
cmdLineProc.setOption ("ntrials",
¶ms.numTrials,
"Number of trials (only used when \"--benchmark\"");
#ifdef HAVE_TSQR_COMPLEX
cmdLineProc.setOption ("complex",
"nocomplex",
¶ms.testComplex,
"Test complex arithmetic, as well as real");
#endif // HAVE_TSQR_COMPLEX
cmdLineProc.parse (argc, argv);
}
catch (Teuchos::CommandLineProcessor::UnrecognizedOption& e) {
if (allowedToPrint)
cerr << "Unrecognized command-line option: " << e.what() << endl;
throw e;
}
catch (Teuchos::CommandLineProcessor::HelpPrinted& e) {
printedHelp = true;
return params; // Don't verify parameters in this case
}
// Validate. TODO (mfh 08 Jul 2010) Figure out how to do this with
// ParameterList validators.
if (params.numRows <= 0)
throw std::invalid_argument ("Number of rows must be positive");
else if (params.numCols <= 0)
throw std::invalid_argument ("Number of columns must be positive");
else if (params.numRows < params.numCols)
throw std::invalid_argument ("Number of rows must be >= number of columns");
else if (params.benchmark && params.numTrials < 1)
throw std::invalid_argument ("Benchmark requires numTrials >= 1");
return params;
}
int main(int argc, char *argv[])
{
Teuchos::GlobalMPISession mpiSession(&argc, &argv);
int status = 0;
// Parse the command line
using Teuchos::CommandLineProcessor;
CommandLineProcessor clp;
clp.throwExceptions(false);
clp.addOutputSetupOptions(true);
bool verbose = false;
clp.setOption( "v", "disable-verbosity", &verbose, "Enable verbosity" );
CommandLineProcessor::EParseCommandLineReturn
parse_return = clp.parse(argc,argv,&std::cerr);
if( parse_return != CommandLineProcessor::PARSE_SUCCESSFUL )
return parse_return;
if (verbose)
std::cout << "Verbosity Activated" << std::endl;
else
std::cout << "Verbosity Disabled" << std::endl;
// Create a communicator for Epetra objects
#ifdef HAVE_MPI
Epetra_MpiComm Comm( MPI_COMM_WORLD );
#else
Epetra_SerialComm Comm;
#endif
// Check we have only one processor since this problem doesn't work
// for more than one proc
if (Comm.NumProc() > 1) {
std::cerr << "Error! Problem can only be run with at most 1 processor!"
<< std::endl;
return -1;
}
// Create the model evaluator object
double d = 10.0;
double p0 = 2.0;
double p1 = 0.0;
double x00 = 0.0;
double x01 = 1.0;
Teuchos::RCP<ModelEvaluator2DSim<double> > thyraModel =
Teuchos::rcp(new ModelEvaluator2DSim<double>(Teuchos::rcp(&Comm,false),
d,p0,p1,x00,x01));
// Create the linear solver type with Stratimikos
//Teuchos::RCP<Thyra::LinearOpWithSolveFactoryBase<double> >
//lowsFactory = rcp(new Thyra::AmesosLinearOpWithSolveFactory());
::Stratimikos::DefaultLinearSolverBuilder builder;
Teuchos::RCP<Teuchos::ParameterList> p =
Teuchos::rcp(new Teuchos::ParameterList);
p->set("Linear Solver Type", "AztecOO");
p->set("Preconditioner Type", "Ifpack");
//p->set("Enable Delayed Solver Construction", true);
builder.setParameterList(p);
Teuchos::RCP< ::Thyra::LinearOpWithSolveFactoryBase<double> >
lowsFactory = builder.createLinearSolveStrategy("");
thyraModel->set_W_factory(lowsFactory);
// Create the initial guess
Teuchos::RCP< ::Thyra::VectorBase<double> >
initial_guess = thyraModel->getNominalValues().get_x()->clone_v();
// Create the NOX::Thyra::Group
Teuchos::RCP<NOX::Thyra::Group> nox_group =
Teuchos::rcp(new NOX::Thyra::Group(*initial_guess, thyraModel));
// nox_group->computeF();
// std::cout << "ComputedF!" << std::endl;
// const NOX::Thyra::Vector& t_vec =
// dynamic_cast<const NOX::Thyra::Vector&>(nox_group->getF());
// t_vec.print(std::cout);
// exit(0);
// Create the NOX status tests and the solver
// Create the convergence tests
Teuchos::RCP<NOX::StatusTest::NormF> absresid =
Teuchos::rcp(new NOX::StatusTest::NormF(1.0e-8));
Teuchos::RCP<NOX::StatusTest::NormWRMS> wrms =
Teuchos::rcp(new NOX::StatusTest::NormWRMS(1.0e-2, 1.0e-8));
Teuchos::RCP<NOX::StatusTest::Combo> converged =
Teuchos::rcp(new NOX::StatusTest::Combo(NOX::StatusTest::Combo::AND));
converged->addStatusTest(absresid);
converged->addStatusTest(wrms);
Teuchos::RCP<NOX::StatusTest::MaxIters> maxiters =
Teuchos::rcp(new NOX::StatusTest::MaxIters(20));
Teuchos::RCP<NOX::StatusTest::FiniteValue> fv =
Teuchos::rcp(new NOX::StatusTest::FiniteValue);
Teuchos::RCP<NOX::StatusTest::Combo> combo =
Teuchos::rcp(new NOX::StatusTest::Combo(NOX::StatusTest::Combo::OR));
combo->addStatusTest(fv);
combo->addStatusTest(converged);
combo->addStatusTest(maxiters);
// Create nox parameter list
Teuchos::RCP<Teuchos::ParameterList> nl_params =
Teuchos::rcp(new Teuchos::ParameterList);
nl_params->set("Nonlinear Solver", "Line Search Based");
// Create the solver
Teuchos::RCP<NOX::Solver::Generic> solver =
NOX::Solver::buildSolver(nox_group, combo, nl_params);
NOX::StatusTest::StatusType solvStatus = solver->solve();
if (solvStatus == NOX::StatusTest::Converged)
std::cout << "Test passed!" << std::endl;
// Final return value (0 = successfull, non-zero = failure)
return status;
}
int main(int argc, char* argv[])
{
Teuchos::GlobalMPISession mpiSession(&argc, &argv);
using Teuchos::CommandLineProcessor;
using Teuchos::OSTab;
bool result, success = true;
bool verbose = true;
Teuchos::RCP<Teuchos::FancyOStream>
out = Teuchos::VerboseObjectBase::getDefaultOStream();
try {
//
// Read options from command-line
//
std::string matrixDir = ".";
bool testTranspose = true;
int numRandomVectors = 1;
bool showAllTests = false;
bool showAllTestsDetails = false;
bool dumpAll = false;
CommandLineProcessor clp;
clp.throwExceptions(false);
clp.addOutputSetupOptions(true);
clp.setOption( "matrix-dir", &matrixDir, "Base directory for the test matrices" );
clp.setOption( "test-transpose", "no-test-transpose", &testTranspose, "Test the transpose solve or not." );
clp.setOption( "num-random-vectors", &numRandomVectors, "Number of times a test is performed with different random vectors." );
clp.setOption( "verbose", "quiet", &verbose, "Set if output is printed or not." );
clp.setOption( "show-all-tests", "no-show-all-tests", &showAllTests, "Set if all the tests are shown or not." );
clp.setOption( "show-all-tests-details", "no-show-all-tests-details", &showAllTestsDetails, "Set if all the details of the tests are shown or not." );
clp.setOption( "dump-all", "no-dump-all", &dumpAll, "Determines if vectors are printed or not." );
CommandLineProcessor::EParseCommandLineReturn parse_return = clp.parse(argc,argv);
if( parse_return != CommandLineProcessor::PARSE_SUCCESSFUL ) return parse_return;
TEUCHOS_TEST_FOR_EXCEPT( matrixDir == "" );
//
// Define the test matrices
//
const int numTestMatrices = 9;
typedef MatrixTestPacket MTP;
// Set up the matices and the tolerances.
// Note, we may need to adjust these for bad platforms ...
const MTP testMatrices[numTestMatrices] =
{
MTP("bcsstk01.mtx",false,1e-12,1e-12,1e-12)
,MTP("bcsstk02.mtx",false,1e-12,1e-12,1e-12)
,MTP("bcsstk04.mtx",false,1e-12,1e-10,1e-12)
,MTP("Diagonal.mtx",false,1e-12,1e-12,1e-12)
,MTP("FourByFour.mtx",true,1e-12,1e-12,1e-12)
,MTP("KheadK.mtx",false,1e-12,1e-12,1e-12)
,MTP("KheadSorted.mtx",false,1e-12,1e-12,1e-12)
,MTP("nos1.mtx",false,1e-11,1e-10,1e-12)
,MTP("nos5.mtx",false,1e-12,1e-12,1e-12)
};
//
// Loop through all of the test matrices
//
for( int matrix_i = 0; matrix_i < numTestMatrices; ++matrix_i ) {
const MatrixTestPacket
mtp = testMatrices[matrix_i];
//
// Loop through all of the solvers
//
for( int solver_i = 0; solver_i < Thyra::Amesos::numSolverTypes; ++solver_i ) {
const Thyra::Amesos::ESolverType
solverType = Thyra::Amesos::solverTypeValues[solver_i];
// bug 1902 - Amesos_Superlu fails on bcsstk01.mtx
// bug 1903 - Amesos_Superlu fails on four matrices,
// when called from the thyra test
//
bool BadMatrixForSuperlu =
mtp.matrixFile == "bcsstk01.mtx" // bug 1902
|| mtp.matrixFile == "bcsstk04.mtx" // bug 1903
|| mtp.matrixFile == "KheadK.mtx" // bug 1903
|| mtp.matrixFile == "KheadSorted.mtx" // bug 1903
|| mtp.matrixFile == "nos1.mtx" ; // bug 1903
//
// Toggle the refactorization options
//
for( int factorizationPolicy_i = 0; factorizationPolicy_i < Thyra::Amesos::numRefactorizationPolices; ++factorizationPolicy_i ) {
const Thyra::Amesos::ERefactorizationPolicy
refactorizationPolicy = Thyra::Amesos::refactorizationPolicyValues[factorizationPolicy_i];
if(verbose)
*out
<< std::endl<<matrix_i<<"."<<solver_i<<"."<<factorizationPolicy_i<<": "
<< "Testing, matrixFile=\'"<<mtp.matrixFile<<"\', solverType=\'"<<toString(solverType)<<"\', refactorizationPolicy=\'"<<toString(refactorizationPolicy)<<"\' ...";
if( mtp.unsymmetric && !Thyra::Amesos::supportsUnsymmetric[solver_i] ) {
*out << " : Skipping since unsymmetric and not supported!\n";
}
else {
// bug 1902 and bug 1903
string StrSolverType = toString(solverType) ;
string StrSuperlu = "Superlu";
if ( StrSolverType==StrSuperlu && BadMatrixForSuperlu ) {
*out << " : Skipping since Superlu fails on this matrix!\n";
}
else {
std::ostringstream ossStore;
Teuchos::RCP<Teuchos::FancyOStream>
oss = Teuchos::rcp(new Teuchos::FancyOStream(Teuchos::rcp(&ossStore,false)));
Teuchos::ParameterList amesosLOWSFPL;
amesosLOWSFPL.set("Solver Type",toString(solverType));
amesosLOWSFPL.set("Refactorization Policy",toString(refactorizationPolicy));
result =
Thyra::test_single_amesos_thyra_solver(
matrixDir+"/"+mtp.matrixFile,&amesosLOWSFPL,testTranspose,numRandomVectors
,mtp.maxFwdError,mtp.maxError,mtp.maxResid,showAllTestsDetails,dumpAll,OSTab(oss).get()
);
if(!result) success = false;
if(verbose) {
if(result) {
if(showAllTests)
*out << std::endl << ossStore.str();
else
*out << " : passed!\n";
}
else {
if(showAllTests)
*out << std::endl << ossStore.str();
else
*out << " : failed!\n";
}
}
}
}
}
}
}
}
catch( const std::exception &excpt ) {
std::cerr << "*** Caught standard exception : " << excpt.what() << std::endl;
success = false;
}
catch( ... ) {
std::cerr << "*** Caught an unknown exception\n";
success = false;
}
if (verbose) {
if(success) *out << "\nCongratulations! All of the tests checked out!\n";
else *out << "\nOh no! At least one of the tests failed!\n";
}
return ( success ? 0 : 1 );
}
/// \brief Parse command-line options for this test
///
/// \param argc [in] As usual in C(++)
/// \param argv [in] As usual in C(++)
/// \param allowedToPrint [in] Whether this (MPI) process is allowed
/// to print to stdout/stderr. Different per (MPI) process.
/// \param printedHelp [out] Whether this (MPI) process printed the
/// "help" display (summary of command-line options)
///
/// \return Encapsulation of command-line options
static LapackTestParameters
parseOptions (int argc,
char* argv[],
const bool allowedToPrint,
bool& printedHelp)
{
using std::cerr;
using std::endl;
printedHelp = false;
// Command-line parameters, set to their default values.
LapackTestParameters params;
try {
using Teuchos::CommandLineProcessor;
CommandLineProcessor cmdLineProc (/* throwExceptions=*/ true,
/* recognizeAllOptions=*/ true);
cmdLineProc.setDocString (docString);
cmdLineProc.setOption ("verify",
"noverify",
¶ms.verify,
"Test accuracy");
cmdLineProc.setOption ("benchmark",
"nobenchmark",
¶ms.benchmark,
"Test performance");
cmdLineProc.setOption ("nrows",
¶ms.numRows,
"Number of rows in the test matrix");
cmdLineProc.setOption ("ncols",
¶ms.numCols,
"Number of columns in the test matrix");
cmdLineProc.setOption ("ntrials",
¶ms.numTrials,
"Number of trials (only used when \"--benchmark\"");
#ifdef HAVE_KOKKOSCLASSIC_TSQR_COMPLEX
cmdLineProc.setOption ("complex",
"nocomplex",
¶ms.testComplex,
"Test complex arithmetic, as well as real");
#endif // HAVE_KOKKOSCLASSIC_TSQR_COMPLEX
cmdLineProc.setOption ("field-names",
¶ms.additionalFieldNames,
"Any additional field name(s) (comma-delimited "
"string) to add to the benchmark output. Empty "
"by default. Good for things known when invoking "
"the benchmark executable, but not (easily) known "
"inside the benchmark -- e.g., environment "
"variables.");
cmdLineProc.setOption ("output-data",
¶ms.additionalData,
"Any additional data to add to the output, "
"corresponding to the above field name(s). "
"Empty by default.");
cmdLineProc.setOption ("print-field-names",
"no-print-field-names",
¶ms.printFieldNames,
"Print field names for benchmark output (including "
"any arguments to --field-names).");
cmdLineProc.setOption ("print-trilinos-test-stuff",
"no-print-trilinos-test-stuff",
¶ms.printTrilinosTestStuff,
"Print output that makes the Trilinos test "
"framework happy (but makes benchmark results "
"parsing scripts unhappy)");
cmdLineProc.setOption ("human-readable",
"machine-readable",
¶ms.humanReadable,
"If set, make output easy to read by humans "
"(but hard to parse)");
cmdLineProc.setOption ("debug",
"nodebug",
¶ms.debug,
"Print debugging information");
cmdLineProc.parse (argc, argv);
}
catch (Teuchos::CommandLineProcessor::UnrecognizedOption& e) {
if (allowedToPrint)
cerr << "Unrecognized command-line option: " << e.what() << endl;
throw e;
}
catch (Teuchos::CommandLineProcessor::HelpPrinted& e) {
printedHelp = true;
return params; // Don't verify parameters in this case
}
// Validate command-line options. We provide default values
// for unset options, so we don't have to validate those.
if (params.numRows <= 0)
throw std::invalid_argument ("Number of rows must be positive");
else if (params.numCols <= 0)
throw std::invalid_argument ("Number of columns must be positive");
else if (params.numRows < params.numCols)
throw std::invalid_argument ("Number of rows must be >= number of columns");
else if (params.benchmark && params.numTrials < 1)
throw std::invalid_argument ("\"--benchmark\" option requires numTrials >= 1");
return params;
}
int main(int argc, char *argv[])
{
using std::endl;
typedef double Scalar;
// typedef double ScalarMag; // unused
typedef Teuchos::ScalarTraits<Scalar> ST;
using Teuchos::describe;
using Teuchos::Array;
using Teuchos::RCP;
using Teuchos::rcp;
using Teuchos::outArg;
using Teuchos::rcp_implicit_cast;
using Teuchos::rcp_dynamic_cast;
using Teuchos::as;
using Teuchos::ParameterList;
using Teuchos::CommandLineProcessor;
typedef Teuchos::ParameterList::PrintOptions PLPrintOptions;
typedef Thyra::ModelEvaluatorBase MEB;
bool result, success = true;
Teuchos::GlobalMPISession mpiSession(&argc,&argv);
RCP<Epetra_Comm> epetra_comm;
#ifdef HAVE_MPI
epetra_comm = rcp( new Epetra_MpiComm(MPI_COMM_WORLD) );
#else
epetra_comm = rcp( new Epetra_SerialComm );
#endif // HAVE_MPI
RCP<Teuchos::FancyOStream>
out = Teuchos::VerboseObjectBase::getDefaultOStream();
try {
//
// Read commandline options
//
CommandLineProcessor clp;
clp.throwExceptions(false);
clp.addOutputSetupOptions(true);
std::string paramsFileName = "";
clp.setOption( "params-file", ¶msFileName,
"File name for XML parameters" );
double t_final = 1e-3;
clp.setOption( "final-time", &t_final,
"Final integration time (initial time is 0.0)" );
int numTimeSteps = 10;
clp.setOption( "num-time-steps", &numTimeSteps,
"Number of (fixed) time steps. If <= 0.0, then variable time steps are taken" );
double maxStateError = 1e-14;
clp.setOption( "max-state-error", &maxStateError,
"Maximum relative error in the integrated state allowed" );
Teuchos::EVerbosityLevel verbLevel = Teuchos::VERB_DEFAULT;
setVerbosityLevelOption( "verb-level", &verbLevel,
"Top-level verbosity level. By default, this gets deincremented as you go deeper into numerical objects.",
&clp );
Teuchos::EVerbosityLevel solnVerbLevel = Teuchos::VERB_DEFAULT;
setVerbosityLevelOption( "soln-verb-level", &solnVerbLevel,
"Solution verbosity level",
&clp );
CommandLineProcessor::EParseCommandLineReturn parse_return = clp.parse(argc,argv);
if( parse_return != CommandLineProcessor::PARSE_SUCCESSFUL ) return parse_return;
//
*out << "\nA) Get the base parameter list ...\n";
//
RCP<ParameterList>
paramList = Teuchos::parameterList();
if (paramsFileName.length())
updateParametersFromXmlFile( paramsFileName, paramList.ptr() );
paramList->validateParameters(*getValidParameters());
const Scalar t_init = 0.0;
const Rythmos::TimeRange<Scalar> fwdTimeRange(t_init, t_final);
const Scalar delta_t = t_final / numTimeSteps;
*out << "\ndelta_t = " << delta_t;
//
*out << "\nB) Create the Stratimikos linear solver factory ...\n";
//
// This is the linear solve strategy that will be used to solve for the
// linear system with the W.
//
Stratimikos::DefaultLinearSolverBuilder linearSolverBuilder;
linearSolverBuilder.setParameterList(sublist(paramList,Stratimikos_name));
RCP<Thyra::LinearOpWithSolveFactoryBase<Scalar> >
W_factory = createLinearSolveStrategy(linearSolverBuilder);
//
*out << "\nC) Create and initalize the forward model ...\n";
//
// C.1) Create the underlying EpetraExt::ModelEvaluator
RCP<EpetraExt::DiagonalTransientModel> epetraStateModel =
EpetraExt::diagonalTransientModel(
epetra_comm,
sublist(paramList,DiagonalTransientModel_name)
);
*out <<"\nepetraStateModel valid options:\n";
epetraStateModel->getValidParameters()->print(
*out, PLPrintOptions().indent(2).showTypes(true).showDoc(true)
);
// C.2) Create the Thyra-wrapped ModelEvaluator
RCP<Thyra::ModelEvaluator<double> > fwdStateModel =
epetraModelEvaluator(epetraStateModel, W_factory);
const RCP<const Thyra::VectorSpaceBase<Scalar> >
x_space = fwdStateModel->get_x_space();
const RCP<const Thyra::VectorBase<Scalar> >
gamma = Thyra::create_Vector(epetraStateModel->get_gamma(), x_space);
*out << "\ngamma = " << describe(*gamma, solnVerbLevel);
//
*out << "\nD) Create the stepper and integrator for the forward problem ...\n";
//
RCP<Rythmos::TimeStepNonlinearSolver<double> > fwdTimeStepSolver =
Rythmos::timeStepNonlinearSolver<double>();
RCP<Rythmos::StepperBase<Scalar> > fwdStateStepper =
Rythmos::backwardEulerStepper<double>(fwdStateModel, fwdTimeStepSolver);
fwdStateStepper->setParameterList(sublist(paramList, RythmosStepper_name));
RCP<Rythmos::IntegratorBase<Scalar> > fwdStateIntegrator;
{
RCP<ParameterList>
integrationControlPL = sublist(paramList, RythmosIntegrationControl_name);
integrationControlPL->set( "Take Variable Steps", false );
integrationControlPL->set( "Fixed dt", as<double>(delta_t) );
RCP<Rythmos::IntegratorBase<Scalar> >
defaultIntegrator = Rythmos::controlledDefaultIntegrator<Scalar>(
Rythmos::simpleIntegrationControlStrategy<Scalar>(integrationControlPL)
);
fwdStateIntegrator = defaultIntegrator;
}
fwdStateIntegrator->setParameterList(sublist(paramList, RythmosIntegrator_name));
//
*out << "\nE) Solve the forward problem ...\n";
//
const MEB::InArgs<Scalar>
state_ic = fwdStateModel->getNominalValues();
*out << "\nstate_ic:\n" << describe(state_ic,solnVerbLevel);
fwdStateStepper->setInitialCondition(state_ic);
fwdStateIntegrator->setStepper(fwdStateStepper, t_final);
Array<RCP<const Thyra::VectorBase<Scalar> > > x_final_array;
fwdStateIntegrator->getFwdPoints(
Teuchos::tuple<Scalar>(t_final), &x_final_array, NULL, NULL
);
const RCP<const Thyra::VectorBase<Scalar> > x_final = x_final_array[0];
*out << "\nx_final:\n" << describe(*x_final, solnVerbLevel);
//
*out << "\nF) Check the solution to the forward problem ...\n";
//
const RCP<Thyra::VectorBase<Scalar> >
x_beta = createMember(x_space),
x_final_be_exact = createMember(x_space);
{
Thyra::ConstDetachedVectorView<Scalar> d_gamma(*gamma);
Thyra::ConstDetachedVectorView<Scalar> d_x_ic(*state_ic.get_x());
Thyra::DetachedVectorView<Scalar> d_x_beta(*x_beta);
Thyra::DetachedVectorView<Scalar> d_x_final_be_exact(*x_final_be_exact);
const int n = d_gamma.subDim();
for ( int i = 0; i < n; ++i ) {
d_x_beta(i) = 1.0 / ( 1.0 - delta_t * d_gamma(i) );
d_x_final_be_exact(i) = integralPow(d_x_beta(i), numTimeSteps) * d_x_ic(i);
}
}
*out << "\nx_final_be_exact:\n" << describe(*x_final_be_exact, solnVerbLevel);
result = Thyra::testRelNormDiffErr<Scalar>(
"x_final", *x_final,
"x_final_be_exact", *x_final_be_exact,
"maxStateError", maxStateError,
"warningTol", 1.0, // Don't warn
&*out, solnVerbLevel
);
if (!result) success = false;
//
*out << "\nG) Create the Adjoint ME wrapper object ...\n";
//
RCP<Thyra::ModelEvaluator<double> > adjModel =
Rythmos::adjointModelEvaluator<double>(
fwdStateModel, fwdTimeRange
);
//
*out << "\nH) Create a stepper and integrator for the adjoint ...\n";
//
RCP<Thyra::LinearNonlinearSolver<double> > adjTimeStepSolver =
Thyra::linearNonlinearSolver<double>();
RCP<Rythmos::StepperBase<Scalar> > adjStepper =
Rythmos::backwardEulerStepper<double>(adjModel, adjTimeStepSolver);
adjStepper->setParameterList(sublist(paramList, RythmosStepper_name));
RCP<Rythmos::IntegratorBase<Scalar> > adjIntegrator =
fwdStateIntegrator->cloneIntegrator();
//
*out << "\nI) Set up the initial condition for the adjoint at the final time ...\n";
//
const RCP<const Thyra::VectorSpaceBase<Scalar> >
f_space = fwdStateModel->get_f_space();
// lambda(t_final) = x_final
const RCP<Thyra::VectorBase<Scalar> > lambda_ic = createMember(f_space);
V_V( outArg(*lambda_ic), *x_final_be_exact );
// lambda_dot(t_final,i) = - gamma(i) * lambda(t_final,i)
const RCP<Thyra::VectorBase<Scalar> > lambda_dot_ic = createMember(f_space);
Thyra::V_S<Scalar>( outArg(*lambda_dot_ic), ST::zero() );
Thyra::ele_wise_prod<Scalar>( -ST::one(), *gamma, *lambda_ic,
outArg(*lambda_dot_ic) );
MEB::InArgs<Scalar> adj_ic = adjModel->getNominalValues();
adj_ic.set_x(lambda_ic);
adj_ic.set_x_dot(lambda_dot_ic);
*out << "\nadj_ic:\n" << describe(adj_ic,solnVerbLevel);
//
*out << "\nJ) Integrate the adjoint backwards in time (using backward time) ...\n";
//
adjStepper->setInitialCondition(adj_ic);
adjIntegrator->setStepper(adjStepper, fwdTimeRange.length());
Array<RCP<const Thyra::VectorBase<Scalar> > > lambda_final_array;
adjIntegrator->getFwdPoints(
Teuchos::tuple<Scalar>(fwdTimeRange.length()), &lambda_final_array, NULL, NULL
);
const RCP<const Thyra::VectorBase<Scalar> > lambda_final = lambda_final_array[0];
*out << "\nlambda_final:\n" << describe(*lambda_final, solnVerbLevel);
//
*out << "\nK) Test the final adjoint againt exact discrete solution ...\n";
//
{
const RCP<Thyra::VectorBase<Scalar> >
lambda_final_be_exact = createMember(x_space);
{
Thyra::ConstDetachedVectorView<Scalar> d_gamma(*gamma);
Thyra::ConstDetachedVectorView<Scalar> d_x_final(*x_final);
Thyra::DetachedVectorView<Scalar> d_x_beta(*x_beta);
Thyra::DetachedVectorView<Scalar> d_lambda_final_be_exact(*lambda_final_be_exact);
const int n = d_gamma.subDim();
for ( int i = 0; i < n; ++i ) {
d_lambda_final_be_exact(i) = integralPow(d_x_beta(i), numTimeSteps) * d_x_final(i);
}
}
*out << "\nlambda_final_be_exact:\n" << describe(*lambda_final_be_exact, solnVerbLevel);
result = Thyra::testRelNormDiffErr<Scalar>(
"lambda_final", *lambda_final,
"lambda_final_be_exact", *lambda_final_be_exact,
"maxStateError", maxStateError,
"warningTol", 1.0, // Don't warn
&*out, solnVerbLevel
);
if (!result) success = false;
}
//
*out << "\nL) Test the reduced gradient from the adjoint against the discrete forward reduced gradient ...\n";
//
{
const RCP<const Thyra::VectorBase<Scalar> >
d_d_hat_d_p_from_lambda = lambda_final; // See above
const RCP<Thyra::VectorBase<Scalar> >
d_d_hat_d_p_be_exact = createMember(x_space);
{
Thyra::ConstDetachedVectorView<Scalar> d_x_ic(*state_ic.get_x());
Thyra::DetachedVectorView<Scalar> d_x_beta(*x_beta);
Thyra::DetachedVectorView<Scalar> d_d_d_hat_d_p_be_exact(*d_d_hat_d_p_be_exact);
const int n = d_x_ic.subDim();
for ( int i = 0; i < n; ++i ) {
d_d_d_hat_d_p_be_exact(i) = integralPow(d_x_beta(i), 2*numTimeSteps) * d_x_ic(i);
}
}
*out << "\nd_d_hat_d_p_be_exact:\n" << describe(*d_d_hat_d_p_be_exact, solnVerbLevel);
result = Thyra::testRelNormDiffErr<Scalar>(
"d_d_hat_d_p_from_lambda", *d_d_hat_d_p_from_lambda,
"d_d_hat_d_p_be_exact", *d_d_hat_d_p_be_exact,
"maxStateError", maxStateError,
"warningTol", 1.0, // Don't warn
&*out, solnVerbLevel
);
if (!result) success = false;
}
}
TEUCHOS_STANDARD_CATCH_STATEMENTS(true,*out,success);
if(success)
*out << "\nEnd Result: TEST PASSED" << endl;
else
*out << "\nEnd Result: TEST FAILED" << endl;
return ( success ? 0 : 1 );
} // end main() [Doxygen looks for this!]
/// \fn main
/// \brief Benchmark driver for (Mat)OrthoManager subclasses
int
main (int argc, char *argv[])
{
using Belos::OrthoManager;
using Belos::OrthoManagerFactory;
using Belos::OutputManager;
using Teuchos::CommandLineProcessor;
using Teuchos::ParameterList;
using Teuchos::parameterList;
using Teuchos::RCP;
using Teuchos::rcp;
Tpetra::ScopeGuard tpetraScope (&argc, &argv);
bool success = false;
bool verbose = false; // Verbosity of output
try {
RCP<const Teuchos::Comm<int> > pComm = Tpetra::getDefaultComm();
// This factory object knows how to make a (Mat)OrthoManager
// subclass, given a name for the subclass. The name is not the
// same as the class' syntactic name: e.g., "TSQR" is the name of
// TsqrOrthoManager.
OrthoManagerFactory<scalar_type, MV, OP> factory;
// The name of the (Mat)OrthoManager subclass to instantiate.
std::string orthoManName (factory.defaultName());
// For SimpleOrthoManager: the normalization method to use. Valid
// values: "MGS", "CGS".
std::string normalization ("CGS");
// Name of the Harwell-Boeing sparse matrix file from which to read
// the inner product operator matrix. If name is "" or not provided
// at the command line, use the standard Euclidean inner product.
std::string filename;
bool debug = false; // Whether to print debugging-level output
// Whether or not to run the benchmark. If false, we let this
// "test" pass trivially.
bool benchmark = false;
// Whether to display benchmark results compactly (in a CSV format),
// or in a human-readable table.
bool displayResultsCompactly = false;
// Default _local_ (per MPI process) number of rows. This will
// change if a sparse matrix is loaded in as an inner product
// operator. Regardless, the number of rows per MPI process must be
// no less than numCols*numBlocks in order for TSQR to work. To
// ensure that the test always passes with default parameters, we
// scale by the number of processes. The default value below may be
// changed by a command-line parameter with a corresponding name.
int numRowsPerProcess = 100;
// The OrthoManager is benchmarked with numBlocks multivectors of
// width numCols each, for numTrials trials. The values below are
// defaults and may be changed by the corresponding command-line
// arguments.
int numCols = 10;
int numBlocks = 5;
int numTrials = 3;
CommandLineProcessor cmdp (false, true);
cmdp.setOption ("benchmark", "nobenchmark", &benchmark,
"Whether to run the benchmark. If not, this \"test\" "
"passes trivially.");
cmdp.setOption ("verbose", "quiet", &verbose,
"Print messages and results.");
cmdp.setOption ("debug", "nodebug", &debug,
"Print debugging information.");
cmdp.setOption ("compact", "human", &displayResultsCompactly,
"Whether to display benchmark results compactly (in a "
"CSV format), or in a human-readable table.");
cmdp.setOption ("filename", &filename,
"Filename of a Harwell-Boeing sparse matrix, used as the "
"inner product operator by the orthogonalization manager."
" If not provided, no matrix is read and the Euclidean "
"inner product is used.");
{
std::ostringstream os;
const int numValid = factory.numOrthoManagers();
const bool plural = numValid > 1 || numValid == 0;
os << "OrthoManager subclass to benchmark. There ";
os << (plural ? "are " : "is ") << numValid << (plural ? "s: " : ": ");
factory.printValidNames (os);
os << ". If none is provided, the test trivially passes.";
cmdp.setOption ("ortho", &orthoManName, os.str().c_str());
}
cmdp.setOption ("normalization", &normalization,
"For SimpleOrthoManager (--ortho=Simple): the normalization "
"method to use. Valid values: \"MGS\", \"CGS\".");
cmdp.setOption ("numRowsPerProcess", &numRowsPerProcess,
"Number of rows per MPI process in the test multivectors. "
"If an input matrix is given, this value is ignored, since "
"the vectors must be commensurate with the dimensions of "
"the matrix.");
cmdp.setOption ("numCols", &numCols,
"Number of columns in the input multivector (>= 1).");
cmdp.setOption ("numBlocks", &numBlocks,
"Number of block(s) to benchmark (>= 1).");
cmdp.setOption ("numTrials", &numTrials,
"Number of trial(s) per timing run (>= 1).");
// Parse the command-line arguments.
{
const CommandLineProcessor::EParseCommandLineReturn parseResult = cmdp.parse (argc,argv);
// If the caller asks us to print the documentation, or does not
// explicitly say to run the benchmark, we let this "test" pass
// trivially.
if (! benchmark || parseResult == CommandLineProcessor::PARSE_HELP_PRINTED)
{
if (Teuchos::rank(*pComm) == 0)
std::cout << "End Result: TEST PASSED" << endl;
return EXIT_SUCCESS;
}
TEUCHOS_TEST_FOR_EXCEPTION(parseResult != CommandLineProcessor::PARSE_SUCCESSFUL,
std::invalid_argument,
"Failed to parse command-line arguments");
}
// Total number of rows in the test vector(s).
// This may be changed if we load in a sparse matrix.
int numRows = numRowsPerProcess * pComm->getSize();
//
// Validate command-line arguments
//
TEUCHOS_TEST_FOR_EXCEPTION(numRowsPerProcess <= 0, std::invalid_argument,
"numRowsPerProcess <= 0 is not allowed");
TEUCHOS_TEST_FOR_EXCEPTION(numCols <= 0, std::invalid_argument,
"numCols <= 0 is not allowed");
TEUCHOS_TEST_FOR_EXCEPTION(numBlocks <= 0, std::invalid_argument,
"numBlocks <= 0 is not allowed");
// Declare an output manager for handling local output. Initialize,
// using the caller's desired verbosity level.
RCP<OutputManager<scalar_type> > outMan =
Belos::Test::makeOutputManager<scalar_type> (verbose, debug);
// Stream for debug output. If debug output is not enabled, then
// this stream doesn't print anything sent to it (it's a "black
// hole" stream).
std::ostream& debugOut = outMan->stream(Belos::Debug);
Belos::Test::printVersionInfo (debugOut);
// Load the inner product operator matrix from the given filename.
// If filename == "", use the identity matrix as the inner product
// operator (the Euclidean inner product), and leave M as
// Teuchos::null. Also return an appropriate Map (which will
// always be initialized; it should never be Teuchos::null).
RCP<map_type> map;
RCP<sparse_matrix_type> M;
{
using Belos::Test::loadSparseMatrix;
// If the sparse matrix is loaded successfully, this call will
// modify numRows to be the total number of rows in the sparse
// matrix. Otherwise, it will leave numRows alone.
std::pair<RCP<map_type>, RCP<sparse_matrix_type> > results =
loadSparseMatrix<local_ordinal_type, global_ordinal_type, node_type> (pComm, filename, numRows, debugOut);
map = results.first;
M = results.second;
}
TEUCHOS_TEST_FOR_EXCEPTION(map.is_null(), std::logic_error,
"Error: (Mat)OrthoManager test code failed to "
"initialize the Map");
if (M.is_null())
{
// Number of rows per process has to be >= number of rows.
TEUCHOS_TEST_FOR_EXCEPTION(numRowsPerProcess <= numCols,
std::invalid_argument,
"numRowsPerProcess <= numCols is not allowed");
}
// Loading the sparse matrix may have changed numRows, so check
// again that the number of rows per process is >= numCols.
// getNodeNumElements() returns a size_t, which is unsigned, and you
// shouldn't compare signed and unsigned values.
if (map->getNodeNumElements() < static_cast<size_t>(numCols))
{
std::ostringstream os;
os << "The number of elements on this process " << pComm->getRank()
<< " is too small for the number of columns that you want to test."
<< " There are " << map->getNodeNumElements() << " elements on "
"this process, but the normalize() method of the MatOrthoManager "
"subclass will need to process a multivector with " << numCols
<< " columns. Not all MatOrthoManager subclasses can handle a "
"local row block with fewer rows than columns.";
// QUESTION (mfh 26 Jan 2011) Should this be a logic error
// instead? It's really TSQR's fault that it can't handle a
// local number of elements less than the number of columns.
throw std::invalid_argument(os.str());
}
// Using the factory object, instantiate the specified OrthoManager
// subclass to be tested. Specify "fast" parameters for a fair
// benchmark comparison, but override the fast parameters to get the
// desired normalization method for SimpleOrthoManaager.
RCP<OrthoManager<scalar_type, MV> > orthoMan;
{
std::string label (orthoManName);
RCP<ParameterList> params =
parameterList (*(factory.getFastParameters (orthoManName)));
if (orthoManName == "Simple") {
params->set ("Normalization", normalization);
label = label + " (" + normalization + " normalization)";
}
orthoMan = factory.makeOrthoManager (orthoManName, M, outMan, label, params);
}
// "Prototype" multivector. The test code will use this (via
// Belos::MultiVecTraits) to clone other multivectors as necessary.
// (This means the test code doesn't need the Map, and it also makes
// the test code independent of the idea of a Map.) We only have to
// allocate one column, because the entries are S are not even read.
// (We could allocate zero columns, if the MV object allows it. We
// play it safe and allocate 1 column instead.)
RCP<MV> X = rcp (new MV (map, 1));
// "Compact" mode means that we have to override
// TimeMonitor::summarize(), which both handles multiple MPI
// processes correctly (only Rank 0 prints to std::cout), and prints
// verbosely in a table form. We deal with the former by making an
// ostream which is std::cout on Rank 0, and prints nothing (is a
// "bit bucket") elsewhere. We deal with the latter inside the
// benchmark itself.
Teuchos::oblackholestream bitBucket;
std::ostream& resultStream =
(displayResultsCompactly && Teuchos::rank(*pComm) != 0) ? bitBucket : std::cout;
// Benchmark the OrthoManager subclass.
typedef Belos::Test::OrthoManagerBenchmarker<scalar_type, MV> benchmarker_type;
benchmarker_type::benchmark (orthoMan, orthoManName, normalization, X,
numCols, numBlocks, numTrials,
outMan, resultStream, displayResultsCompactly);
success = true;
// Only Rank 0 gets to write to cout.
if (Teuchos::rank(*pComm) == 0)
std::cout << "End Result: TEST PASSED" << endl;
}
TEUCHOS_STANDARD_CATCH_STATEMENTS(verbose, std::cerr, success);
return ( success ? EXIT_SUCCESS : EXIT_FAILURE );
}
int main( int argc, char* argv[] )
{
using Teuchos::rcp;
using Teuchos::RCP;
using Teuchos::OSTab;
using MoochoPack::MoochoSolver;
using MoochoPack::MoochoThyraSolver;
using Teuchos::CommandLineProcessor;
Teuchos::GlobalMPISession mpiSession(&argc,&argv);
const int numProcs = mpiSession.getNProc();
Teuchos::Time timer("");
bool dummySuccess = true;
Teuchos::RCP<Teuchos::FancyOStream>
out = Teuchos::VerboseObjectBase::getDefaultOStream();
try {
// Create the solver object
GLpApp::AdvDiffReactOptModelCreator advDiffReacModelCreator;
Stratimikos::DefaultLinearSolverBuilder lowsfCreator;
MoochoThyraSolver solver;
//
// Get options from the command line
//
std::string matchingVecFile = "";
bool showMoochoThyraParams = false;
bool showMoochoThyraParamsWithDoc = true;
bool showMoochoThyraParamsXML = false;
CommandLineProcessor clp;
clp.throwExceptions(false);
clp.addOutputSetupOptions(true);
advDiffReacModelCreator.setupCLP(&clp);
lowsfCreator.setupCLP(&clp);
solver.setupCLP(&clp);
clp.setOption(
"q-vec-file", &matchingVecFile
,"Base file name to read the objective state matching "
"vector q (i.e. ||x-q||_M in the objective)."
);
clp.setOption(
"only-print-moocho-thyra-solver-params", "no-print-moocho-thyra-solver-params"
,&showMoochoThyraParams
,"Only print the parameters accepted by MoochoPack::MoochoThyraSolver and stop."
);
clp.setOption(
"show-doc", "hide-doc", &showMoochoThyraParamsWithDoc
,"Show MoochoPack::MocohoThyraSolver parameters with documentation or not."
);
clp.setOption(
"xml-format", "readable-format", &showMoochoThyraParamsXML
,"Show MoochoPack::MoochoThyraSolver parameters in XML or human-readable format."
);
CommandLineProcessor::EParseCommandLineReturn
parse_return = clp.parse(argc,argv,&std::cerr);
if( parse_return != CommandLineProcessor::PARSE_SUCCESSFUL )
return parse_return;
lowsfCreator.readParameters( !showMoochoThyraParams ? out.get() : NULL );
solver.readParameters( !showMoochoThyraParams ? out.get() : NULL );
if(showMoochoThyraParams) {
typedef Teuchos::ParameterList::PrintOptions PLPrintOptions;
if(showMoochoThyraParamsXML)
Teuchos::writeParameterListToXmlOStream(
*solver.getValidParameters()
,*out
);
else
solver.getValidParameters()->print(
*out,PLPrintOptions().indent(2).showTypes(true).showDoc(showMoochoThyraParamsWithDoc)
);
return 0;
}
//
// Setup the output streams
//
Teuchos::RCP<Teuchos::FancyOStream>
journalOut = Teuchos::rcp(
new Teuchos::FancyOStream(
solver.getSolver().generate_output_file("MoochoJournal")
," "
)
);
journalOut->copyAllOutputOptions(*out);
*out
<< "\n***"
<< "\n*** NLPThyraEpetraAdvDiffReactOptMain, Global numProcs = "<<numProcs
<< "\n***\n";
#ifdef HAVE_MPI
MPI_Comm mpiComm = MPI_COMM_WORLD;
#endif
Teuchos::RCP<Epetra_Comm> comm = Teuchos::null;
#ifdef HAVE_MPI
comm = Teuchos::rcp(new Epetra_MpiComm(mpiComm));
#else
comm = Teuchos::rcp(new Epetra_SerialComm());
#endif
//
// Create the Thyra::ModelEvaluator object
//
*out << "\nCreate the GLpApp::AdvDiffReactOptModel wrapper object ...\n";
Teuchos::RCP<GLpApp::AdvDiffReactOptModel>
epetraModel = advDiffReacModelCreator.createModel(comm);
epetraModel->setOStream(journalOut);
*out << "\nCreate the Thyra::LinearOpWithSolveFactory object ...\n";
Teuchos::RCP<Thyra::LinearOpWithSolveFactoryBase<Scalar> >
lowsFactory = lowsfCreator.createLinearSolveStrategy("");
// ToDo: Set the output stream before calling above!
///lowsFactory = lowsfCreator.createLOWSF(OSTab(journalOut).get());
*out << "\nCreate the Thyra::EpetraModelEvaluator wrapper object ...\n";
Teuchos::RCP<Thyra::EpetraModelEvaluator>
epetraThyraModel = rcp(new Thyra::EpetraModelEvaluator()); // Sets default options!
epetraThyraModel->setOStream(journalOut);
epetraThyraModel->initialize(epetraModel,lowsFactory);
*out
<< "\nnx = " << epetraThyraModel->get_x_space()->dim()
<< "\nnp = " << epetraThyraModel->get_p_space(0)->dim() << "\n";
if(matchingVecFile != "") {
*out << "\nReading the matching vector \'q\' from the file(s) with base name \""<<matchingVecFile<<"\" ...\n";
Thyra::DefaultSpmdMultiVectorFileIO<Scalar> fileIO;
epetraModel->set_q(
Thyra::get_Epetra_Vector(
*epetraModel->get_x_map()
,readVectorFromFile(fileIO,matchingVecFile,*epetraThyraModel->get_x_space())
)
);
}
//
// Solve the NLP
//
// Set the journal file
solver.getSolver().set_journal_out(journalOut);
// Set the model
solver.setModel(epetraThyraModel);
// Read the initial guess if one exists
solver.readInitialGuess(out.get());
// Solve the NLP
const MoochoSolver::ESolutionStatus solution_status = solver.solve();
// Write the solution to file
solver.writeFinalSolution(out.get());
// Write the final parameters to file
lowsfCreator.writeParamsFile(*lowsFactory);
solver.writeParamsFile();
//
// Return the solution status (0 if successful)
//
if(solution_status == MoochoSolver::SOLVE_RETURN_SOLVED)
*out << "\nEnd Result: TEST PASSED\n";
else
*out << "\nEnd Result: TEST FAILED\n";
return solution_status;
}
TEUCHOS_STANDARD_CATCH_STATEMENTS(true, *out, dummySuccess)
return MoochoSolver::SOLVE_RETURN_EXCEPTION;
}
int main( int argc, char* argv[] )
{
using Teuchos::rcp;
using Teuchos::RCP;
using Teuchos::OSTab;
using MoochoPack::MoochoSolver;
using MoochoPack::MoochoThyraSolver;
using Teuchos::CommandLineProcessor;
Teuchos::GlobalMPISession mpiSession(&argc, &argv);
Teuchos::Time timer("");
bool dummySuccess = true;
Teuchos::RCP<Teuchos::FancyOStream>
out = Teuchos::VerboseObjectBase::getDefaultOStream();
try {
//
// A) Create the solver objects that will insert their command-line
// options
//
MoochoThyraSolver solver;
//
// B) Get options from the command line
//
int localDim = 4;
double pt = 0.0;
double p0 = 0.1;
double scale = 0.1;
CommandLineProcessor clp;
clp.throwExceptions(false);
clp.addOutputSetupOptions(true);
clp.setOption("local-dim", &localDim);
clp.setOption("pt", &pt);
clp.setOption("p0", &p0);
clp.setOption("scale", &scale);
solver.setupCLP(&clp);
CommandLineProcessor::EParseCommandLineReturn
parse_return = clp.parse(argc,argv,&std::cerr);
if( parse_return != CommandLineProcessor::PARSE_SUCCESSFUL )
return parse_return;
solver.readParameters( out.get() );
Teuchos::RCP<Epetra_Comm> comm = Teuchos::null;
#ifdef HAVE_MPI
MPI_Comm mpiComm = MPI_COMM_WORLD;
comm = Teuchos::rcp(new Epetra_MpiComm(mpiComm));
#else
comm = Teuchos::rcp(new Epetra_SerialComm());
#endif
//
// C) Create the Thyra::ModelEvaluator object
//
*out << "\nCreate EpetraExt::DiagonalQuadraticResponseOnlyModelEvaluator object ...\n";
Teuchos::RCP<EpetraExt::DiagonalQuadraticResponseOnlyModelEvaluator>
epetraModel = EpetraExt::diagonalQuadraticResponseOnlyModelEvaluator(
comm, localDim, pt, p0, scale);
*out << "\nCreate the Thyra::EpetraModelEvaluator wrapper object ...\n";
Teuchos::RCP<Thyra::EpetraModelEvaluator>
epetraThyraModel(new Thyra::EpetraModelEvaluator()); // Sets default options!
epetraThyraModel->initialize(epetraModel, Teuchos::null);
//
// D) Solve the NLP
//
// Set the model
solver.setModel(epetraThyraModel);
// Read the initial guess if one exists
solver.readInitialGuess(out.get());
// Solve the NLP
const MoochoSolver::ESolutionStatus solution_status = solver.solve();
// Write the solution to file
solver.writeFinalSolution(out.get());
// Write the final parameters to file
solver.writeParamsFile();
//
// E) Return the solution status (0 if successful)
//
if(solution_status == MoochoSolver::SOLVE_RETURN_SOLVED)
*out << "\nEnd Result: TEST PASSED\n";
else
*out << "\nEnd Result: TEST FAILED\n";
return solution_status;
}
TEUCHOS_STANDARD_CATCH_STATEMENTS(true, *out, dummySuccess)
return MoochoSolver::SOLVE_RETURN_EXCEPTION;
}
//
// Main driver program for epetra implementation of the power method.
//
int main(int argc, char *argv[])
{
using Teuchos::outArg;
using Teuchos::CommandLineProcessor;
using Teuchos::RCP;
bool success = true;
bool result;
//
// (A) Setup and get basic MPI info
//
Teuchos::GlobalMPISession mpiSession(&argc,&argv);
#ifdef HAVE_MPI
MPI_Comm mpiComm = MPI_COMM_WORLD;
#endif
//
// (B) Setup the output stream (do output only on root process!)
//
Teuchos::RCP<Teuchos::FancyOStream>
out = Teuchos::VerboseObjectBase::getDefaultOStream();
try {
//
// (C) Read in commandline options
//
CommandLineProcessor clp;
clp.throwExceptions(false);
clp.addOutputSetupOptions(true);
int globalDim = 500;
clp.setOption( "global-dim", &globalDim, "Global dimension of the linear system." );
bool dumpAll = false;
clp.setOption( "dump-all", "no-dump", &dumpAll, "Determines if quantities are dumped or not." );
CommandLineProcessor::EParseCommandLineReturn
parse_return = clp.parse(argc,argv);
if (parse_return != CommandLineProcessor::PARSE_SUCCESSFUL)
return parse_return;
TEST_FOR_EXCEPTION( globalDim < 2, std::logic_error, "Error, globalDim=" << globalDim << " < 2 is not allowed!" );
*out << "\n***\n*** Running power method example using Epetra implementation\n***\n" << std::scientific;
//
// (D) Setup the operator and run the power method!
//
//
// (1) Setup the initial tridiagonal operator
//
// [ 2 -1 ]
// [ -1 2 -1 ]
// A = [ . . . ]
// [ -1 2 -1 ]
// [ -1 2 ]
//
*out << "\n(1) Constructing tridagonal Epetra matrix A of global dimension = " << globalDim << " ...\n";
RCP<Epetra_Operator>
A_epetra = createTridiagEpetraLinearOp(
globalDim,
#ifdef HAVE_MPI
mpiComm,
#endif
1.0, true, *out
);
// Wrap in an Thyra::EpetraLinearOp object
RCP<Thyra::LinearOpBase<double> >
A = Thyra::nonconstEpetraLinearOp(A_epetra);
//
if (dumpAll) *out << "\nA =\n" << *A; // This works even in parallel!
//
// (2) Run the power method ANA
//
*out << "\n(2) Running the power method on matrix A ...\n";
double lambda = 0.0;
double tolerance = 1e-3;
int maxNumIters = 10*globalDim;
result = sillyPowerMethod<double>(*A, maxNumIters, tolerance, outArg(lambda), *out);
if(!result) success = false;
*out << "\n Estimate of dominate eigenvalue lambda = " << lambda << std::endl;
//
// (3) Increase dominance of first eigenvalue
//
*out << "\n(3) Scale the diagonal of A by a factor of 10 ...\n";
scaleFirstDiagElement( 10.0, &*A );
//
// (4) Run the power method ANA again
//
*out << "\n(4) Running the power method again on matrix A ...\n";
result = sillyPowerMethod<double>(*A, maxNumIters, tolerance, outArg(lambda), *out);
if(!result) success = false;
*out << "\n Estimate of dominate eigenvalue lambda = " << lambda << std::endl;
}
TEUCHOS_STANDARD_CATCH_STATEMENTS(true,*out,success)
if (success)
*out << "\nCongratulations! All of the tests checked out!\n";
else
*out << "\nOh no! At least one of the tests failed!\n";
return success ? 0 : 1;
} // end main()
int main(int argc, char **argv)
{
// Initialize Tpetra (MPI and Kokkos nodes)
Tpetra::initialize(&argc, &argv);
// Get global communicator
COMM_ptr_t comm = Tpetra::getDefaultComm();
// obtain the rank of current process and the size of communicator
int myRank = comm->getRank();
int procNum = comm->getSize();
// set up fancy output, which can be used by Trilinos objects
Teuchos::oblackholestream blackHole;
std::ostream &out = (myRank == 0) ? std::cout : blackHole;
// setup the domain and descritization information
int Nx = 100;
CommandLineProcessor CLP;
CLP.setDocString("Trilinos MVM test.");
CLP.setOption("Nx", &Nx, "Number of grid points on x direction. (Ny = Nx)");
CLP.parse(argc, argv);
out << "Final value of Nx: " << Nx << std::endl;
int N = Nx * Nx;
// create a Map and obtain the number of nodes contained in current process
MAP_ptr_t map = rcp(new MAP_t(N, 0, comm, Tpetra::GloballyDistributed));
// number of local entries
LO_t localN = map->getNodeNumElements();
// definition of all variables
RCP<MV_t> x, y;
RCP<SPM_t> A;
// set x and y coordinates
x = rcp(new MV_t(map, 1));
y = rcp(new MV_t(map, 1));
comm->barrier();
// set sparse matrix A, a fully Neumann BC Poisson problem
A = rcp(new SPM_t(map, 5, Tpetra::StaticProfile));
A->setObjectLabel("coefficient matrix");
generateA(map, A, Nx);
comm->barrier();
A->fillComplete();
// initialize a timer
RCP<Time> MVMTime = TimeMonitor::getNewCounter("Wall-time of MVM");
for(int i=0; i<10; ++i)
{
x->randomize();
y->randomize();
comm->barrier();
TimeMonitor localTimer(*MVMTime);
// Matrix-Vector Multiplication
A->apply(*x, *y);
comm->barrier();
}
TimeMonitor::summarize(comm.ptr(), out, true, true, true,
Teuchos::Intersection, "", false);
Tpetra::finalize();
return 0;
}
int main( int argc, char* argv[] ) {
using Teuchos::CommandLineProcessor;
using Teuchos::RCP;
bool success = true;
bool verbose = true;
Teuchos::GlobalMPISession mpiSession(&argc,&argv);
RCP<Teuchos::FancyOStream>
out = Teuchos::VerboseObjectBase::getDefaultOStream();
try {
//
// Read options from command-line
//
int n = 4;
int numBlocks = 4;
bool showAllTests = true;
bool dumpAll = false;
CommandLineProcessor clp;
clp.throwExceptions(false);
clp.addOutputSetupOptions(true);
clp.setOption( "verbose", "quiet", &verbose, "Set if output is printed or not." );
clp.setOption( "n", &n, "Number of elements in each constituent vector." );
clp.setOption( "num-blocks", &numBlocks, "blocks to create." );
clp.setOption( "dump-all", "no-dump-all", &dumpAll, "Determines if vectors are printed or not." );
clp.setOption( "show-all-tests", "no-show-all-tests", &showAllTests, "Determines if all tests are printed or not." );
CommandLineProcessor::EParseCommandLineReturn parse_return = clp.parse(argc,argv);
if( parse_return != CommandLineProcessor::PARSE_SUCCESSFUL ) return parse_return;
//
// Run the tests
//
#ifdef HAVE_THYRA_TEUCHOS_BLASFLOAT
if( !run_product_space_tests<float>(n,numBlocks,float(1e-5),showAllTests,dumpAll,verbose?&*out:NULL) ) success = false;
#endif // HAVE_THYRA_TEUCHOS_BLASFLOAT
if( !run_product_space_tests<double>(n,numBlocks,double(1e-13),showAllTests,dumpAll,verbose?&*out:NULL) ) success = false;
#if defined(HAVE_THYRA_COMPLEX)
#ifdef THYRA_TEUCHOS_BLASFLOAT
if( !run_product_space_tests<std::complex<float> >(n,numBlocks,float(1e-5),showAllTests,dumpAll,verbose?&*out:NULL) ) success = false;
#endif // HAVE_THYRA_TEUCHOS_BLASFLOAT
if( !run_product_space_tests<std::complex<double> >(n,numBlocks,double(1e-12),showAllTests,dumpAll,verbose?&*out:NULL) ) success = false;
#endif // defined(HAVE_THYRA_COMPLEX)
#ifdef HAVE_TEUCHOS_GNU_MP
//if( !run_product_space_tests<mpf_class>(n,numBlocks,mpf_class(1e-13),showAllTests,dumpAll,verbose?&*out:NULL) ) success = false;
// Above commented out code will not compile because its ScalarTraits specialization does not support eps()
#endif // HAVE_TEUCHOS_GNU_MP
} // end try
TEUCHOS_STANDARD_CATCH_STATEMENTS(true,*out,success)
if(verbose) {
if(success)
*out << "\nAll of the tests seem to have run successfully!\n";
else
*out << "\nOh no! at least one of the test failed!\n";
}
return success ? 0 : 1;
} // end main() [Doxygen looks for this!]
int
main (int argc, char *argv[])
{
using Teuchos::Array;
using Teuchos::as;
using Teuchos::Comm;
using Teuchos::CommandLineProcessor;
using Teuchos::ParameterList;
using Teuchos::ptr;
using Teuchos::RCP;
using Teuchos::rcp;
using Teuchos::REDUCE_MAX;
using Teuchos::REDUCE_MIN;
using Teuchos::reduceAll;
using std::cerr;
using std::cout;
using std::endl;
typedef double scalar_type;
typedef int local_ordinal_type;
typedef int global_ordinal_type;
typedef Kokkos::SerialNode node_type;
Teuchos::GlobalMPISession mpiSession (&argc, &argv, &cout);
RCP<const Comm<int> > comm =
Tpetra::DefaultPlatform::getDefaultPlatform().getComm();
const int myRank = comm->getRank();
const int numProcs = comm->getSize();
std::string inputFilename; // Matrix Market file to read
std::string temporaryFilename; // Matrix Market file to write (if applicable)
std::string outputFilename; // Matrix Market file to write (if applicable)
// Number of a specific test to run. If nonzero, only run that
// test. We always run Test #1 since its result is needed for
// subsequent tests.
int testToRun = 0;
// FIXME (mfh 07 Feb 2012) Currently, all tests with a different
// index base FAIL. Reading in the multivector appears to be
// correct, but writing it results in a multivector of all zeros (on
// _all_ processes).
bool testDifferentIndexBase = false;
bool testContiguousInputMap = true;
bool testNoncontiguousInputMap = false;
bool testWrite = true; // Test Matrix Market output?
bool tolerant = false; // Parse the file tolerantly?
bool echo = false; // Echo the read-in matrix back?
bool verbose = false; // Verbosity of output
bool debug = false; // Print debugging info?
// If true, stop after a single test failure. Intended for
// interactive use, so that you can examine a test's output file.
// Not intended for batch or ctest use.
bool stopAfterFailure = false;
CommandLineProcessor cmdp (false, true);
cmdp.setOption ("inputFilename", &inputFilename,
"Name of the Matrix Market dense matrix file to read.");
cmdp.setOption ("temporaryFilename", &temporaryFilename,
"If --testWrite is true, then use this file as temporary "
"storage on (MPI) Proc 0. Otherwise, this argument is "
"ignored.");
cmdp.setOption ("outputFilename", &outputFilename,
"If --testWrite is true, then write the read-in matrix to "
"this file in Matrix Market format on (MPI) Proc 0. "
"Otherwise, this argument is ignored. Note that the output "
"file may not be identical to the input file.");
cmdp.setOption ("testToRun", &testToRun, "Number of a specific test to run. "
"If nonzero, only run that test. We always run Test #1 since"
" its result is needed for subsequent tests.");
cmdp.setOption ("testDifferentIndexBase", "dontTestDifferentIndexBase",
&testDifferentIndexBase, "Whether to test input and output "
"for Maps with different index bases.");
cmdp.setOption ("testContiguousInputMap", "dontTestContiguousInputMap",
&testContiguousInputMap,
"Whether to test input and output for nonnull contiguous "
"input Maps.");
cmdp.setOption ("testNoncontiguousInputMap", "dontTestNoncontiguousInputMap",
&testNoncontiguousInputMap,
"Whether to test input and output for nonnull noncontiguous "
"input Maps.");
cmdp.setOption ("testWrite", "noTestWrite", &testWrite,
"Whether to test Matrix Market file output. Ignored if no "
"--outputFilename value is given.");
cmdp.setOption ("tolerant", "strict", &tolerant,
"Whether to parse the input Matrix Market file tolerantly.");
cmdp.setOption ("echo", "noecho", &echo,
"Whether to echo the read-in matrix back to stdout on Rank 0 "
"in Matrix Market format. Note that the echoed matrix may "
"not be identical to the input file.");
cmdp.setOption ("verbose", "quiet", &verbose, "Print messages and results.");
cmdp.setOption ("debug", "nodebug", &debug, "Print debugging information.");
cmdp.setOption ("stopAfterFailure", "dontStopAfterFailure", &stopAfterFailure,
"Whether to stop after a single test failure.");
// Parse the command-line arguments.
{
const CommandLineProcessor::EParseCommandLineReturn parseResult =
cmdp.parse (argc,argv);
// If the caller asks us to print the documentation, or does not
// explicitly say to run the benchmark, we let this "test" pass
// trivially.
if (parseResult == CommandLineProcessor::PARSE_HELP_PRINTED) {
if (myRank == 0) {
cout << "End Result: TEST PASSED" << endl;
}
return EXIT_SUCCESS;
}
TEUCHOS_TEST_FOR_EXCEPTION(parseResult != CommandLineProcessor::PARSE_SUCCESSFUL,
std::invalid_argument, "Failed to parse command-line arguments.");
}
// Get a Kokkos Node instance for the particular Node type.
RCP<node_type> node = getNode<node_type>();
// List of numbers of failed tests.
std::vector<int> failedTests;
// Current test number. Increment before starting each test. If a
// test is only run conditionally, increment before evaluating the
// condition. This ensures that each test has the same number each
// time, whether or not a particular test is run.
int testNum = 0;
// Run all the tests. If no input filename was specified, we don't
// invoke the test and we report a "TEST PASSED" message.
if (inputFilename != "") {
// Convenient abbreviations
typedef scalar_type ST;
typedef local_ordinal_type LO;
typedef global_ordinal_type GO;
typedef node_type NT;
typedef Tpetra::MultiVector<ST, LO, GO, NT> MV;
typedef Tpetra::Map<LO, GO, NT> MT;
// If not testing writes, don't do the sanity check that tests
// input by comparing against output.
std::string outFilename = testWrite ? outputFilename : "";
std::string tmpFilename = testWrite ? temporaryFilename : "";
// Test 1: null input Map.
++testNum;
if (verbose && myRank == 0) {
cout << "Test " << testNum << ": Null Map on input to readDenseFile()" << endl;
}
RCP<MV> X;
try {
X = testReadDenseFile<MV> (inputFilename, tmpFilename, comm,
node, tolerant, verbose, debug);
if (outFilename != "") {
testWriteDenseFile<MV> (outFilename, X, echo, verbose, debug);
}
} catch (std::exception& e) {
failedTests.push_back (testNum);
// If Test 1 fails, the other tests shouldn't even run, since
// they depend on the result of Test 1 (the multivector X).
throw e;
}
// Test 2: nonnull contiguous input Map with the same index base
// as X's Map. This Map may or may not necessarily be the same as
// (in the sense of isSameAs()) or even compatible with X's Map.
++testNum;
if ((testToRun == 0 && testContiguousInputMap) ||
(testToRun != 0 && testToRun == testNum)) {
if (verbose && myRank == 0) {
cout << "Test " << testNum << ": Nonnull contiguous Map (same index "
"base) on input to readDenseFile()" << endl;
}
const Tpetra::global_size_t globalNumRows = X->getMap()->getGlobalNumElements();
const GO indexBase = X->getMap()->getIndexBase();
// Create the Map.
RCP<const MT> map =
rcp (new Tpetra::Map<LO, GO, NT> (globalNumRows, indexBase, comm,
Tpetra::GloballyDistributed, node));
try {
RCP<MV> X2 =
testReadDenseFileWithInputMap<MV> (inputFilename, tmpFilename,
map, tolerant, verbose, debug);
if (outFilename != "") {
testWriteDenseFile<MV> (outFilename, X2, echo, verbose, debug);
}
} catch (std::exception& e) {
failedTests.push_back (testNum);
if (myRank == 0) {
cerr << "Test " << testNum << " failed: " << e.what() << endl;
}
if (stopAfterFailure) {
if (failedTests.size() > 0) {
if (myRank == 0) {
cout << "End Result: TEST FAILED" << endl;
}
return EXIT_FAILURE;
}
else {
if (myRank == 0) {
cout << "End Result: TEST PASSED" << endl;
}
return EXIT_SUCCESS;
}
} // if stop after failure
}
}
// Test 3: nonnull contiguous input Map, with a different index
// base than X's Map. In this case, the index base is X's Map's
// index base plus a small number (3). For sufficiently long
// vectors, this tests the case where the GID sets overlap.
++testNum;
if ((testToRun == 0 && testContiguousInputMap && testDifferentIndexBase) ||
(testToRun != 0 && testToRun == testNum)) {
if (verbose && myRank == 0) {
cout << "Test " << testNum << ": Nonnull contiguous Map (different "
"index base) on input to readDenseFile()" << endl;
}
const Tpetra::global_size_t globalNumRows = X->getMap()->getGlobalNumElements();
const GO indexBase = X->getMap()->getIndexBase() + as<GO> (3);
// Make sure that the index base is the same on all processes.
// It definitely should be, since the Map's getMaxAllGlobalIndex()
// method should return the same value on all processes.
GO minIndexBase = indexBase;
reduceAll (*comm, REDUCE_MIN, indexBase, ptr (&minIndexBase));
GO maxIndexBase = indexBase;
reduceAll (*comm, REDUCE_MAX, indexBase, ptr (&maxIndexBase));
TEUCHOS_TEST_FOR_EXCEPTION(minIndexBase != maxIndexBase || minIndexBase != indexBase,
std::logic_error, "Index base values do not match on all processes. "
"Min value is " << minIndexBase << " and max value is " << maxIndexBase
<< ".");
// Create the Map.
RCP<const MT> map =
rcp (new Tpetra::Map<LO, GO, NT> (globalNumRows, indexBase, comm,
Tpetra::GloballyDistributed, node));
try {
RCP<MV> X3 =
testReadDenseFileWithInputMap<MV> (inputFilename, tmpFilename,
map, tolerant, verbose, debug);
if (outFilename != "") {
testWriteDenseFile<MV> (outFilename, X3, echo, verbose, debug);
}
} catch (std::exception& e) {
failedTests.push_back (testNum);
if (myRank == 0) {
cerr << "Test " << testNum << " failed: " << e.what() << endl;
}
if (stopAfterFailure) {
if (failedTests.size() > 0) {
if (myRank == 0) {
cout << "End Result: TEST FAILED" << endl;
}
return EXIT_FAILURE;
}
else {
if (myRank == 0) {
cout << "End Result: TEST PASSED" << endl;
}
return EXIT_SUCCESS;
}
} // if stop after failure
}
}
// Test 4: nonnull contiguous input Map, with a different index
// base than X's Map. In this case, the new index base is chosen
// so that the new GID set does not overlap with X's Map's GID
// set.
++testNum;
if ((testToRun == 0 && testContiguousInputMap && testDifferentIndexBase) ||
(testToRun != 0 && testToRun == testNum)) {
if (verbose && myRank == 0) {
cout << "Test " << testNum << ": Nonnull contiguous Map (different "
"index base) on input to readDenseFile()" << endl;
}
const Tpetra::global_size_t globalNumRows = X->getMap()->getGlobalNumElements();
// Choose the Map's index base so that the global ordinal sets
// of X->getMap() and map don't overlap. This will ensure that
// we test something nontrivial.
const GO indexBase = X->getMap()->getMaxAllGlobalIndex() + 1;
// Make sure that the index base is the same on all processes.
// It definitely should be, since the Map's getMaxAllGlobalIndex()
// method should return the same value on all processes.
GO minIndexBase = indexBase;
reduceAll (*comm, REDUCE_MIN, indexBase, ptr (&minIndexBase));
GO maxIndexBase = indexBase;
reduceAll (*comm, REDUCE_MAX, indexBase, ptr (&maxIndexBase));
TEUCHOS_TEST_FOR_EXCEPTION(minIndexBase != maxIndexBase || minIndexBase != indexBase,
std::logic_error, "Index base values do not match on all processes. "
"Min value is " << minIndexBase << " and max value is " << maxIndexBase
<< ".");
// Create the Map.
RCP<const MT> map =
rcp (new Tpetra::Map<LO, GO, NT> (globalNumRows, indexBase, comm,
Tpetra::GloballyDistributed, node));
try {
RCP<MV> X3 =
testReadDenseFileWithInputMap<MV> (inputFilename, tmpFilename,
map, tolerant, verbose, debug);
if (outFilename != "") {
testWriteDenseFile<MV> (outFilename, X3, echo, verbose, debug);
}
} catch (std::exception& e) {
failedTests.push_back (testNum);
if (myRank == 0) {
cerr << "Test " << testNum << " failed: " << e.what() << endl;
}
if (stopAfterFailure) {
if (failedTests.size() > 0) {
if (myRank == 0) {
cout << "End Result: TEST FAILED" << endl;
}
return EXIT_FAILURE;
}
else {
if (myRank == 0) {
cout << "End Result: TEST PASSED" << endl;
}
return EXIT_SUCCESS;
}
} // if stop after failure
}
}
++testNum;
if ((testToRun == 0 && testNoncontiguousInputMap) ||
(testToRun != 0 && testToRun == testNum)) {
// Test 5: nonnull input Map with the same index base as X's
// Map, and a "noncontiguous" distribution (in the sense that
// the Map is constructed using the constructor that takes an
// arbitrary list of GIDs; that doesn't necessarily mean that
// the GIDs themselves are noncontiguous).
if (verbose && myRank == 0) {
cout << "Test " << testNum << ": Nonnull noncontiguous Map (same index "
"base) on input to readDenseFile()" << endl;
}
const GO indexBase = X->getMap()->getIndexBase();
const Tpetra::global_size_t globalNumRows = X->getMap()->getGlobalNumElements();
// Compute number of GIDs owned by each process. We're
// replicating Tpetra functionality here because we want to
// trick Tpetra into thinking we have a noncontiguous
// distribution. This is the most general case and the most
// likely to uncover bugs.
const size_t quotient = globalNumRows / numProcs;
const size_t remainder = globalNumRows - quotient * numProcs;
const size_t localNumRows = (as<size_t> (myRank) < remainder) ?
(quotient + 1) : quotient;
// Build the list of GIDs owned by this process.
Array<GO> elementList (localNumRows);
GO myStartGID;
if (as<size_t> (myRank) < remainder) {
myStartGID = indexBase + as<GO> (myRank) * as<GO> (quotient + 1);
}
else {
// This branch does _not_ assume that GO is a signed type.
myStartGID = indexBase + as<GO> (remainder) * as<GO> (quotient + 1) +
(as<GO> (myRank) - as<GO> (remainder)) * as<GO> (quotient);
}
for (GO i = 0; i < as<GO> (localNumRows); ++i) {
elementList[i] = myStartGID + i;
}
if (debug) {
for (int p = 0; p < numProcs; ++p) {
if (p == myRank) {
if (elementList.size() > 0) {
const GO minGID = *std::min_element (elementList.begin(), elementList.end());
const GO maxGID = *std::max_element (elementList.begin(), elementList.end());
cerr << "On Proc " << p << ": min,max GID = " << minGID << "," << maxGID << endl;
}
else {
cerr << "On Proc " << p << ": elementList is empty" << endl;
}
cerr << std::flush;
}
comm->barrier ();
comm->barrier ();
comm->barrier ();
}
}
// Create the Map.
using Tpetra::createNonContigMapWithNode;
RCP<const MT> map =
createNonContigMapWithNode<LO, GO, NT> (elementList(), comm, node);
try {
RCP<MV> X4 = testReadDenseFileWithInputMap<MV> (inputFilename, tmpFilename,
map, tolerant, verbose, debug);
if (outFilename != "") {
testWriteDenseFile<MV> (outFilename, X4, echo, verbose, debug);
}
} catch (std::exception& e) {
failedTests.push_back (testNum);
if (myRank == 0) {
cerr << "Test " << testNum << " failed: " << e.what() << endl;
}
if (stopAfterFailure) {
if (failedTests.size() > 0) {
if (myRank == 0) {
cout << "End Result: TEST FAILED" << endl;
}
return EXIT_FAILURE;
}
else {
if (myRank == 0) {
cout << "End Result: TEST PASSED" << endl;
}
return EXIT_SUCCESS;
}
} // if stop after failure
}
} // if test noncontiguous input Map
++testNum;
if ((testToRun == 0 && testNoncontiguousInputMap && testDifferentIndexBase) ||
(testToRun != 0 && testToRun == testNum)) {
// Test 6: nonnull input Map with a different index base than
// X's Map, and a "noncontiguous" distribution (in the sense
// that the Map is constructed using the constructor that takes
// an arbitrary list of GIDs; that doesn't necessarily mean that
// the GIDs themselves are noncontiguous).
if (verbose && myRank == 0) {
cout << "Test " << testNum << ": Nonnull noncontiguous Map (different "
"index base) on input to readDenseFile()" << endl;
}
// Make sure that the global ordinal sets of X->getMap() and
// map don't overlap.
GO indexBase = X->getMap()->getMaxAllGlobalIndex() + 1;
const Tpetra::global_size_t globalNumRows = X->getMap()->getGlobalNumElements();
// Compute number of GIDs owned by each process. We're
// replicating Tpetra functionality here because we want to
// trick Tpetra into thinking we have a noncontiguous
// distribution. This is the most general case and the most
// likely to uncover bugs.
const size_t quotient = globalNumRows / numProcs;
const size_t remainder = globalNumRows - quotient * numProcs;
const size_t localNumRows = (as<size_t> (myRank) < remainder) ?
(quotient + 1) : quotient;
// Build the list of GIDs owned by this process.
Array<GO> elementList (localNumRows);
GO myStartGID;
if (as<size_t> (myRank) < remainder) {
myStartGID = indexBase + as<GO> (myRank) * as<GO> (quotient + 1);
}
else {
// This branch does _not_ assume that GO is a signed type.
myStartGID = indexBase + as<GO> (remainder) * as<GO> (quotient + 1) +
(as<GO> (remainder) - as<GO> (myRank)) * as<GO> (quotient);
}
for (GO i = 0; i < as<GO> (localNumRows); ++i) {
elementList[i] = myStartGID + i;
}
// Create the Map.
using Tpetra::createNonContigMapWithNode;
RCP<const MT> map =
createNonContigMapWithNode<LO, GO, NT> (elementList(), comm, node);
try {
RCP<MV> X5 = testReadDenseFileWithInputMap<MV> (inputFilename, tmpFilename,
map, tolerant, verbose, debug);
if (outFilename != "") {
testWriteDenseFile<MV> (outFilename, X5, echo, verbose, debug);
}
} catch (std::exception& e) {
failedTests.push_back (testNum);
if (myRank == 0) {
cerr << "Test " << testNum << " failed: " << e.what() << endl;
}
if (stopAfterFailure) {
if (failedTests.size() > 0) {
if (myRank == 0) {
cout << "End Result: TEST FAILED" << endl;
}
return EXIT_FAILURE;
}
else {
if (myRank == 0) {
cout << "End Result: TEST PASSED" << endl;
}
return EXIT_SUCCESS;
}
} // if stop after failure
}
} // if test noncontiguous input Map
++testNum;
if ((testToRun == 0 && testNoncontiguousInputMap) ||
(testToRun != 0 && testToRun == testNum)) {
// Test 7: nonnull input Map with the same index base as X's
// Map, and a "noncontiguous" distribution with GIDs that start
// at 3. This lets us easily observe any missing entries after
// writing X and reading it back in again.
if (verbose && myRank == 0) {
cout << "Test " << testNum << ": Nonnull noncontiguous Map (same index "
"base, GIDs not in 0 .. N-1) on input to readDenseFile()" << endl;
}
const Tpetra::global_size_t globalNumRows = X->getMap()->getGlobalNumElements();
const GO globalStartGID = as<GO> (3);
// Compute number of GIDs owned by each process. We're
// replicating Tpetra functionality here because we want to
// trick Tpetra into thinking we have a noncontiguous
// distribution. This is the most general case and the most
// likely to uncover bugs.
const size_t quotient = globalNumRows / numProcs;
const size_t remainder = globalNumRows - quotient * numProcs;
const size_t localNumRows = (as<size_t> (myRank) < remainder) ?
(quotient + 1) : quotient;
// Build the list of GIDs owned by this process.
Array<GO> elementList (localNumRows);
GO myStartGID;
if (as<size_t> (myRank) < remainder) {
myStartGID = globalStartGID + as<GO> (myRank) * as<GO> (quotient + 1);
}
else {
// This branch does _not_ assume that GO is a signed type.
myStartGID = globalStartGID + as<GO> (remainder) * as<GO> (quotient + 1) +
(as<GO> (myRank) - as<GO> (remainder)) * as<GO> (quotient);
}
for (GO i = 0; i < as<GO> (localNumRows); ++i) {
elementList[i] = myStartGID + i;
}
if (debug) {
for (int p = 0; p < numProcs; ++p) {
if (p == myRank) {
if (elementList.size() > 0) {
const GO minGID = *std::min_element (elementList.begin(), elementList.end());
const GO maxGID = *std::max_element (elementList.begin(), elementList.end());
cerr << "On Proc " << p << ": min,max GID = " << minGID << "," << maxGID << endl;
}
else {
cerr << "On Proc " << p << ": elementList is empty" << endl;
}
cerr << std::flush;
}
comm->barrier ();
comm->barrier ();
comm->barrier ();
}
}
// Create the Map.
using Tpetra::createNonContigMapWithNode;
RCP<const MT> map =
createNonContigMapWithNode<LO, GO, NT> (elementList(), comm, node);
try {
RCP<MV> X7 = testReadDenseFileWithInputMap<MV> (inputFilename, tmpFilename,
map, tolerant, verbose, debug);
if (outFilename != "") {
testWriteDenseFile<MV> (outFilename, X7, echo, verbose, debug);
}
} catch (std::exception& e) {
failedTests.push_back (testNum);
if (myRank == 0) {
cerr << "Test " << testNum << " failed: " << e.what() << endl;
}
if (stopAfterFailure) {
if (failedTests.size() > 0) {
if (myRank == 0) {
cout << "End Result: TEST FAILED" << endl;
}
return EXIT_FAILURE;
}
else {
if (myRank == 0) {
cout << "End Result: TEST PASSED" << endl;
}
return EXIT_SUCCESS;
}
} // if stop after failure
}
} // if test noncontiguous input Map
}
if (failedTests.size() > 0) {
if (myRank == 0) {
cout << "End Result: TEST FAILED" << endl;
}
return EXIT_FAILURE;
}
else {
if (myRank == 0) {
cout << "End Result: TEST PASSED" << endl;
}
return EXIT_SUCCESS;
}
}
int main(int argc, char* argv[])
{
using Teuchos::CommandLineProcessor;
bool success = true;
bool verbose = true;
Teuchos::GlobalMPISession mpiSession(&argc, &argv);
Teuchos::RCP<Teuchos::FancyOStream>
out = Teuchos::VerboseObjectBase::getDefaultOStream();
try {
//
// Read options from command-line
//
std::string matrixFile = "";
bool testTranspose = false;
bool usePreconditioner = false;
int numRhs = 1;
int numRandomVectors = 1;
double maxFwdError = 1e-14;
int maxIterations = 400;
int outputFrequency = 10;
bool outputMaxResOnly = true;
double maxResid = 1e-6;
double maxSolutionError = 1e-6;
bool showAllTests = false;
bool dumpAll = false;
double weightCutoff = 1e-4;
int mcCheckFrequency = 1024;
int mcBufferSize = 1024;
bool reproducibleMC = true;
int overlapSize = 0;
int numSets = 1;
double sampleRatio = 10.0;
std::string mcType = "Adjoint";
int blockSize = 1;
std::string solverType = "MCSA";
std::string precType = "Point Jacobi";
double dropTol = 1.0e-2;
double fillLevel = 1.5;
double richardsonRelax = 1.0;
CommandLineProcessor clp;
clp.throwExceptions(false);
clp.addOutputSetupOptions(true);
clp.setOption( "matrix-file", &matrixFile, "Matrix input file [Required]." );
clp.setOption( "test-transpose", "no-test-transpose", &testTranspose, "Test the transpose solve or not." );
clp.setOption( "use-preconditioner", "no-use-preconditioner", &usePreconditioner, "Use the preconditioner or not." );
clp.setOption( "num-rhs", &numRhs, "Number of RHS in linear solve." );
clp.setOption( "num-random-vectors", &numRandomVectors, "Number of times a test is performed with different random vectors." );
clp.setOption( "max-fwd-error", &maxFwdError, "The maximum relative error in the forward operator." );
clp.setOption( "max-iters", &maxIterations, "The maximum number of linear solver iterations to take." );
clp.setOption( "output-frequency", &outputFrequency, "Number of linear solver iterations between output" );
clp.setOption( "output-max-res-only", "output-all-res", &outputMaxResOnly,
"Determines if only the max residual is printed or if all residuals are printed per iteration." );
clp.setOption( "max-resid", &maxResid, "The maximum relative error in the residual." );
clp.setOption( "max-solution-error", &maxSolutionError, "The maximum relative error in the solution of the linear system." );
clp.setOption( "verbose", "quiet", &verbose, "Set if output is printed or not." );
clp.setOption( "show-all-tests", "no-show-all-tests", &showAllTests, "Set if all the tests are shown or not." );
clp.setOption( "dump-all", "no-dump-all", &dumpAll, "Determines if vectors are printed or not." );
clp.setOption( "mc-type", &mcType, "Determines underlying MC type in solver." );
clp.setOption( "mc-cutoff", &weightCutoff, "Determines underlying MC history weight cutoff." );
clp.setOption( "mc-frequency", &mcCheckFrequency, "Determines the frequency of MC communications." );
clp.setOption( "mc-buffer-size", &mcBufferSize, "Determines the size of MC history buffers." );
clp.setOption( "mc-reproduce", "reproducible", &reproducibleMC,
"Determines whether or not to communicate RNG with MC histories." );
clp.setOption( "mc-overlap", &overlapSize, "Determines the size of overlap in MC problem." );
clp.setOption( "mc-sets", &numSets, "Determines the number of sets in the MC problem." );
clp.setOption( "mc-sample-ratio", &sampleRatio, "Determines the number of histories in the MC problem." );
clp.setOption( "block-size", &blockSize, "Block Jacobi preconditioning block size." );
clp.setOption( "solver-type", &solverType, "Determines MCLS solver." );
clp.setOption( "prec-type", &precType, "Determines MCLS preconditioner." );
clp.setOption( "drop-tol", &dropTol, "ILUT drop tolerance." );
clp.setOption( "fill-level", &fillLevel, "ILUT level-of-fill." );
clp.setOption( "rich-relax", &richardsonRelax, "Richardson relaxation parameter." );
CommandLineProcessor::EParseCommandLineReturn parse_return = clp.parse(argc,argv);
if( parse_return != CommandLineProcessor::PARSE_SUCCESSFUL ) return parse_return;
TEUCHOS_TEST_FOR_EXCEPT( matrixFile == "" );
Teuchos::ParameterList mclsLOWSFPL;
mclsLOWSFPL.set("Solver Type", solverType);
Teuchos::ParameterList& mclsLOWSFPL_solver =
mclsLOWSFPL.sublist("Solver Types");
Teuchos::ParameterList& mclsLOWSFPL_mcsa =
mclsLOWSFPL_solver.sublist("MCSA");
mclsLOWSFPL_mcsa.set("Maximum Iterations",int(maxIterations));
mclsLOWSFPL_mcsa.set("Convergence Tolerance",double(maxResid));
mclsLOWSFPL_mcsa.set("MC Type",std::string(mcType));
mclsLOWSFPL_mcsa.set("Iteration Print Frequency",int(outputFrequency));
mclsLOWSFPL_mcsa.set("Weight Cutoff",double(weightCutoff));
mclsLOWSFPL_mcsa.set("MC Check Frequency",int(mcCheckFrequency));
mclsLOWSFPL_mcsa.set("MC Buffer Size",int(mcBufferSize));
mclsLOWSFPL_mcsa.set("Reproducible MC Mode",bool(reproducibleMC));
mclsLOWSFPL_mcsa.set("Overlap Size",int(overlapSize));
mclsLOWSFPL_mcsa.set("Number of Sets",int(numSets));
mclsLOWSFPL_mcsa.set("Sample Ratio", double(sampleRatio));
mclsLOWSFPL_mcsa.set("Transport Type","Global");
Teuchos::ParameterList& mclsLOWSFPL_adjmc =
mclsLOWSFPL_solver.sublist("Adjoint MC");
mclsLOWSFPL_adjmc.set("Convergence Tolerance",double(maxResid));
mclsLOWSFPL_adjmc.set("Weight Cutoff",double(weightCutoff));
mclsLOWSFPL_adjmc.set("MC Check Frequency",int(mcCheckFrequency));
mclsLOWSFPL_adjmc.set("MC Buffer Size",int(mcBufferSize));
mclsLOWSFPL_adjmc.set("Reproducible MC Mode",bool(reproducibleMC));
mclsLOWSFPL_adjmc.set("Overlap Size",int(overlapSize));
mclsLOWSFPL_adjmc.set("Number of Sets",int(numSets));
mclsLOWSFPL_adjmc.set("Sample Ratio", double(sampleRatio));
mclsLOWSFPL_adjmc.set("Transport Type","Global");
Teuchos::ParameterList& mclsLOWSFPL_fwdmc =
mclsLOWSFPL_solver.sublist("Forward MC");
mclsLOWSFPL_fwdmc.set("Convergence Tolerance",double(maxResid));
mclsLOWSFPL_fwdmc.set("Weight Cutoff",double(weightCutoff));
mclsLOWSFPL_fwdmc.set("MC Check Frequency",int(mcCheckFrequency));
mclsLOWSFPL_fwdmc.set("MC Buffer Size",int(mcBufferSize));
mclsLOWSFPL_fwdmc.set("Reproducible MC Mode",bool(reproducibleMC));
mclsLOWSFPL_fwdmc.set("Overlap Size",int(overlapSize));
mclsLOWSFPL_fwdmc.set("Number of Sets",int(numSets));
mclsLOWSFPL_fwdmc.set("Sample Ratio", double(sampleRatio));
mclsLOWSFPL_fwdmc.set("Transport Type","Global");
Teuchos::ParameterList& mclsLOWSFPL_richardson =
mclsLOWSFPL_solver.sublist("Fixed Point");
mclsLOWSFPL_richardson.set("Maximum Iterations",int(maxIterations));
mclsLOWSFPL_richardson.set("Convergence Tolerance",double(maxResid));
mclsLOWSFPL_richardson.set("Iteration Print Frequency",int(outputFrequency));
mclsLOWSFPL_richardson.set("Richardson Relaxation",double(richardsonRelax));
Teuchos::ParameterList precPL("MCLS");
if(usePreconditioner)
{
precPL.set("Preconditioner Type",precType);
Teuchos::ParameterList& precPL_prec = precPL.sublist("Preconditioner Types");
Teuchos::ParameterList& precPL_bj = precPL_prec.sublist("Block Jacobi");
precPL_bj.set("Jacobi Block Size", blockSize);
Teuchos::ParameterList& precPL_ilut = precPL_prec.sublist("ILUT");
precPL_ilut.set("fact: drop tolerance", dropTol);
precPL_ilut.set("fact: ilut level-of-fill", fillLevel);
}
success
= Thyra::test_single_mcls_thyra_solver(
matrixFile,testTranspose,usePreconditioner,numRhs,numRandomVectors
,maxFwdError,maxResid,maxSolutionError,showAllTests,dumpAll
,&mclsLOWSFPL,&precPL
,verbose?&*out:0
);
}
TEUCHOS_STANDARD_CATCH_STATEMENTS(verbose, std::cerr, success)
if (verbose) {
if(success) *out << "\nCongratulations! All of the tests checked out!\n";
else *out << "\nOh no! At least one of the tests failed!\n";
}
return ( success ? 0 : 1 );
}
int main(int argc, char *argv[])
{
using std::endl;
using Teuchos::RCP;
using Teuchos::rcp;
using Teuchos::ParameterList;
using Teuchos::CommandLineProcessor;
bool result, success = true;
Teuchos::GlobalMPISession mpiSession(&argc,&argv);
RCP<Epetra_Comm> epetra_comm;
#ifdef HAVE_MPI
epetra_comm = rcp( new Epetra_MpiComm(MPI_COMM_WORLD) );
#else
epetra_comm = rcp( new Epetra_SerialComm );
#endif // HAVE_MPI
RCP<Teuchos::FancyOStream>
out = Teuchos::VerboseObjectBase::getDefaultOStream();
try {
//
// Read commandline options
//
CommandLineProcessor clp;
clp.throwExceptions(false);
clp.addOutputSetupOptions(true);
Teuchos::EVerbosityLevel verbLevel = Teuchos::VERB_DEFAULT;
setVerbosityLevelOption( "verb-level", &verbLevel,
"Top-level verbosity level. By default, this gets deincremented as you go deeper into numerical objects.",
&clp );
bool dumpFinalSolutions = false;
clp.setOption(
"dump-final-solutions", "no-dump-final-solutions", &dumpFinalSolutions,
"Determine if the final solutions are dumpped or not." );
CommandLineProcessor::EParseCommandLineReturn parse_return = clp.parse(argc,argv);
if( parse_return != CommandLineProcessor::PARSE_SUCCESSFUL ) return parse_return;
if ( Teuchos::VERB_DEFAULT == verbLevel )
verbLevel = Teuchos::VERB_LOW;
const Teuchos::EVerbosityLevel
solnVerbLevel = ( dumpFinalSolutions ? Teuchos::VERB_EXTREME : verbLevel );
//
// Get the base parameter list that all other parameter lists will be read
// from.
//
RCP<ParameterList>
paramList = Teuchos::parameterList();
//
// Create the underlying EpetraExt::ModelEvaluator
//
RCP<LorenzModel>
lorenzModel = rcp(new LorenzModel( epetra_comm, *paramList ));
//
// Create the Thyra-wrapped ModelEvaluator
//
RCP<Thyra::ModelEvaluator<double> >
thyraLorenzModel = Thyra::epetraModelEvaluator(lorenzModel,Teuchos::null);
//
// Create the Rythmos GAASP ErrorEstimator
//
RCP<Rythmos::GAASPErrorEstimator> gaaspEE = rcp(new Rythmos::GAASPErrorEstimator);
gaaspEE->setModel(thyraLorenzModel);
//gaaspEE->setQuantityOfInterest( AVERAGE_ERROR_QTY ); // Not passed through yet.
Teuchos::RCP<Teuchos::ParameterList> pl = Teuchos::parameterList();
pl->sublist("GAASP Interface Parameters").set<double>("eTime",1.0);
pl->sublist("GAASP Interface Parameters").set<double>("timeStep",0.1);
//pl->sublist("GAASP Interface Parameters").set<double>("timeStep",0.5);
gaaspEE->setParameterList(pl);
//RCP<const Rythmos::ErrorEstimateBase<double> > error = gaaspEE->getErrorEstimate();
//double uTOL = 1.0e-8;
double uTOL = 1.0e-2;
RCP<const Rythmos::ErrorEstimateBase<double> > error = gaaspEE->controlGlobalError(uTOL);
double err = error->getTotalError();
out->precision(15);
*out << "err = " << err << std::endl;
}
TEUCHOS_STANDARD_CATCH_STATEMENTS(true,*out,success);
// if(success)
// *out << "\nEnd Result: TEST PASSED" << endl;
// else
// *out << "\nEnd Result: TEST FAILED" << endl;
return ( success ? 0 : 1 );
} // end main() [Doxygen looks for this!]
int main(int argc, char *argv[])
{
using std::endl;
typedef double Scalar;
typedef double ScalarMag;
using Teuchos::describe;
using Teuchos::RCP;
using Teuchos::rcp;
using Teuchos::rcp_implicit_cast;
using Teuchos::rcp_dynamic_cast;
using Teuchos::as;
using Teuchos::ParameterList;
using Teuchos::CommandLineProcessor;
typedef Teuchos::ParameterList::PrintOptions PLPrintOptions;
typedef Thyra::ModelEvaluatorBase MEB;
using Thyra::createMember;
using Thyra::createMembers;
bool success = true;
Teuchos::GlobalMPISession mpiSession(&argc,&argv);
RCP<Epetra_Comm> epetra_comm;
#ifdef HAVE_MPI
epetra_comm = rcp( new Epetra_MpiComm(MPI_COMM_WORLD) );
#else
epetra_comm = rcp( new Epetra_SerialComm );
#endif // HAVE_MPI
RCP<Teuchos::FancyOStream>
out = Teuchos::VerboseObjectBase::getDefaultOStream();
try {
//
// A) Read commandline options
//
CommandLineProcessor clp;
clp.throwExceptions(false);
clp.addOutputSetupOptions(true);
std::string paramsFileName = "";
clp.setOption( "params-file", ¶msFileName,
"File name for XML parameters" );
std::string extraParamsString = "";
clp.setOption( "extra-params", &extraParamsString,
"Extra XML parameter string" );
Teuchos::EVerbosityLevel verbLevel = Teuchos::VERB_DEFAULT;
setVerbosityLevelOption( "verb-level", &verbLevel,
"Top-level verbosity level. By default, this gets deincremented as you go deeper into numerical objects.",
&clp );
double finalTime = 1.0;
clp.setOption( "final-time", &finalTime, "Final time (the inital time)" );
int numTimeSteps = 2;
clp.setOption( "num-time-steps", &numTimeSteps, "Number of time steps" );
bool dumpFinalSolutions = false;
clp.setOption(
"dump-final-solutions", "no-dump-final-solutions", &dumpFinalSolutions,
"Determine if the final solutions are dumpped or not." );
double maxStateError = 1e-6;
clp.setOption( "max-state-error", &maxStateError,
"The maximum allowed error in the integrated state in relation to the exact state solution" );
// ToDo: Read in more parameters
CommandLineProcessor::EParseCommandLineReturn parse_return = clp.parse(argc,argv);
if( parse_return != CommandLineProcessor::PARSE_SUCCESSFUL ) return parse_return;
if ( Teuchos::VERB_DEFAULT == verbLevel )
verbLevel = Teuchos::VERB_LOW;
const Teuchos::EVerbosityLevel
solnVerbLevel = ( dumpFinalSolutions ? Teuchos::VERB_EXTREME : verbLevel );
//
// B) Get the base parameter list that all other parameter lists will be
// read from.
//
RCP<ParameterList> paramList = Teuchos::parameterList();
if (paramsFileName.length())
updateParametersFromXmlFile( paramsFileName, &*paramList );
if (extraParamsString.length())
updateParametersFromXmlString( extraParamsString, &*paramList );
paramList->validateParameters(*getValidParameters());
//
// C) Create the Stratimikos linear solver factories.
//
// Get the linear solve strategy that will be used to solve for the linear
// system with the dae's W matrix.
Stratimikos::DefaultLinearSolverBuilder daeLinearSolverBuilder;
daeLinearSolverBuilder.setParameterList(sublist(paramList,DAELinearSolver_name));
RCP<Thyra::LinearOpWithSolveFactoryBase<Scalar> >
daeLOWSF = createLinearSolveStrategy(daeLinearSolverBuilder);
// Get the linear solve strategy that can be used to override the overall
// linear system solve
Stratimikos::DefaultLinearSolverBuilder overallLinearSolverBuilder;
overallLinearSolverBuilder.setParameterList(sublist(paramList,OverallLinearSolver_name));
RCP<Thyra::LinearOpWithSolveFactoryBase<Scalar> >
overallLOWSF = createLinearSolveStrategy(overallLinearSolverBuilder);
//
// D) Create the underlying EpetraExt::ModelEvaluator
//
RCP<EpetraExt::DiagonalTransientModel> epetraDaeModel =
EpetraExt::diagonalTransientModel(
epetra_comm,
sublist(paramList,DiagonalTransientModel_name)
);
*out <<"\nepetraDaeModel valid options:\n";
epetraDaeModel->getValidParameters()->print(
*out, PLPrintOptions().indent(2).showTypes(true).showDoc(true)
);
//
// E) Create the Thyra-wrapped ModelEvaluator
//
RCP<Thyra::ModelEvaluator<double> > daeModel =
epetraModelEvaluator(epetraDaeModel,daeLOWSF);
//
// F) Create the TimeDiscretizedBackwardEulerModelEvaluator
//
MEB::InArgs<Scalar> initCond = daeModel->createInArgs();
initCond.setArgs(daeModel->getNominalValues());
RCP<Thyra::ModelEvaluator<Scalar> >
discretizedModel = Rythmos::timeDiscretizedBackwardEulerModelEvaluator<Scalar>(
daeModel, initCond, finalTime, numTimeSteps, overallLOWSF );
*out << "\ndiscretizedModel = " << describe(*discretizedModel,verbLevel);
//
// F) Setup a nonlinear solver and solve the system
//
// F.1) Setup a nonlinear solver
Thyra::DampenedNewtonNonlinearSolver<Scalar> nonlinearSolver;
nonlinearSolver.setOStream(out);
nonlinearSolver.setVerbLevel(verbLevel);
//nonlinearSolver.setParameterList(sublist(paramList,NonlinearSolver_name));
//2007/11/27: rabartl: ToDo: Implement parameter list handling for
//DampenedNonlinearSolve so that I can uncomment the above line.
nonlinearSolver.setModel(discretizedModel);
// F.2) Solve the system
RCP<Thyra::VectorBase<Scalar> >
x_bar = createMember(discretizedModel->get_x_space());
V_S( x_bar.ptr(), 0.0 );
Thyra::SolveStatus<Scalar> solveStatus =
Thyra::solve( nonlinearSolver, &*x_bar );
*out << "\nsolveStatus:\n" << solveStatus;
*out << "\nx_bar = " << describe(*x_bar,solnVerbLevel);
//
// G) Verify that the solution is correct???
//
// Check against the end time exact solution.
RCP<const Thyra::VectorBase<Scalar> >
exact_x_final = Thyra::create_Vector(
epetraDaeModel->getExactSolution(finalTime),
daeModel->get_x_space()
);
RCP<const Thyra::VectorBase<Scalar> > solved_x_final
= rcp_dynamic_cast<Thyra::ProductVectorBase<Scalar> >(x_bar,true)->getVectorBlock(numTimeSteps-1);
const bool result = Thyra::testRelNormDiffErr(
"exact_x_final", *exact_x_final, "solved_x_final", *solved_x_final,
"maxStateError", maxStateError, "warningTol", 1.0, // Don't warn
&*out, solnVerbLevel
);
if (!result) success = false;
}
TEUCHOS_STANDARD_CATCH_STATEMENTS(true,*out,success);
if(success)
*out << "\nEnd Result: TEST PASSED" << endl;
else
*out << "\nEnd Result: TEST FAILED" << endl;
return ( success ? 0 : 1 );
} // end main() [Doxygen looks for this!]
int main(int argc, char *argv[])
{
#ifdef HAVE_MPI
MPI_Init(&argc,&argv);
Epetra_MpiComm Comm(MPI_COMM_WORLD);
#else
Epetra_SerialComm Comm;
#endif
CommandLineProcessor CLP;
int n = 10;
int m = (int)pow((double)Comm.NumProc(), 0.3334);
double DampingFactor = 1.333;
std::string AggregationScheme = "Uncoupled";
int NPA = 16;
int MaxLevels = 5;
CLP.setOption("l", &MaxLevels, "number of levels");
CLP.setOption("n", &n, "number of nodes along each axis");
CLP.setOption("damp", &DampingFactor, "prolongator damping factor");
CLP.setOption("aggr", &AggregationScheme, "aggregation scheme");
CLP.setOption("npa", &NPA, "nodes per aggregate (if supported by the aggregation scheme)");
CLP.throwExceptions(false);
CLP.parse(argc,argv);
if (m * m * m != Comm.NumProc()) {
if (Comm.MyPID() == 0)
{
std::cout << "Number of processes must be a perfect cube." << std::endl;
std::cout << "Please re-run with --help option for details." << std::endl;
}
#ifdef HAVE_MPI
MPI_Finalize();
#endif
exit(EXIT_SUCCESS);
}
n *= m;
Laplace3D A(Comm, n, n, n, m, m, m, true);
Epetra_Vector LHS(A.OperatorDomainMap());
Epetra_Vector RHS(A.OperatorDomainMap());
LHS.Random();
RHS.PutScalar(0.0);
Epetra_LinearProblem Problem(&A, &LHS, &RHS);
// Construct a solver object for this problem
AztecOO solver(Problem);
// create a parameter list for ML options
ParameterList MLList;
// set defaults for classic smoothed aggregation
ML_Epetra::SetDefaults("SA",MLList);
// overwrite some parameters. Please refer to the user's guide
// for more information
MLList.set("max levels",MaxLevels);
MLList.set("increasing or decreasing","increasing");
MLList.set("aggregation: type", AggregationScheme);
MLList.set("aggregation: damping factor", DampingFactor);
MLList.set("aggregation: nodes per aggregate", NPA);
MLList.set("smoother: type","symmetric Gauss-Seidel");
MLList.set("smoother: pre or post", "both");
MLList.set("coarse: max size", 512);
MLList.set("coarse: type","Amesos-KLU");
MLList.set("analyze memory", true);
MLList.set("repartition: enable", true);
MLList.set("repartition: max min ratio", 1.1);
MLList.set("repartition: min per proc", 512);
MLList.set("low memory usage", true);
MLList.set("x-coordinates", (double*) A.XCoord());
MLList.set("y-coordinates", (double*) A.YCoord());
MLList.set("z-coordinates", (double*) A.ZCoord());
// create the preconditioner object and compute hierarchy
MultiLevelPreconditioner* MLPrec = new MultiLevelPreconditioner(A, MLList);
// tell AztecOO to use this preconditioner, then solve
solver.SetPrecOperator(MLPrec);
solver.SetAztecOption(AZ_solver, AZ_cg_condnum);
solver.SetAztecOption(AZ_output, 1);
solver.Iterate(500, 1e-10);
delete MLPrec;
double norm;
LHS.Norm2(&norm);
if (Comm.MyPID() == 0)
std::cout << "Norm of the error = " << norm << std::endl;
#ifdef HAVE_MPI
MPI_Finalize() ;
#endif
exit(EXIT_SUCCESS);
}
int
main (int argc, char *argv[])
{
using Teuchos::ArrayRCP;
using Teuchos::ArrayView;
using Teuchos::Comm;
using Teuchos::CommandLineProcessor;
using Teuchos::FancyOStream;
using Teuchos::getFancyOStream;
using Teuchos::OSTab;
using Teuchos::ptr;
using Teuchos::RCP;
using Teuchos::rcp;
using Teuchos::rcpFromRef;
using std::cout;
using std::endl;
bool success = true; // May be changed by tests
Teuchos::oblackholestream blackHole;
//Teuchos::GlobalMPISession (&argc, &argv, &blackHole);
MPI_Init (&argc, &argv);
//
// Construct communicators, and verify that we are on 4 processors.
//
// Construct a Teuchos Comm object.
RCP<const Comm<int> > teuchosComm = Teuchos::DefaultComm<int>::getComm();
const int numProcs = teuchosComm->getSize();
const int pid = teuchosComm->getRank();
RCP<FancyOStream> pOut =
getFancyOStream (rcpFromRef ((pid == 0) ? std::cout : blackHole));
FancyOStream& out = *pOut;
// Verify that we are on four processors (which manifests the bug).
if (teuchosComm->getSize() != 4) {
out << "This test must be run on four processors. Exiting ..." << endl;
return EXIT_FAILURE;
}
// We also need an Epetra Comm, so that we can compare Tpetra and
// Epetra results.
Epetra_MpiComm epetraComm (MPI_COMM_WORLD);
//
// Default values of command-line options.
//
bool verbose = false;
bool printEpetra = false;
bool printTpetra = false;
CommandLineProcessor cmdp (false,true);
//
// Set command-line options.
//
cmdp.setOption ("verbose", "quiet", &verbose, "Print verbose output.");
// Epetra and Tpetra output will ask the Maps and Import objects to
// print themselves in distributed, maximally verbose fashion. It's
// best to turn on either Epetra or Tpetra, but not both. Then you
// can compare their output side by side.
cmdp.setOption ("printEpetra", "dontPrintEpetra", &printEpetra,
"Print Epetra output (in verbose mode only).");
cmdp.setOption ("printTpetra", "dontPrintTpetra", &printTpetra,
"Print Tpetra output (in verbose mode only).");
// Parse command-line options.
if (cmdp.parse (argc,argv) != CommandLineProcessor::PARSE_SUCCESSFUL) {
out << "End Result: TEST FAILED" << endl;
MPI_Finalize ();
return EXIT_FAILURE;
}
if (verbose) {
out << "Running test on " << numProcs << " process"
<< (numProcs != 1 ? "es" : "") << "." << endl;
}
// The maps for this problem are derived from a 3D structured mesh.
// In this example, the dimensions are 4x4x2 and there are 2
// processors assigned to the first dimension and 2 processors
// assigned to the second dimension, with no parallel decomposition
// along the third dimension. The "owned" arrays represent the
// one-to-one map, with each array representing a 2x2x2 slice. If
// DIMENSIONS == 2, then only the first 4 values will be used,
// representing a 2x2(x1) slice.
int owned0[8] = { 0, 1, 4, 5,16,17,20,21};
int owned1[8] = { 2, 3, 6, 7,18,19,22,23};
int owned2[8] = { 8, 9,12,13,24,25,28,29};
int owned3[8] = {10,11,14,15,26,27,30,31};
// The "overlap" arrays represent the map with communication
// elements, with each array representing a 3x3x2 slice. If
// DIMENSIONS == 2, then only the first 9 values will be used,
// representing a 3x3(x1) slice.
int overlap0[18] = {0,1,2,4, 5, 6, 8, 9,10,16,17,18,20,21,22,24,25,26};
int overlap1[18] = {1,2,3,5, 6, 7, 9,10,11,17,18,19,21,22,23,25,26,27};
int overlap2[18] = {4,5,6,8, 9,10,12,13,14,20,21,22,24,25,26,28,29,30};
int overlap3[18] = {5,6,7,9,10,11,13,14,15,21,22,23,25,26,27,29,30,31};
// Construct the owned and overlap maps for both Epetra and Tpetra.
int* owned;
int* overlap;
if (pid == 0) {
owned = owned0;
overlap = overlap0;
}
else if (pid == 1) {
owned = owned1;
overlap = overlap1;
}
else if (pid == 2) {
owned = owned2;
overlap = overlap2;
}
else {
owned = owned3;
overlap = overlap3;
}
#if DIMENSIONS == 2
int ownedSize = 4;
int overlapSize = 9;
#elif DIMENSIONS == 3
int ownedSize = 8;
int overlapSize = 18;
#endif
// Create the two Epetra Maps. Source for the Import is the owned
// map; target for the Import is the overlap map.
Epetra_Map epetraOwnedMap ( -1, ownedSize, owned, 0, epetraComm);
Epetra_Map epetraOverlapMap (-1, overlapSize, overlap, 0, epetraComm);
if (verbose && printEpetra) {
// Have the Epetra_Map objects describe themselves.
//
// Epetra_BlockMap::Print() takes an std::ostream&, and expects
// all MPI processes to be able to write to it. (The method
// handles its own synchronization.)
out << "Epetra owned map:" << endl;
epetraOwnedMap.Print (std::cout);
out << "Epetra overlap map:" << endl;
epetraOverlapMap.Print (std::cout);
}
// Create the two Tpetra Maps. The "invalid" global element count
// input tells Tpetra::Map to compute the global number of elements
// itself.
const int invalid = Teuchos::OrdinalTraits<int>::invalid();
RCP<Tpetra::Map<int> > tpetraOwnedMap =
rcp (new Tpetra::Map<int> (invalid, ArrayView<int> (owned, ownedSize),
0, teuchosComm));
tpetraOwnedMap->setObjectLabel ("Owned Map");
RCP<Tpetra::Map<int> > tpetraOverlapMap =
rcp (new Tpetra::Map<int> (invalid, ArrayView<int> (overlap, overlapSize),
0, teuchosComm));
tpetraOverlapMap->setObjectLabel ("Overlap Map");
// In verbose mode, have the Tpetra::Map objects describe themselves.
if (verbose && printTpetra) {
Teuchos::EVerbosityLevel verb = Teuchos::VERB_EXTREME;
// Tpetra::Map::describe() takes a FancyOStream, but expects all
// MPI processes to be able to write to it. (The method handles
// its own synchronization.)
RCP<FancyOStream> globalOut = getFancyOStream (rcpFromRef (std::cout));
out << "Tpetra owned map:" << endl;
{
OSTab tab (globalOut);
tpetraOwnedMap->describe (*globalOut, verb);
}
out << "Tpetra overlap map:" << endl;
{
OSTab tab (globalOut);
tpetraOverlapMap->describe (*globalOut, verb);
}
}
// Use the owned and overlap maps to construct an importer for both
// Epetra and Tpetra.
Epetra_Import epetraImporter (epetraOverlapMap, epetraOwnedMap );
Tpetra::Import<int> tpetraImporter (tpetraOwnedMap , tpetraOverlapMap);
// In verbose mode, have the Epetra_Import object describe itself.
if (verbose && printEpetra) {
out << "Epetra importer:" << endl;
// The importer's Print() method takes an std::ostream& and plans
// to write to it on all MPI processes (handling synchronization
// itself).
epetraImporter.Print (std::cout);
out << endl;
}
// In verbose mode, have the Tpetra::Import object describe itself.
if (verbose && printTpetra) {
out << "Tpetra importer:" << endl;
// The importer doesn't implement Teuchos::Describable. It wants
// std::cout and plans to write to it on all MPI processes (with
// its own synchronization).
tpetraImporter.print (std::cout);
out << endl;
}
// Construct owned and overlap vectors for both Epetra and Tpetra.
Epetra_Vector epetraOwnedVector (epetraOwnedMap );
Epetra_Vector epetraOverlapVector (epetraOverlapMap);
Tpetra::Vector<double,int> tpetraOwnedVector (tpetraOwnedMap );
Tpetra::Vector<double,int> tpetraOverlapVector (tpetraOverlapMap);
// The test is as follows: initialize the owned and overlap vectors
// with global IDs in the owned regions. Initialize the overlap
// vectors to equal -1 in the overlap regions. Then perform a
// communication from the owned vectors to the overlap vectors. The
// resulting overlap vectors should have global IDs everywhere and
// all of the -1 values should be overwritten.
// Initialize. We cannot assign directly to the Tpetra Vectors;
// instead, we extract nonconst views and assign to those. The
// results aren't guaranteed to be committed to the vector unless
// the views are released (by assigning Teuchos::null to them).
epetraOverlapVector.PutScalar(-1);
tpetraOverlapVector.putScalar(-1);
ArrayRCP<double> tpetraOwnedArray = tpetraOwnedVector.getDataNonConst(0);
ArrayRCP<double> tpetraOverlapArray = tpetraOverlapVector.getDataNonConst(0);
for (int owned_lid = 0;
owned_lid < tpetraOwnedMap->getNodeElementList().size();
++owned_lid) {
int gid = tpetraOwnedMap->getGlobalElement(owned_lid);
int overlap_lid = tpetraOverlapMap->getLocalElement(gid);
epetraOwnedVector[owned_lid] = gid;
epetraOverlapVector[overlap_lid] = gid;
tpetraOwnedArray[owned_lid] = gid;
tpetraOverlapArray[overlap_lid] = gid;
}
// Make sure that the changes to the Tpetra Vector were committed,
// by releasing the nonconst views.
tpetraOwnedArray = Teuchos::null;
tpetraOverlapArray = Teuchos::null;
// Test the Epetra and Tpetra Import.
if (verbose) {
out << "Testing Import from owned Map to overlap Map:" << endl << endl;
}
epetraOverlapVector.Import( epetraOwnedVector, epetraImporter, Insert);
tpetraOverlapVector.doImport(tpetraOwnedVector, tpetraImporter,
Tpetra::INSERT);
// Check the Import results.
success = countFailures (teuchosComm, epetraOwnedMap, epetraOwnedVector,
epetraOverlapMap, epetraOverlapVector,
tpetraOwnedMap, tpetraOwnedVector,
tpetraOverlapMap, tpetraOverlapVector, verbose);
const bool testOtherDirections = false;
if (testOtherDirections) {
//
// Reinitialize the Tpetra vectors and test whether Export works.
//
tpetraOverlapVector.putScalar(-1);
tpetraOwnedArray = tpetraOwnedVector.getDataNonConst(0);
tpetraOverlapArray = tpetraOverlapVector.getDataNonConst(0);
for (int owned_lid = 0;
owned_lid < tpetraOwnedMap->getNodeElementList().size();
++owned_lid)
{
int gid = tpetraOwnedMap->getGlobalElement(owned_lid);
int overlap_lid = tpetraOverlapMap->getLocalElement(gid);
tpetraOwnedArray[owned_lid] = gid;
tpetraOverlapArray[overlap_lid] = gid;
}
// Make sure that the changes to the Tpetra Vector were committed,
// by releasing the nonconst views.
tpetraOwnedArray = Teuchos::null;
tpetraOverlapArray = Teuchos::null;
// Make a Tpetra Export object, and test the export.
Tpetra::Export<int> tpetraExporter1 (tpetraOwnedMap, tpetraOverlapMap);
if (verbose) {
out << "Testing Export from owned Map to overlap Map:" << endl << endl;
}
tpetraOverlapVector.doExport (tpetraOwnedVector, tpetraExporter1,
Tpetra::INSERT);
// Check the Export results.
success = countFailures (teuchosComm, epetraOwnedMap, epetraOwnedVector,
epetraOverlapMap, epetraOverlapVector,
tpetraOwnedMap, tpetraOwnedVector,
tpetraOverlapMap, tpetraOverlapVector, verbose);
//
// Reinitialize the Tpetra vectors and see what Import in the
// other direction does.
//
tpetraOverlapVector.putScalar(-1);
tpetraOwnedArray = tpetraOwnedVector.getDataNonConst(0);
tpetraOverlapArray = tpetraOverlapVector.getDataNonConst(0);
for (int owned_lid = 0;
owned_lid < tpetraOwnedMap->getNodeElementList().size();
++owned_lid)
{
int gid = tpetraOwnedMap->getGlobalElement(owned_lid);
int overlap_lid = tpetraOverlapMap->getLocalElement(gid);
tpetraOwnedArray[owned_lid] = gid;
tpetraOverlapArray[overlap_lid] = gid;
}
// Make sure that the changes to the Tpetra Vector were committed,
// by releasing the nonconst views.
tpetraOwnedArray = Teuchos::null;
tpetraOverlapArray = Teuchos::null;
if (verbose) {
out << "Testing Import from overlap Map to owned Map:" << endl << endl;
}
Tpetra::Import<int> tpetraImporter2 (tpetraOverlapMap, tpetraOwnedMap);
tpetraOwnedVector.doImport (tpetraOverlapVector, tpetraImporter2,
Tpetra::INSERT);
// Check the Import results.
success = countFailures (teuchosComm, epetraOwnedMap, epetraOwnedVector,
epetraOverlapMap, epetraOverlapVector,
tpetraOwnedMap, tpetraOwnedVector,
tpetraOverlapMap, tpetraOverlapVector, verbose);
} // if testOtherDirections
out << "End Result: TEST " << (success ? "PASSED" : "FAILED") << endl;
MPI_Finalize ();
return success ? EXIT_SUCCESS : EXIT_FAILURE;
}
int main( int argc, char* argv[] ) {
using Teuchos::CommandLineProcessor;
bool success = true;
bool verbose = true;
Teuchos::GlobalMPISession mpiSession(&argc,&argv);
Teuchos::RCP<Teuchos::FancyOStream>
out = Teuchos::VerboseObjectBase::getDefaultOStream();
try {
const Teuchos::RCP<const Teuchos::Comm<Thyra::Ordinal> >
comm = Teuchos::DefaultComm<Thyra::Ordinal>::getComm();
//
// Read options from command-line
//
int n = 4;
bool useSpmd = true;
bool dumpAll = false;
CommandLineProcessor clp;
clp.throwExceptions(false);
clp.addOutputSetupOptions(true);
clp.setOption( "verbose", "quiet", &verbose, "Set if output is printed or not." );
clp.setOption( "local-dim", &n, "Local number of elements in each constituent vector." );
clp.setOption( "use-spmd", "use-serial", &useSpmd, "Determines if MPI or serial vector space is used." );
clp.setOption( "dump-all", "no-dump-all", &dumpAll, "Determines if vectors are printed or not." );
CommandLineProcessor::EParseCommandLineReturn parse_return = clp.parse(argc,argv);
if( parse_return != CommandLineProcessor::PARSE_SUCCESSFUL ) return parse_return;
//
// Run the tests
//
#ifdef HAVE_THYRA_TEUCHOS_BLASFLOAT
if( !run_composite_linear_ops_tests<float>(comm,n,useSpmd,float(1e-4),dumpAll,verbose?&*out:NULL) ) success = false;
#endif // HAVE_THYRA_TEUCHOS_BLASFLOAT
if( !run_composite_linear_ops_tests<double>(comm,n,useSpmd,double(1e-12),dumpAll,verbose?&*out:NULL) ) success = false;
#if defined(HAVE_THYRA_COMPLEX)
#ifdef HAVE_THYRA_TEUCHOS_BLASFLOAT
if( !run_composite_linear_ops_tests<std::complex<float> >(comm,n,useSpmd,float(1e-4),dumpAll,verbose?&*out:NULL) ) success = false;
#endif // HAVE_THYRA_TEUCHOS_BLASFLOAT
if( !run_composite_linear_ops_tests<std::complex<double> >(comm,n,useSpmd,double(1e-12),dumpAll,verbose?&*out:NULL) ) success = false;
#endif
#if defined(HAVE_TEUCHOS_GNU_MP) && !defined(USE_MPI) // mpf_class can not be used with MPI yet!
if( !run_composite_linear_ops_tests<mpf_class>(comm,n,useSpmd,mpf_class(1e-12),dumpAll,verbose?&*out:NULL) ) success = false;
#endif
if( verbose ) {
if(success) *out << "\nAll of the tests seem to have run successfully!\n";
else *out << "\nOh no! at least one of the tests failed!\n";
}
} // end try
TEUCHOS_STANDARD_CATCH_STATEMENTS(true,*out,success)
return success ? EXIT_SUCCESS : EXIT_FAILURE;
} // end main() [Doxygen looks for this!]
int main(int argc, char* argv[])
{
using Teuchos::CommandLineProcessor;
bool success = true;
bool verbose = true;
Teuchos::RCP<Teuchos::FancyOStream>
out = Teuchos::VerboseObjectBase::getDefaultOStream();
try {
//
// Read options from command-line
//
std::string matrixFile = "";
Thyra::Amesos::ESolverType solverType
#ifdef HAVE_AMESOS_KLU
= Thyra::Amesos::KLU;
#else
= Thyra::Amesos::LAPACK;
#endif
Thyra::Amesos::ERefactorizationPolicy refactorizationPolicy = Thyra::Amesos::REPIVOT_ON_REFACTORIZATION;
bool testTranspose = true;
int numRandomVectors = 1;
double maxFwdError = 1e-14;
double maxError = 1e-10;
double maxResid = 1e-10;
bool showAllTests = false;
bool dumpAll = false;
CommandLineProcessor clp;
clp.throwExceptions(false);
clp.addOutputSetupOptions(true);
clp.setOption( "matrix-file", &matrixFile, "Matrix iput file [Required]." );
clp.setOption(
"solver-type", &solverType
,Thyra::Amesos::numSolverTypes, Thyra::Amesos::solverTypeValues, Thyra::Amesos::solverTypeNames
,"Type of direct solver."
);
clp.setOption(
"refactorization-policy", &refactorizationPolicy
,Thyra::Amesos::numRefactorizationPolices, Thyra::Amesos::refactorizationPolicyValues, Thyra::Amesos::refactorizationPolicyNames
,"Pivoting policy used on refactorizations."
);
clp.setOption( "test-transpose", "no-test-transpose", &testTranspose, "Test the transpose solve or not." );
clp.setOption( "num-random-vectors", &numRandomVectors, "Number of times a test is performed with different random vectors." );
clp.setOption( "max-fwd-error", &maxFwdError, "The maximum relative error in the forward operator." );
clp.setOption( "max-error", &maxError, "The maximum relative error in the solution." );
clp.setOption( "max-resid", &maxResid, "The maximum relative error in the residual." );
clp.setOption( "verbose", "quiet", &verbose, "Set if output is printed or not." );
clp.setOption( "show-all-tests", "no-show-all-tests", &showAllTests, "Set if all the tests are shown or not." );
clp.setOption( "dump-all", "no-dump-all", &dumpAll, "Determines if vectors are printed or not." );
CommandLineProcessor::EParseCommandLineReturn parse_return = clp.parse(argc,argv);
if( parse_return != CommandLineProcessor::PARSE_SUCCESSFUL ) return parse_return;
TEST_FOR_EXCEPT( matrixFile == "" );
Teuchos::ParameterList amesosLOWSFPL;
amesosLOWSFPL.set("Solver Type",toString(solverType));
amesosLOWSFPL.set("Refactorization Policy",toString(refactorizationPolicy));
success
= Thyra::test_single_amesos_thyra_solver(
matrixFile,&amesosLOWSFPL,testTranspose,numRandomVectors
,maxFwdError,maxError,maxResid,showAllTests,dumpAll,verbose?&*out:0
);
}
int main(int argc, char *argv[])
{
Teuchos::GlobalMPISession mpiSession(&argc, &argv);
// Create a communicator for Epetra objects
#ifdef HAVE_MPI
Epetra_MpiComm Comm( MPI_COMM_WORLD );
#else
Epetra_SerialComm Comm;
#endif
bool success = false;
bool verbose = false;
try {
// Parse the command line
using Teuchos::CommandLineProcessor;
CommandLineProcessor clp;
clp.throwExceptions(false);
clp.addOutputSetupOptions(true);
clp.setOption( "v", "disable-verbosity", &verbose, "Enable verbosity" );
CommandLineProcessor::EParseCommandLineReturn
parse_return = clp.parse(argc,argv,&std::cerr);
if( parse_return != CommandLineProcessor::PARSE_SUCCESSFUL )
return parse_return;
if (verbose)
std::cout << "Verbosity Activated" << std::endl;
else
std::cout << "Verbosity Disabled" << std::endl;
int status = 0;
const int num_elements = 400;
// Check we have only one processor since this problem doesn't work
// for more than one proc
if (Comm.NumProc() > num_elements)
throw "Error! Number of elements must be greate than number of processors!";
// Create the model evaluator object
double paramC = 0.99;
Teuchos::RCP<ModelEvaluatorHeq<double> > model =
modelEvaluatorHeq<double>(Teuchos::rcp(&Comm,false),num_elements,paramC);
::Stratimikos::DefaultLinearSolverBuilder builder;
Teuchos::RCP<Teuchos::ParameterList> p =
Teuchos::rcp(new Teuchos::ParameterList);
p->set("Linear Solver Type", "AztecOO");
p->sublist("Linear Solver Types").sublist("AztecOO").sublist("Forward Solve").sublist("AztecOO Settings").set("Output Frequency",20);
p->set("Preconditioner Type", "Ifpack");
builder.setParameterList(p);
Teuchos::RCP< ::Thyra::LinearOpWithSolveFactoryBase<double> >
lowsFactory = builder.createLinearSolveStrategy("");
model->set_W_factory(lowsFactory);
// Create the initial guess
Teuchos::RCP< ::Thyra::VectorBase<double> >
initial_guess = model->getNominalValues().get_x()->clone_v();
Thyra::V_S(initial_guess.ptr(),Teuchos::ScalarTraits<double>::one());
Teuchos::RCP<NOX::Thyra::Group> nox_group =
Teuchos::rcp(new NOX::Thyra::Group(*initial_guess, model));
//Teuchos::rcp(new NOX::Thyra::Group(*initial_guess, model, model->create_W_op(), lowsFactory, Teuchos::null, Teuchos::null));
nox_group->computeF();
// Create the NOX status tests and the solver
// Create the convergence tests
Teuchos::RCP<NOX::StatusTest::NormF> absresid =
Teuchos::rcp(new NOX::StatusTest::NormF(1.0e-8));
Teuchos::RCP<NOX::StatusTest::NormWRMS> wrms =
Teuchos::rcp(new NOX::StatusTest::NormWRMS(1.0e-2, 1.0e-8));
Teuchos::RCP<NOX::StatusTest::Combo> converged =
Teuchos::rcp(new NOX::StatusTest::Combo(NOX::StatusTest::Combo::AND));
converged->addStatusTest(absresid);
converged->addStatusTest(wrms);
Teuchos::RCP<NOX::StatusTest::MaxIters> maxiters =
Teuchos::rcp(new NOX::StatusTest::MaxIters(20));
Teuchos::RCP<NOX::StatusTest::FiniteValue> fv =
Teuchos::rcp(new NOX::StatusTest::FiniteValue);
Teuchos::RCP<NOX::StatusTest::Combo> combo =
Teuchos::rcp(new NOX::StatusTest::Combo(NOX::StatusTest::Combo::OR));
combo->addStatusTest(fv);
combo->addStatusTest(converged);
combo->addStatusTest(maxiters);
// Create nox parameter list
Teuchos::RCP<Teuchos::ParameterList> nl_params =
Teuchos::rcp(new Teuchos::ParameterList);
nl_params->set("Nonlinear Solver", "Anderson Accelerated Fixed-Point");
nl_params->sublist("Anderson Parameters").set("Storage Depth", 5);
nl_params->sublist("Anderson Parameters").set("Mixing Parameter", 1.0);
nl_params->sublist("Anderson Parameters").set("Acceleration Start Iteration", 1);
nl_params->sublist("Anderson Parameters").sublist("Preconditioning").set("Precondition", false);
nl_params->sublist("Direction").sublist("Newton").sublist("Linear Solver").set("Tolerance", 1.0e-4);
nl_params->sublist("Printing").sublist("Output Information").set("Details",true);
nl_params->sublist("Printing").sublist("Output Information").set("Outer Iteration",true);
//nl_params->sublist("Printing").sublist("Output Information").set("Outer Iteration StatusTest",true);
// Create the solver
Teuchos::RCP<NOX::Solver::Generic> solver =
NOX::Solver::buildSolver(nox_group, combo, nl_params);
NOX::StatusTest::StatusType solvStatus = solver->solve();
// 1. Convergence
if (solvStatus != NOX::StatusTest::Converged)
status = 1;
// 2. Number of iterations
if (const_cast<Teuchos::ParameterList&>(solver->getList()).sublist("Output").get("Nonlinear Iterations", 0) != 11)
status = 2;
success = status==0;
if (success)
std::cout << "Test passed!" << std::endl;
else
std::cout << "Test failed!" << std::endl;
}
TEUCHOS_STANDARD_CATCH_STATEMENTS(verbose, std::cerr, success);
return ( success ? EXIT_SUCCESS : EXIT_FAILURE );
}
int main( int argc, char* argv[] ) {
using Teuchos::CommandLineProcessor;
bool success = true;
bool verbose = true;
bool dumpAll = false;
Teuchos::GlobalMPISession mpiSession(&argc,&argv);
// KL 27 Jul 2006 -- Commenting out unused variables
// const int procRank = Teuchos::GlobalMPISession::getRank();
// const int numProc = Teuchos::GlobalMPISession::getNProc();
Teuchos::RCP<Teuchos::FancyOStream>
out = Teuchos::VerboseObjectBase::getDefaultOStream();
try {
//
// Read options from the command-line
//
CommandLineProcessor clp;
clp.throwExceptions(false);
clp.addOutputSetupOptions(true);
int local_dim = 4;
clp.setOption( "local-dim", &local_dim, "Number of vector elements per process." );
double eps_scale = 200.0;
clp.setOption( "eps-scale", &eps_scale, "Constant (greater than 1) to scale eps by in error tests." );
clp.setOption( "verbose", "quiet", &verbose,
"Determines if any output is printed or not." );
clp.setOption( "dump-all", "no-dump", &dumpAll, "Determines if quantities are dumped or not." );
CommandLineProcessor::EParseCommandLineReturn parse_return = clp.parse(argc,argv);
if( parse_return != CommandLineProcessor::PARSE_SUCCESSFUL ) return parse_return;
//
// Run the tests
//
#if defined(HAVE_THYRA_FLOAT)
if( !Thyra::run_std_ops_tests<float>(local_dim,float(eps_scale*Teuchos::ScalarTraits<float>::eps()),dumpAll,verbose?&*out:NULL) ) success = false;
#endif
if( !Thyra::run_std_ops_tests<double>(local_dim,double(eps_scale*Teuchos::ScalarTraits<double>::eps()),dumpAll,verbose?&*out:NULL) ) success = false;
#if defined(HAVE_THYRA_COMPLEX) && defined(HAVE_THYRA_FLOAT)
if( !Thyra::run_std_ops_tests<std::complex<float> >(local_dim,float(eps_scale*Teuchos::ScalarTraits<float>::eps()),dumpAll,verbose?&*out:NULL) ) success = false;
#endif
#if defined(HAVE_THYRA_COMPLEX)
if( !Thyra::run_std_ops_tests<std::complex<double> >(local_dim,double(eps_scale*Teuchos::ScalarTraits<double>::eps()),dumpAll,verbose?&*out:NULL) ) success = false;
#endif
#ifdef HAVE_TEUCHOS_GNU_MP
//if( !Thyra::run_std_ops_tests<mpf_class>(local_dim,mpf_class(max_rel_err),dumpAll,verbose?&*out:NULL) ) success = false;
// RAB: 4/16/2005: We can not instantiate the above since rmax() is not supported by this types ScalarTraits class
// and it is needed by the class RTOpPack::ROpMaxIndexLessThanBound. This can be fixed using a template
// conditional but I have not done this yet.
#endif
} // end try
catch( const std::exception &excpt ) {
if(verbose)
std::cerr << "*** Caught a standard exception : " << excpt.what() << std::endl;
success = false;
}
catch( ... ) {
if(verbose)
std::cerr << "*** Caught an unknown exception!\n";
success = false;
}
if(verbose) {
if(success)
*out << "\nAll of the tests seem to have run successfully!\n";
else
*out << "\nOh no! at least one of the test failed!\n";
}
return success ? 0 : 1;
}
int main(int argc, char *argv[])
{
Teuchos::GlobalMPISession mpiSession(&argc, &argv);
int status = 0;
// Parse the command line
using Teuchos::CommandLineProcessor;
CommandLineProcessor clp;
clp.throwExceptions(false);
clp.addOutputSetupOptions(true);
bool verbose = false;
clp.setOption( "v", "disable-verbosity", &verbose, "Enable verbosity" );
CommandLineProcessor::EParseCommandLineReturn
parse_return = clp.parse(argc,argv,&std::cerr);
if( parse_return != CommandLineProcessor::PARSE_SUCCESSFUL )
return parse_return;
if (verbose)
std::cout << "Verbosity Activated" << std::endl;
else
std::cout << "Verbosity Disabled" << std::endl;
// Create a communicator for Epetra objects
#ifdef HAVE_MPI
Epetra_MpiComm Comm( MPI_COMM_WORLD );
#else
Epetra_SerialComm Comm;
#endif
// Check we have only one processor since this problem doesn't work
// for more than one proc
if (Comm.NumProc() > 1) {
std::cerr << "Error! Problem can only be run with at most 1 processor!"
<< std::endl;
return -1;
}
// Create the model evaluator object
double d = 10.0;
double p0 = 2.0;
double p1 = 0.0;
double x00 = 0.0;
double x01 = 1.0;
Teuchos::RCP<ModelEvaluator2DSim<double> > thyraModel =
Teuchos::rcp(new ModelEvaluator2DSim<double>(Teuchos::rcp(&Comm,false),
d,p0,p1,x00,x01));
::Stratimikos::DefaultLinearSolverBuilder builder;
Teuchos::RCP<Teuchos::ParameterList> p =
Teuchos::rcp(new Teuchos::ParameterList);
p->set("Linear Solver Type", "AztecOO");
p->set("Preconditioner Type", "Ifpack");
builder.setParameterList(p);
Teuchos::RCP< ::Thyra::LinearOpWithSolveFactoryBase<double> >
lowsFactory = builder.createLinearSolveStrategy("");
thyraModel->set_W_factory(lowsFactory);
// Create nox parameter list
Teuchos::RCP<Teuchos::ParameterList> nl_params =
Teuchos::rcp(new Teuchos::ParameterList);
nl_params->set("Nonlinear Solver", "Line Search Based");
// Create a Thyra nonlinear solver
Teuchos::RCP< ::Thyra::NonlinearSolverBase<double> > solver =
Teuchos::rcp(new ::Thyra::NOXNonlinearSolver);
solver->setParameterList(nl_params);
solver->setModel(thyraModel);
Teuchos::RCP< ::Thyra::VectorBase<double> >
initial_guess = thyraModel->getNominalValues().get_x()->clone_v();
::Thyra::SolveCriteria<double> solve_criteria;
::Thyra::SolveStatus<double> solve_status;
solve_status = solver->solve(initial_guess.get(), &solve_criteria);
TEUCHOS_ASSERT(solve_status.extraParameters->isType<int>("Number of Iterations"));
TEUCHOS_ASSERT(solve_status.extraParameters->get<int>("Number of Iterations") == 7);
if (solve_status.solveStatus == ::Thyra::SOLVE_STATUS_CONVERGED)
std::cout << "Test passed!" << std::endl;
Teuchos::TimeMonitor::summarize();
// Final return value (0 = successfull, non-zero = failure)
return status;
}
//
// Main driver program
//
int main( int argc, char *argv[] )
{
using Teuchos::CommandLineProcessor;
bool success = true;
bool result;
Teuchos::GlobalMPISession mpiSession(&argc,&argv);
// Above is needed to run in an MPI build with some MPI implementations
Teuchos::RCP<Teuchos::FancyOStream>
out = Teuchos::VerboseObjectBase::getDefaultOStream();
try {
//
// Read in command-line options
//
CommandLineProcessor clp;
clp.throwExceptions(false);
clp.addOutputSetupOptions(true);
int n0 = 2;
clp.setOption( "n0", &n0 );
int n1 = 3;
clp.setOption( "n1", &n1 );
int n2 = 4;
clp.setOption( "n2", &n2 );
Teuchos::EVerbosityLevel verbLevel = Teuchos::VERB_MEDIUM;
setVerbosityLevelOption( "verb-level", &verbLevel,
"Top-level verbosity level. By default, this gets deincremented as you go deeper into numerical objects.",
&clp );
CommandLineProcessor::EParseCommandLineReturn parse_return = clp.parse(argc,argv);
if( parse_return != CommandLineProcessor::PARSE_SUCCESSFUL ) return parse_return;
#if defined(HAVE_THYRA_FLOAT)
// Run using float
result = exampleImplicitlyComposedLinearOperators<float>(
n0, n1, n2, *out, verbLevel, 1e-5, true );
if (!result) success = false;
#endif
// Run using double
result = exampleImplicitlyComposedLinearOperators<double>(
n0, n1, n2, *out, verbLevel, 1e-12, true );
if (!result) success = false;
#ifdef HAVE_THYRA_COMPLEX
#if defined(HAVE_THYRA_FLOAT)
// Run using std::complex<float>
result = exampleImplicitlyComposedLinearOperators<std::complex<float> >(
n0, n1, n2, *out, verbLevel, 1e-5, false );
if (!result) success = false;
// 2007/11/02: rabartl: Above, I skip the test of the adjoint since it
// fails but a lot. On my machine, the relative error is:
// rel_err((-3.00939,-0.836347),(-0.275689,1.45244)) = 1.14148.
// Since this works just fine for the next complex<double> case, I am
// going to just skip this test.
#endif // defined(HAVE_THYRA_FLOAT)
// Run using std::complex<double>
result = exampleImplicitlyComposedLinearOperators<std::complex<double> >(
n0, n1, n2, *out, verbLevel, 1e-12, true );
if (!result) success = false;
#endif // HAVE_THYRA_COMPLEX
#ifdef HAVE_TEUCHOS_GNU_MP
// Run using mpf_class
result = exampleImplicitlyComposedLinearOperators<mpf_class>(
n0, n1, n2, *out, verbLevel, 1e-20, true );
if (!result) success = false;
#endif // HAVE_TEUCHOS_GNU_MP
}
TEUCHOS_STANDARD_CATCH_STATEMENTS(true,*out,success)
if(success)
*out << "\nCongratulations! All of the tests checked out!\n";
else
*out << "\nOh no! At least one of the tests failed!\n";
return success ? 0 : 1;
} // end main()
//
// Actual main driver program
//
int main(int argc, char *argv[])
{
using Teuchos::CommandLineProcessor;
bool success = true;
bool result;
Teuchos::GlobalMPISession mpiSession(&argc,&argv);
// Above is needed to run in an MPI build with some MPI implementations
Teuchos::RCP<Teuchos::FancyOStream>
out = Teuchos::VerboseObjectBase::getDefaultOStream();
try {
//
// Read in command-line options
//
CommandLineProcessor clp;
clp.throwExceptions(false);
clp.addOutputSetupOptions(true);
int dim = 500;
clp.setOption( "dim", &dim,
"Dimension of the linear system." );
double diagScale = 1.001;
clp.setOption( "diag-scale", &diagScale,
"Scaling of the diagonal to improve conditioning." );
bool symOp = true;
clp.setOption( "sym-op", "unsym-op", &symOp,
"Determines if the operator is symmetric or not." );
bool showAllTests = false;
clp.setOption( "show-all-tests", "show-summary-only", &showAllTests,
"Show all LinearOpTester tests or not" );
double tolerance = 1e-4;
clp.setOption( "tol", &tolerance,
"Relative tolerance for linear system solve." );
int maxNumIters = 300;
clp.setOption( "max-num-iters", &maxNumIters,
"Maximum of CG iterations." );
CommandLineProcessor::EParseCommandLineReturn parse_return = clp.parse(argc,argv);
if( parse_return != CommandLineProcessor::PARSE_SUCCESSFUL ) return parse_return;
TEUCHOS_TEST_FOR_EXCEPTION( dim < 2, std::logic_error, "Error, dim=" << dim << " < 2 is not allowed!" );
#if defined(HAVE_THYRA_FLOAT)
result = runCgSolveExample<float>(dim, diagScale, symOp, showAllTests,
tolerance, maxNumIters);
if(!result) success = false;
#endif
result = runCgSolveExample<double>(dim, diagScale, symOp, showAllTests,
tolerance, maxNumIters);
if(!result) success = false;
#ifdef HAVE_THYRA_COMPLEX
#if defined(HAVE_THYRA_FLOAT)
result = runCgSolveExample<std::complex<float> >(dim, diagScale, symOp, showAllTests,
tolerance, maxNumIters);
if(!result) success = false;
#endif
result = runCgSolveExample<std::complex<double> >(dim, diagScale, symOp, showAllTests,
tolerance, maxNumIters);
if(!result) success = false;
#endif // HAVE_THYRA_COMPLEX
#ifdef HAVE_TEUCHOS_GNU_MP
result = runCgSolveExample<mpf_class>(dim, diagScale, symOp, showAllTests,
tolerance, maxNumIters);
if(!result) success = false;
#ifdef HAVE_THYRA_COMPLEX
//result = runCgSolveExample<std::complex<mpf_class> >(dim, mpf_class(diagScale), symOp,
showAllTests, mpf_class(tolerance), maxNumIters);
//if(!result) success = false;
//The above commented-out code throws a floating-point exception?
#endif // HAVE_THYRA_COMPLEX
#endif // HAVE_TEUCHOS_GNU_MP
}
TEUCHOS_STANDARD_CATCH_STATEMENTS(true,*out,success)
if(success)
*out << "\nCongratulations! All of the tests checked out!\n";
else
*out << "\nOh no! At least one of the tests failed!\n";
return success ? 0 : 1;
} // end main()
int main(int argc, char *argv[])
{
using std::endl;
typedef double Scalar;
typedef double ScalarMag;
using Teuchos::describe;
using Teuchos::RCP;
using Teuchos::rcp;
using Teuchos::rcp_implicit_cast;
using Teuchos::rcp_dynamic_cast;
using Teuchos::as;
using Teuchos::ParameterList;
using Teuchos::CommandLineProcessor;
typedef Teuchos::ParameterList::PrintOptions PLPrintOptions;
typedef Thyra::ModelEvaluatorBase MEB;
typedef Thyra::DefaultMultiVectorProductVectorSpace<Scalar> DMVPVS;
using Thyra::productVectorBase;
bool result, success = true;
Teuchos::GlobalMPISession mpiSession(&argc,&argv);
RCP<Epetra_Comm> epetra_comm;
#ifdef HAVE_MPI
epetra_comm = rcp( new Epetra_MpiComm(MPI_COMM_WORLD) );
#else
epetra_comm = rcp( new Epetra_SerialComm );
#endif // HAVE_MPI
RCP<Teuchos::FancyOStream>
out = Teuchos::VerboseObjectBase::getDefaultOStream();
try {
//
// Read commandline options
//
CommandLineProcessor clp;
clp.throwExceptions(false);
clp.addOutputSetupOptions(true);
std::string paramsFileName = "";
clp.setOption( "params-file", ¶msFileName,
"File name for XML parameters" );
std::string extraParamsString = "";
clp.setOption( "extra-params", &extraParamsString,
"Extra XML parameters" );
std::string extraParamsFile = "";
clp.setOption( "extra-params-file", &extraParamsFile, "File containing extra parameters in XML format.");
double maxStateError = 1e-6;
clp.setOption( "max-state-error", &maxStateError,
"The maximum allowed error in the integrated state in relation to the exact state solution" );
double finalTime = 1e-3;
clp.setOption( "final-time", &finalTime,
"Final integration time (initial time is 0.0)" );
int numTimeSteps = 10;
clp.setOption( "num-time-steps", &numTimeSteps,
"Number of (fixed) time steps. If <= 0.0, then variable time steps are taken" );
bool useBDF = false;
clp.setOption( "use-BDF", "use-BE", &useBDF,
"Use BDF or Backward Euler (BE)" );
bool useIRK = false;
clp.setOption( "use-IRK", "use-other", &useIRK,
"Use IRK or something" );
bool doFwdSensSolve = false;
clp.setOption( "fwd-sens-solve", "state-solve", &doFwdSensSolve,
"Do the forward sensitivity solve or just the state solve" );
bool doFwdSensErrorControl = false;
clp.setOption( "fwd-sens-err-cntrl", "no-fwd-sens-err-cntrl", &doFwdSensErrorControl,
"Do error control on the forward sensitivity solve or not" );
double maxRestateError = 0.0;
clp.setOption( "max-restate-error", &maxRestateError,
"The maximum allowed error between the state integrated by itself verses integrated along with DxDp" );
double maxSensError = 1e-4;
clp.setOption( "max-sens-error", &maxSensError,
"The maximum allowed error in the integrated sensitivity in relation to"
" the finite-difference sensitivity" );
Teuchos::EVerbosityLevel verbLevel = Teuchos::VERB_DEFAULT;
setVerbosityLevelOption( "verb-level", &verbLevel,
"Top-level verbosity level. By default, this gets deincremented as you go deeper into numerical objects.",
&clp );
bool testExactSensitivity = false;
clp.setOption( "test-exact-sens", "no-test-exact-sens", &testExactSensitivity,
"Test the exact sensitivity with finite differences or not." );
bool dumpFinalSolutions = false;
clp.setOption(
"dump-final-solutions", "no-dump-final-solutions", &dumpFinalSolutions,
"Determine if the final solutions are dumpped or not." );
CommandLineProcessor::EParseCommandLineReturn parse_return = clp.parse(argc,argv);
if( parse_return != CommandLineProcessor::PARSE_SUCCESSFUL ) return parse_return;
if ( Teuchos::VERB_DEFAULT == verbLevel )
verbLevel = Teuchos::VERB_LOW;
const Teuchos::EVerbosityLevel
solnVerbLevel = ( dumpFinalSolutions ? Teuchos::VERB_EXTREME : verbLevel );
//
// Get the base parameter list that all other parameter lists will be read
// from.
//
RCP<ParameterList>
paramList = Teuchos::parameterList();
if (paramsFileName.length())
updateParametersFromXmlFile( paramsFileName, paramList.ptr() );
if(extraParamsFile.length())
Teuchos::updateParametersFromXmlFile( "./"+extraParamsFile, paramList.ptr() );
if (extraParamsString.length())
updateParametersFromXmlString( extraParamsString, paramList.ptr() );
if (testExactSensitivity) {
paramList->sublist(DiagonalTransientModel_name).set("Exact Solution as Response",true);
}
paramList->validateParameters(*getValidParameters(),0); // Only validate top level lists!
//
// Create the Stratimikos linear solver factory.
//
// This is the linear solve strategy that will be used to solve for the
// linear system with the W.
//
Stratimikos::DefaultLinearSolverBuilder linearSolverBuilder;
linearSolverBuilder.setParameterList(sublist(paramList,Stratimikos_name));
RCP<Thyra::LinearOpWithSolveFactoryBase<Scalar> >
W_factory = createLinearSolveStrategy(linearSolverBuilder);
//
// Create the underlying EpetraExt::ModelEvaluator
//
RCP<EpetraExt::DiagonalTransientModel>
epetraStateModel = EpetraExt::diagonalTransientModel(
epetra_comm,
sublist(paramList,DiagonalTransientModel_name)
);
*out <<"\nepetraStateModel valid options:\n";
epetraStateModel->getValidParameters()->print(
*out, PLPrintOptions().indent(2).showTypes(true).showDoc(true)
);
//
// Create the Thyra-wrapped ModelEvaluator
//
RCP<Thyra::ModelEvaluator<double> >
stateModel = epetraModelEvaluator(epetraStateModel,W_factory);
*out << "\nParameter names = " << *stateModel->get_p_names(0) << "\n";
//
// Create the Rythmos stateStepper
//
RCP<Rythmos::TimeStepNonlinearSolver<double> >
nonlinearSolver = Rythmos::timeStepNonlinearSolver<double>();
RCP<ParameterList>
nonlinearSolverPL = sublist(paramList,TimeStepNonlinearSolver_name);
nonlinearSolverPL->get("Default Tol",1e-3*maxStateError); // Set default if not set
nonlinearSolver->setParameterList(nonlinearSolverPL);
RCP<Rythmos::StepperBase<Scalar> > stateStepper;
if (useBDF) {
stateStepper = rcp(
new Rythmos::ImplicitBDFStepper<double>(
stateModel, nonlinearSolver
)
);
}
else if (useIRK) {
// We need a separate LOWSFB object for the IRK stepper
RCP<Thyra::LinearOpWithSolveFactoryBase<Scalar> >
irk_W_factory = createLinearSolveStrategy(linearSolverBuilder);
RCP<Rythmos::RKButcherTableauBase<double> > irkbt = Rythmos::createRKBT<double>("Backward Euler");
stateStepper = Rythmos::implicitRKStepper<double>(
stateModel, nonlinearSolver, irk_W_factory, irkbt
);
}
else {
stateStepper = rcp(
new Rythmos::BackwardEulerStepper<double>(
stateModel, nonlinearSolver
)
);
}
*out <<"\nstateStepper:\n" << describe(*stateStepper,verbLevel);
*out <<"\nstateStepper valid options:\n";
stateStepper->getValidParameters()->print(
*out, PLPrintOptions().indent(2).showTypes(true).showDoc(true)
);
stateStepper->setParameterList(sublist(paramList,RythmosStepper_name));
//
// Setup finite difference objects that will be used for tests
//
Thyra::DirectionalFiniteDiffCalculator<Scalar> fdCalc;
fdCalc.setParameterList(sublist(paramList,FdCalc_name));
fdCalc.setOStream(out);
fdCalc.setVerbLevel(verbLevel);
//
// Use a StepperAsModelEvaluator to integrate the state
//
const MEB::InArgs<Scalar>
state_ic = stateModel->getNominalValues();
*out << "\nstate_ic:\n" << describe(state_ic,verbLevel);
RCP<Rythmos::IntegratorBase<Scalar> > integrator;
{
RCP<ParameterList>
integratorPL = sublist(paramList,RythmosIntegrator_name);
integratorPL->set( "Take Variable Steps", as<bool>(numTimeSteps < 0) );
integratorPL->set( "Fixed dt", as<double>((finalTime - state_ic.get_t())/numTimeSteps) );
RCP<Rythmos::IntegratorBase<Scalar> >
defaultIntegrator = Rythmos::controlledDefaultIntegrator<Scalar>(
Rythmos::simpleIntegrationControlStrategy<Scalar>(integratorPL)
);
integrator = defaultIntegrator;
}
RCP<Rythmos::StepperAsModelEvaluator<Scalar> >
stateIntegratorAsModel = Rythmos::stepperAsModelEvaluator(
stateStepper, integrator, state_ic
);
stateIntegratorAsModel->setVerbLevel(verbLevel);
*out << "\nUse the StepperAsModelEvaluator to integrate state x(p,finalTime) ... \n";
RCP<Thyra::VectorBase<Scalar> > x_final;
{
Teuchos::OSTab tab(out);
x_final = createMember(stateIntegratorAsModel->get_g_space(0));
eval_g(
*stateIntegratorAsModel,
0, *state_ic.get_p(0),
finalTime,
0, &*x_final
);
*out
<< "\nx_final = x(p,finalTime) evaluated using stateIntegratorAsModel:\n"
<< describe(*x_final,solnVerbLevel);
}
//
// Test the integrated state against the exact analytical state solution
//
RCP<const Thyra::VectorBase<Scalar> >
exact_x_final = create_Vector(
epetraStateModel->getExactSolution(finalTime),
stateModel->get_x_space()
);
result = Thyra::testRelNormDiffErr(
"exact_x_final", *exact_x_final, "x_final", *x_final,
"maxStateError", maxStateError, "warningTol", 1.0, // Don't warn
&*out, solnVerbLevel
);
if (!result) success = false;
//
// Solve and test the forward sensitivity computation
//
if (doFwdSensSolve) {
//
// Create the forward sensitivity stepper
//
RCP<Rythmos::ForwardSensitivityStepper<Scalar> > stateAndSensStepper =
Rythmos::forwardSensitivityStepper<Scalar>();
if (doFwdSensErrorControl) {
stateAndSensStepper->initializeDecoupledSteppers(
stateModel, 0, stateModel->getNominalValues(),
stateStepper, nonlinearSolver,
integrator->cloneIntegrator(), finalTime
);
}
else {
stateAndSensStepper->initializeSyncedSteppers(
stateModel, 0, stateModel->getNominalValues(),
stateStepper, nonlinearSolver
);
// The above call will result in stateStepper and nonlinearSolver being
// cloned. This helps to ensure consistency between the state and
// sensitivity computations!
}
//
// Set the initial condition for the state and forward sensitivities
//
RCP<Thyra::VectorBase<Scalar> > s_bar_init
= createMember(stateAndSensStepper->getFwdSensModel()->get_x_space());
assign( s_bar_init.ptr(), 0.0 );
RCP<Thyra::VectorBase<Scalar> > s_bar_dot_init
= createMember(stateAndSensStepper->getFwdSensModel()->get_x_space());
assign( s_bar_dot_init.ptr(), 0.0 );
// Above, I believe that these are the correct initial conditions for
// s_bar and s_bar_dot given how the EpetraExt::DiagonalTransientModel
// is currently implemented!
RCP<const Rythmos::StateAndForwardSensitivityModelEvaluator<Scalar> >
stateAndSensModel = stateAndSensStepper->getStateAndFwdSensModel();
MEB::InArgs<Scalar>
state_and_sens_ic = stateAndSensStepper->getModel()->createInArgs();
// Copy time, parameters etc.
state_and_sens_ic.setArgs(state_ic);
// Set initial condition for x_bar = [ x; s_bar ]
state_and_sens_ic.set_x(
stateAndSensModel->create_x_bar_vec(state_ic.get_x(),s_bar_init)
);
// Set initial condition for x_bar_dot = [ x_dot; s_bar_dot ]
state_and_sens_ic.set_x_dot(
stateAndSensModel->create_x_bar_vec(state_ic.get_x_dot(),s_bar_dot_init)
);
*out << "\nstate_and_sens_ic:\n" << describe(state_and_sens_ic,verbLevel);
stateAndSensStepper->setInitialCondition(state_and_sens_ic);
//
// Use a StepperAsModelEvaluator to integrate the state+sens
//
RCP<Rythmos::StepperAsModelEvaluator<Scalar> >
stateAndSensIntegratorAsModel = Rythmos::stepperAsModelEvaluator(
rcp_implicit_cast<Rythmos::StepperBase<Scalar> >(stateAndSensStepper),
integrator, state_and_sens_ic
);
stateAndSensIntegratorAsModel->setVerbLevel(verbLevel);
*out << "\nUse the StepperAsModelEvaluator to integrate state + sens x_bar(p,finalTime) ... \n";
RCP<Thyra::VectorBase<Scalar> > x_bar_final;
{
Teuchos::OSTab tab(out);
x_bar_final = createMember(stateAndSensIntegratorAsModel->get_g_space(0));
eval_g(
*stateAndSensIntegratorAsModel,
0, *state_ic.get_p(0),
finalTime,
0, &*x_bar_final
);
*out
<< "\nx_bar_final = x_bar(p,finalTime) evaluated using stateAndSensIntegratorAsModel:\n"
<< describe(*x_bar_final,solnVerbLevel);
}
//
// Test that the state computed above is same as computed initially!
//
*out << "\nChecking that x(p,finalTime) computed as part of x_bar above is the same ...\n";
{
Teuchos::OSTab tab(out);
RCP<const Thyra::VectorBase<Scalar> >
x_in_x_bar_final = productVectorBase<Scalar>(x_bar_final)->getVectorBlock(0);
result = Thyra::testRelNormDiffErr<Scalar>(
"x_final", *x_final,
"x_in_x_bar_final", *x_in_x_bar_final,
"maxRestateError", maxRestateError,
"warningTol", 1.0, // Don't warn
&*out, solnVerbLevel
);
if (!result) success = false;
}
//
// Compute DxDp using finite differences
//
*out << "\nApproximating DxDp(p,t) using directional finite differences of integrator for x(p,t) ...\n";
RCP<Thyra::MultiVectorBase<Scalar> > DxDp_fd_final;
{
Teuchos::OSTab tab(out);
MEB::InArgs<Scalar>
fdBasePoint = stateIntegratorAsModel->createInArgs();
fdBasePoint.set_t(finalTime);
fdBasePoint.set_p(0,stateModel->getNominalValues().get_p(0));
DxDp_fd_final = createMembers(
stateIntegratorAsModel->get_g_space(0),
stateIntegratorAsModel->get_p_space(0)->dim()
);
typedef Thyra::DirectionalFiniteDiffCalculatorTypes::SelectedDerivatives
SelectedDerivatives;
MEB::OutArgs<Scalar> fdOutArgs =
fdCalc.createOutArgs(
*stateIntegratorAsModel,
SelectedDerivatives().supports(MEB::OUT_ARG_DgDp,0,0)
);
fdOutArgs.set_DgDp(0,0,DxDp_fd_final);
// Silence the model evaluators that are called. The fdCal object
// will show all of the inputs and outputs for each call.
stateStepper->setVerbLevel(Teuchos::VERB_NONE);
stateIntegratorAsModel->setVerbLevel(Teuchos::VERB_NONE);
fdCalc.calcDerivatives(
*stateIntegratorAsModel, fdBasePoint,
stateIntegratorAsModel->createOutArgs(), // Don't bother with function value
fdOutArgs
);
*out
<< "\nFinite difference DxDp_fd_final = DxDp(p,finalTime): "
<< describe(*DxDp_fd_final,solnVerbLevel);
}
//
// Test that the integrated sens and the F.D. sens are similar
//
*out << "\nChecking that integrated DxDp(p,finalTime) and finite-diff DxDp(p,finalTime) are similar ...\n";
{
Teuchos::OSTab tab(out);
RCP<const Thyra::VectorBase<Scalar> >
DxDp_vec_final = Thyra::productVectorBase<Scalar>(x_bar_final)->getVectorBlock(1);
RCP<const Thyra::VectorBase<Scalar> >
DxDp_fd_vec_final = Thyra::multiVectorProductVector(
rcp_dynamic_cast<const Thyra::DefaultMultiVectorProductVectorSpace<Scalar> >(
DxDp_vec_final->range()
),
DxDp_fd_final
);
result = Thyra::testRelNormDiffErr(
"DxDp_vec_final", *DxDp_vec_final,
"DxDp_fd_vec_final", *DxDp_fd_vec_final,
"maxSensError", maxSensError,
"warningTol", 1.0, // Don't warn
&*out, solnVerbLevel
);
if (!result) success = false;
}
}
}
TEUCHOS_STANDARD_CATCH_STATEMENTS(true,*out,success);
if(success)
*out << "\nEnd Result: TEST PASSED" << endl;
else
*out << "\nEnd Result: TEST FAILED" << endl;
return ( success ? 0 : 1 );
} // end main() [Doxygen looks for this!]
int
main (int argc, char *argv[])
{
using Belos::OutputManager;
using Belos::SolverFactory;
using Teuchos::CommandLineProcessor;
using Teuchos::null;
using Teuchos::ParameterList;
using Teuchos::parameterList;
using Teuchos::RCP;
using Teuchos::rcp;
using Teuchos::rcp_dynamic_cast;
using Teuchos::rcp_implicit_cast;
using std::cerr;
using std::cout;
using std::endl;
typedef double scalar_type;
typedef Epetra_MultiVector MV;
typedef Epetra_Operator OP;
typedef Belos::SolverManager<scalar_type, MV, OP> solver_base_type;
typedef Belos::SolverFactory<scalar_type, MV, OP> factory_type;
Teuchos::oblackholestream blackHole;
Teuchos::GlobalMPISession mpiSession (&argc, &argv, &blackHole);
RCP<Epetra_Comm> comm;
{
#ifdef EPETRA_MPI
RCP<Epetra_MpiComm> commSpecific (new Epetra_MpiComm (MPI_COMM_WORLD));
#else
RCP<Epetra_SerialComm> commSpecific (new Epetra_SerialComm);
#endif // EPETRA_MPI
comm = rcp_implicit_cast<Epetra_Comm> (commSpecific);
}
std::ostream& out = (comm->MyPID() == 0) ? std::cout : blackHole;
bool success = false;
bool verbose = false;
try {
int numRHS = 1;
bool debug = false;
// Define command-line arguments.
CommandLineProcessor cmdp (false, true);
cmdp.setOption ("numRHS", &numRHS, "Number of right-hand sides in the linear "
"system to solve.");
cmdp.setOption ("verbose", "quiet", &verbose, "Print messages and results.");
cmdp.setOption ("debug", "nodebug", &debug, "Print debugging information.");
// Parse the command-line arguments.
{
const CommandLineProcessor::EParseCommandLineReturn parseResult =
cmdp.parse (argc,argv);
if (parseResult == CommandLineProcessor::PARSE_HELP_PRINTED) {
if (comm->MyPID() == 0)
std::cout << "End Result: TEST PASSED" << endl;
return EXIT_SUCCESS;
}
TEUCHOS_TEST_FOR_EXCEPTION(parseResult != CommandLineProcessor::PARSE_SUCCESSFUL,
std::invalid_argument, "Failed to parse command-line arguments.");
}
// Declare an output manager for handling local output. Initialize,
// using the caller's desired verbosity level.
RCP<OutputManager<scalar_type> > outMan =
rcp (new OutputManager<scalar_type> (selectVerbosity (verbose, debug)));
// Stream for debug output. If debug output is not enabled, then
// this stream doesn't print anything sent to it (it's a "black
// hole" stream).
//std::ostream& debugOut = outMan->stream (Belos::Debug);
// Create the operator to test, with domain and range maps.
RCP<const Epetra_Map> domainMap, rangeMap;
RCP<Epetra_Operator> A = makeMatrix (comm, domainMap, rangeMap);
// "Solution" input/output multivector.
RCP<MV> X_exact = rcp (new MV (*domainMap, numRHS));
X_exact->Seed ();
X_exact->Random ();
RCP<MV> X = rcp (new MV (*domainMap, numRHS));
X->PutScalar (0.0);
// "Right-hand side" input multivector.
RCP<MV> B = rcp (new MV (*rangeMap, numRHS));
A->Apply (*X_exact, *B);
//
// Test creating solver instances using the solver factory.
//
factory_type factory;
//
// Test the canonical solver names.
//
{
typedef Belos::BlockGmresSolMgr<scalar_type, MV, OP> solver_impl_type;
testCreatingSolver<factory_type, solver_base_type,
solver_impl_type> (factory, "Block GMRES", out, verbose);
}
{
typedef Belos::PseudoBlockGmresSolMgr<scalar_type, MV, OP> solver_impl_type;
testCreatingSolver<factory_type, solver_base_type,
solver_impl_type> (factory, "Pseudoblock GMRES", out, verbose);
}
{
typedef Belos::BlockCGSolMgr<scalar_type, MV, OP> solver_impl_type;
testCreatingSolver<factory_type, solver_base_type,
solver_impl_type> (factory, "Block CG", out, verbose);
}
{
typedef Belos::PseudoBlockCGSolMgr<scalar_type, MV, OP> solver_impl_type;
testCreatingSolver<factory_type, solver_base_type,
solver_impl_type> (factory, "Pseudoblock CG", out, verbose);
}
{
typedef Belos::GCRODRSolMgr<scalar_type, MV, OP> solver_impl_type;
testCreatingSolver<factory_type, solver_base_type,
solver_impl_type> (factory, "GCRODR", out, verbose);
}
{
typedef Belos::RCGSolMgr<scalar_type, MV, OP> solver_impl_type;
testCreatingSolver<factory_type, solver_base_type,
solver_impl_type> (factory, "RCG", out, verbose);
}
{
typedef Belos::MinresSolMgr<scalar_type, MV, OP> solver_impl_type;
testCreatingSolver<factory_type, solver_base_type,
solver_impl_type> (factory, "MINRES", out, verbose);
}
{
typedef Belos::LSQRSolMgr<scalar_type, MV, OP> solver_impl_type;
testCreatingSolver<factory_type, solver_base_type,
solver_impl_type> (factory, "LSQR", out, verbose);
}
//
// Test aliases.
//
{
typedef Belos::BlockGmresSolMgr<scalar_type, MV, OP> solver_impl_type;
testCreatingSolver<factory_type, solver_base_type,
solver_impl_type> (factory, "Flexible GMRES", out, verbose);
}
{
typedef Belos::PseudoBlockCGSolMgr<scalar_type, MV, OP> solver_impl_type;
testCreatingSolver<factory_type, solver_base_type,
solver_impl_type> (factory, "CG", out, verbose);
}
{
typedef Belos::RCGSolMgr<scalar_type, MV, OP> solver_impl_type;
testCreatingSolver<factory_type, solver_base_type,
solver_impl_type> (factory, "Recycling CG", out, verbose);
}
{
typedef Belos::GCRODRSolMgr<scalar_type, MV, OP> solver_impl_type;
testCreatingSolver<factory_type, solver_base_type,
solver_impl_type> (factory, "Recycling GMRES", out, verbose);
}
{
typedef Belos::PseudoBlockGmresSolMgr<scalar_type, MV, OP> solver_impl_type;
testCreatingSolver<factory_type, solver_base_type,
solver_impl_type> (factory, "Pseudo Block GMRES", out, verbose);
}
{
typedef Belos::PseudoBlockCGSolMgr<scalar_type, MV, OP> solver_impl_type;
testCreatingSolver<factory_type, solver_base_type,
solver_impl_type> (factory, "Pseudo Block CG", out, verbose);
}
success = true;
if (comm->MyPID() == 0) {
cout << "End Result: TEST PASSED" << endl;
}
}
TEUCHOS_STANDARD_CATCH_STATEMENTS(verbose, std::cerr, success);
return ( success ? EXIT_SUCCESS : EXIT_FAILURE );
}
/// \brief Parse command-line options for this test
///
/// \param argc [in] As usual in C(++)
/// \param argv [in] As usual in C(++)
/// \param allowedToPrint [in] Whether this (MPI) process is allowed
/// to print to stdout/stderr. Different per (MPI) process.
/// \param printedHelp [out] Whether this (MPI) process printed the
/// "help" display (summary of command-line options)
///
/// \return Encapsulation of command-line options
static SeqTestParameters
parseOptions (int argc,
char* argv[],
const bool allowedToPrint,
bool& printedHelp)
{
using std::cerr;
using std::endl;
printedHelp = false;
// Command-line parameters, set to their default values.
SeqTestParameters params;
/// We really want the cache block size as a size_t, but
/// Teuchos::CommandLineProcessor doesn't offer that option.
/// So we read it in as an int, which means negative inputs
/// are possible. We check for those below in the input
/// validation phase.
//
// Fetch default value of cacheSizeHint.
int cacheSizeHintAsInt = static_cast<int> (params.cacheSizeHint);
try {
using Teuchos::CommandLineProcessor;
CommandLineProcessor cmdLineProc (/* throwExceptions=*/ true,
/* recognizeAllOptions=*/ true);
cmdLineProc.setDocString (docString);
cmdLineProc.setOption ("verify",
"noverify",
¶ms.verify,
"Test accuracy");
cmdLineProc.setOption ("benchmark",
"nobenchmark",
¶ms.benchmark,
"Test performance");
cmdLineProc.setOption ("nrows",
¶ms.numRows,
"Number of rows in the test matrix");
cmdLineProc.setOption ("ncols",
¶ms.numCols,
"Number of columns in the test matrix");
cmdLineProc.setOption ("ntrials",
¶ms.numTrials,
"Number of trials (only used when \"--benchmark\"");
#ifdef HAVE_KOKKOSCLASSIC_TSQR_COMPLEX
cmdLineProc.setOption ("complex",
"nocomplex",
¶ms.testComplex,
"Test complex arithmetic, as well as real");
#endif // HAVE_KOKKOSCLASSIC_TSQR_COMPLEX
cmdLineProc.setOption ("cache-block-size",
&cacheSizeHintAsInt,
"Cache size hint in bytes (0 means pick a reasonable default)");
cmdLineProc.setOption ("contiguous-cache-blocks",
"noncontiguous-cache-blocks",
¶ms.contiguousCacheBlocks,
"Whether cache blocks should be stored contiguously");
cmdLineProc.setOption ("field-names",
¶ms.additionalFieldNames,
"Any additional field name(s) (comma-delimited "
"string) to add to the benchmark output. Empty "
"by default. Good for things known when invoking "
"the benchmark executable, but not (easily) known "
"inside the benchmark -- e.g., environment "
"variables.");
cmdLineProc.setOption ("output-data",
¶ms.additionalData,
"Any additional data to add to the output, "
"corresponding to the above field name(s). "
"Empty by default.");
cmdLineProc.setOption ("print-field-names",
"no-print-field-names",
¶ms.printFieldNames,
"Print field names (for machine-readable output only)");
cmdLineProc.setOption ("print-trilinos-test-stuff",
"no-print-trilinos-test-stuff",
¶ms.printTrilinosTestStuff,
"Print output that makes the Trilinos test "
"framework happy (but makes benchmark results "
"parsing scripts unhappy)");
cmdLineProc.setOption ("human-readable",
"machine-readable",
¶ms.humanReadable,
"If set, make output easy to read by humans "
"(but hard to parse)");
cmdLineProc.setOption ("debug",
"nodebug",
¶ms.debug,
"Print debugging information");
cmdLineProc.parse (argc, argv);
}
catch (Teuchos::CommandLineProcessor::UnrecognizedOption& e) {
if (allowedToPrint)
cerr << "Unrecognized command-line option: " << e.what() << endl;
throw e;
}
catch (Teuchos::CommandLineProcessor::HelpPrinted& e) {
printedHelp = true;
return params; // Don't verify parameters in this case
}
// Validate command-line options. We provide default values
// for unset options, so we don't have to validate those.
if (params.numRows <= 0)
throw std::invalid_argument ("Number of rows must be positive");
else if (params.numCols <= 0)
throw std::invalid_argument ("Number of columns must be positive");
else if (params.numRows < params.numCols)
throw std::invalid_argument ("Number of rows must be >= number of columns");
else if (params.benchmark && params.numTrials < 1)
throw std::invalid_argument ("\"--benchmark\" option requires numTrials >= 1");
else
{
if (cacheSizeHintAsInt < 0)
throw std::invalid_argument ("Cache size hint must be nonnegative");
else
params.cacheSizeHint = static_cast< size_t > (cacheSizeHintAsInt);
}
return params;
}
