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;
}
int main( int argc, char* argv[] )
{
using Teuchos::CommandLineProcessor;
typedef AbstractLinAlgPack::value_type Scalar;
using MoochoPack::MoochoSolver;
using MoochoPack::MoochoThyraSolver;
bool dummySuccess = true;
Teuchos::GlobalMPISession mpiSession(&argc,&argv);
Teuchos::RCP<Teuchos::FancyOStream>
out = Teuchos::VerboseObjectBase::getDefaultOStream();
try {
Stratimikos::DefaultLinearSolverBuilder lowsfCreator;
MoochoThyraSolver solver;
//
// Get options from the command line
//
Scalar xt0 = 1.0;
Scalar xt1 = 1.0;
Scalar pt0 = 2.0;
Scalar pt1 = 0.0;
Scalar d = 10.0;
Scalar x00 = 1.0;
Scalar x01 = 1.0;
Scalar p00 = 2.0;
Scalar p01 = 0.0;
Scalar pL0 = -1e+50;
Scalar pL1 = -1e+50;
Scalar pU0 = +1e+50;
Scalar pU1 = +1e+50;
Scalar xL0 = -1e+50;
Scalar xL1 = -1e+50;
Scalar xU0 = +1e+50;
Scalar xU1 = +1e+50;
bool supportDerivs = true;
std::string extraXmlFile = "";
CommandLineProcessor clp(false); // Don't throw exceptions
lowsfCreator.setupCLP(&clp);
solver.setupCLP(&clp);
clp.setOption( "xt0", &xt0 );
clp.setOption( "xt1", &xt1 );
clp.setOption( "pt0", &pt0 );
clp.setOption( "pt1", &pt1 );
clp.setOption( "d", &d );
clp.setOption( "x00", &x00 );
clp.setOption( "x01", &x01 );
clp.setOption( "p00", &p00 );
clp.setOption( "p01", &p01 );
clp.setOption( "pL0", &pL0 );
clp.setOption( "pL1", &pL1 );
clp.setOption( "pU0", &pU0 );
clp.setOption( "pU1", &pU1 );
clp.setOption( "xL0", &xL0 );
clp.setOption( "xL1", &xL1 );
clp.setOption( "xU0", &xU0 );
clp.setOption( "xU1", &xU1 );
clp.setOption( "support-derivs", "no-support-derivs", &supportDerivs );
clp.setOption("extra-xml-file",&extraXmlFile,"File with extra XML text that will modify the initial XML read in");
std::string line("");
if(extraXmlFile.length()) {
std::ifstream myfile(extraXmlFile.c_str());
if (myfile.is_open())
{
getline (myfile,line);
solver.extraParamsXmlStringOption(line);
std::cout << line << "\n";
myfile.close();
}
}
CommandLineProcessor::EParseCommandLineReturn
parse_return = clp.parse(argc,argv,&std::cerr);
if( parse_return != CommandLineProcessor::PARSE_SUCCESSFUL )
return parse_return;
lowsfCreator.readParameters(out.get());
solver.readParameters(out.get());
//
// Create the NLP
//
// Create the EpetraExt::ModelEvaluator object
Teuchos::RCP<EpetraModelEval4DOpt>
epetraModel = Teuchos::rcp(new EpetraModelEval4DOpt(xt0,xt1,pt0,pt1,d,x00,x01,p00,p01));
epetraModel->setSupportDerivs(supportDerivs);
epetraModel->set_p_bounds(pL0,pL1,pU0,pU1);
epetraModel->set_x_bounds(xL0,xL1,xU0,xU1);
// Create the Thyra::EpetraModelEvaluator object
Teuchos::RCP<Thyra::LinearOpWithSolveFactoryBase<double> >
lowsFactory = lowsfCreator.createLinearSolveStrategy("");
Teuchos::RCP<Thyra::EpetraModelEvaluator>
epetraThyraModel = Teuchos::rcp(new Thyra::EpetraModelEvaluator());
epetraThyraModel->initialize(epetraModel,lowsFactory);
//
// 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 final solution if requested
solver.writeFinalSolution(out.get());
// Write the parameters that where read
lowsfCreator.writeParamsFile(*lowsFactory);
solver.writeParamsFile();
//
// Return the solution status (0 if sucessfull)
//
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);
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;
}