Deck* chance_deck() {
Deck* ChanceDeck = new Deck;
std::vector<uint> utils(2);
utils[0] = 12;
utils[1] = 28;
std::vector<uint> rails(4);
for (uint i = 0; i < rails.size(); i++)
rails[i] = 5 + i*10;
ChanceDeck->insert_card(new AdvanceTo(0)); // Go
ChanceDeck->insert_card(new AdvanceTo(24)); // Illinois
ChanceDeck->insert_card(new AdvanceTo(11)); // StCharles
ChanceDeck->insert_card(new AdvanceTo(5)); // Reading
ChanceDeck->insert_card(new AdvanceTo(39)); // BoardWalk
ChanceDeck->insert_card(new AdvanceTo(utils)); // Utilities
ChanceDeck->insert_card(new AdvanceTo(rails)); // Rails
ChanceDeck->insert_card(new GoDirToJail); // Go to jail card
ChanceDeck->insert_card(new MoveBack3); // Move back 3 spaces
for (uint i = 0; i < 6; i++) ChanceDeck->insert_card(new Card);
ChanceDeck->shuffle();
return ChanceDeck;
}
void
GenericEpetraProblem::outputResults(const NOX::Solver::Generic& solver,
Teuchos::ParameterList& printParams)
{
// Output the parameter list
NOX::Utils utils(printParams);
if (utils.isPrintType(NOX::Utils::Parameters)) {
cout << endl << "Final Parameters" << endl
<< "****************" << endl;
solver.getList().print(cout);
cout << endl;
}
// Get the Epetra_Vector with the final solution from the solver
const NOX::Epetra::Group& finalGroup =
dynamic_cast<const NOX::Epetra::Group&>(solver.getSolutionGroup());
const Epetra_Vector& finalSolution =
(dynamic_cast<const NOX::Epetra::Vector&>
(finalGroup.getX())).getEpetraVector();
// Print solution
char file_name[25];
FILE *ifp;
int NumMyElements = finalSolution.Map().NumMyElements();
(void) sprintf(file_name, "output.%d",finalSolution.Map().Comm().MyPID());
ifp = fopen(file_name, "w");
for (int i=0; i<NumMyElements; i++)
fprintf(ifp,"%d %E\n",finalSolution.Map().MinMyGID()+i,finalSolution[i]);
fclose(ifp);
}
void
nsEditingSession::RestoreAnimationMode(nsIDOMWindow *aWindow)
{
if (!mInteractive)
{
nsCOMPtr<nsIDOMWindowUtils> utils(do_GetInterface(aWindow));
if (utils)
utils->SetImageAnimationMode(mImageAnimationMode);
}
}
bool Register::user_register(std::string username, std::string password) {
std::shared_ptr<DatabaseOperator>databaseOperator(new DatabaseOperator());
std::shared_ptr<User>user(new User());
user->set_username(username);
user = databaseOperator->userManager->get_user(user, 1);
if (user->get_status()!=0){
return false;
}
std::shared_ptr<Utils>utils(new Utils());
std::string uuid = utils->uuid();
user->set_username(username);
user->set_password(cppcms::util::md5hex(password));
user->set_usercode(uuid);
user->set_status(1);
bool result = databaseOperator->userManager->save_user(user);
return result;
}
/***********************************************************
* Constructor.
***********************************************************/
HTrackerItem::HTrackerItem(const char* name
,const char* address
,uint16 port
,uint16 users
,const char* desc
,bool isTracker
,HTrackerItem *parent)
:CLVEasyItem(0, isTracker,0,16.0)
,fParentItem(parent)
{
BBitmap *bitmap = NULL;
fConnection = NULL;
fIsShown = false;
fIsTracker = isTracker;
BResources *rsrc = BApplication::AppResources();
ResourceUtils utils(rsrc);
if(isTracker == false)
utils.GetBitmapResource('BBMP',"BMP:SERVER",&bitmap);
else
utils.GetBitmapResource('BBMP',"BMP:ADDTRACKER",&bitmap);
this->SetColumnContent(1,bitmap);
delete bitmap;
this->SetColumnContent(2,name);
this->SetColumnContent(3,address);
BString Users;
uint32 port32 = port;
Users << port32;
this->SetColumnContent(4,Users.String());
Users = "";
if(isTracker == false)
{
port32 = users;
Users << port32;
}else
Users = "";
this->SetColumnContent(5,Users.String());
this->SetColumnContent(6,desc);
}
Deck* comm_deck() {
Deck* CommDeck = new Deck;
std::vector<uint> utils(2);
utils[0] = 12;
utils[1] = 28;
std::vector<uint> rails(4);
for (uint i = 0; i < rails.size(); i++)
rails[i] = 5 + i*10;
CommDeck->insert_card(new AdvanceTo(0)); // Go
CommDeck->insert_card(new GoDirToJail); // Go to jail card
for (uint i = 0; i < 13; i++) CommDeck->insert_card(new Card);
CommDeck->shuffle();
return CommDeck;
}
int main(int argc, char *argv[]) {
// Initialize MPI
#ifdef HAVE_MPI
MPI_Init(&argc,&argv);
#endif
int MyPID;
try {
// Create a communicator for Epetra objects
Teuchos::RCP<const Epetra_Comm> globalComm;
#ifdef HAVE_MPI
globalComm = Teuchos::rcp(new Epetra_MpiComm(MPI_COMM_WORLD));
#else
globalComm = Teuchos::rcp(new Epetra_SerialComm);
#endif
MyPID = globalComm->MyPID();
// Create Stochastic Galerkin basis and expansion
int p = 5;
Teuchos::Array< Teuchos::RCP<const Stokhos::OneDOrthogPolyBasis<int,double> > > bases(1);
bases[0] = Teuchos::rcp(new Stokhos::LegendreBasis<int,double>(p));
Teuchos::RCP<const Stokhos::CompletePolynomialBasis<int,double> > basis =
Teuchos::rcp(new Stokhos::CompletePolynomialBasis<int,double>(bases));
int sz = basis->size();
Teuchos::RCP<Stokhos::Sparse3Tensor<int,double> > Cijk;
Cijk = basis->computeTripleProductTensor();
Teuchos::RCP<Stokhos::OrthogPolyExpansion<int,double> > expansion =
Teuchos::rcp(new Stokhos::AlgebraicOrthogPolyExpansion<int,double>(basis,
Cijk));
if (MyPID == 0)
std::cout << "Stochastic Galerkin expansion size = " << sz << std::endl;
// Create stochastic parallel distribution
int num_spatial_procs = -1;
Teuchos::ParameterList parallelParams;
parallelParams.set("Number of Spatial Processors", num_spatial_procs);
Teuchos::RCP<Stokhos::ParallelData> sg_parallel_data =
Teuchos::rcp(new Stokhos::ParallelData(basis, Cijk, globalComm,
parallelParams));
Teuchos::RCP<const EpetraExt::MultiComm> sg_comm =
sg_parallel_data->getMultiComm();
Teuchos::RCP<const Epetra_Comm> app_comm =
sg_parallel_data->getSpatialComm();
// Create application model evaluator
Teuchos::RCP<EpetraExt::ModelEvaluator> model =
Teuchos::rcp(new SimpleME(app_comm));
// Setup stochastic Galerkin algorithmic parameters
Teuchos::RCP<Teuchos::ParameterList> sgParams =
Teuchos::rcp(new Teuchos::ParameterList);
sgParams->set("Jacobian Method", "Matrix Free");
sgParams->set("Mean Preconditioner Type", "Ifpack");
// Create stochastic Galerkin model evaluator
Teuchos::RCP<Stokhos::SGModelEvaluator> sg_model =
Teuchos::rcp(new Stokhos::SGModelEvaluator(model, basis, Teuchos::null,
expansion, sg_parallel_data,
sgParams));
// Stochastic Galerkin initial guess
// Set the mean to the deterministic initial guess, higher-order terms
// to zero
Teuchos::RCP<Stokhos::EpetraVectorOrthogPoly> x_init_sg =
sg_model->create_x_sg();
x_init_sg->init(0.0);
(*x_init_sg)[0] = *(model->get_x_init());
sg_model->set_x_sg_init(*x_init_sg);
// Stochastic Galerkin parameters
// Linear expansion with the mean given by the deterministic initial
// parameter values, linear terms equal to 1, and higher order terms
// equal to zero.
Teuchos::RCP<Stokhos::EpetraVectorOrthogPoly> p_init_sg =
sg_model->create_p_sg(0);
p_init_sg->init(0.0);
(*p_init_sg)[0] = *(model->get_p_init(0));
for (int i=0; i<model->get_p_map(0)->NumMyElements(); i++)
(*p_init_sg)[i+1][i] = 1.0;
sg_model->set_p_sg_init(0, *p_init_sg);
std::cout << "Stochatic Galerkin parameter expansion = " << std::endl
<< *p_init_sg << std::endl;
// Set up NOX parameters
Teuchos::RCP<Teuchos::ParameterList> noxParams =
Teuchos::rcp(new Teuchos::ParameterList);
// Set the nonlinear solver method
noxParams->set("Nonlinear Solver", "Line Search Based");
// Set the printing parameters in the "Printing" sublist
Teuchos::ParameterList& printParams = noxParams->sublist("Printing");
printParams.set("MyPID", MyPID);
printParams.set("Output Precision", 3);
printParams.set("Output Processor", 0);
printParams.set("Output Information",
NOX::Utils::OuterIteration +
NOX::Utils::OuterIterationStatusTest +
NOX::Utils::InnerIteration +
//NOX::Utils::Parameters +
//NOX::Utils::Details +
NOX::Utils::LinearSolverDetails +
NOX::Utils::Warning +
NOX::Utils::Error);
// Create printing utilities
NOX::Utils utils(printParams);
// Sublist for line search
Teuchos::ParameterList& searchParams = noxParams->sublist("Line Search");
searchParams.set("Method", "Full Step");
// Sublist for direction
Teuchos::ParameterList& dirParams = noxParams->sublist("Direction");
dirParams.set("Method", "Newton");
Teuchos::ParameterList& newtonParams = dirParams.sublist("Newton");
newtonParams.set("Forcing Term Method", "Constant");
// Sublist for linear solver for the Newton method
Teuchos::ParameterList& lsParams = newtonParams.sublist("Linear Solver");
lsParams.set("Aztec Solver", "GMRES");
lsParams.set("Max Iterations", 100);
lsParams.set("Size of Krylov Subspace", 100);
lsParams.set("Tolerance", 1e-4);
lsParams.set("Output Frequency", 10);
lsParams.set("Preconditioner", "Ifpack");
// Sublist for convergence tests
Teuchos::ParameterList& statusParams = noxParams->sublist("Status Tests");
statusParams.set("Test Type", "Combo");
statusParams.set("Number of Tests", 2);
statusParams.set("Combo Type", "OR");
Teuchos::ParameterList& normF = statusParams.sublist("Test 0");
normF.set("Test Type", "NormF");
normF.set("Tolerance", 1e-10);
normF.set("Scale Type", "Scaled");
Teuchos::ParameterList& maxIters = statusParams.sublist("Test 1");
maxIters.set("Test Type", "MaxIters");
maxIters.set("Maximum Iterations", 10);
// Create NOX interface
Teuchos::RCP<NOX::Epetra::ModelEvaluatorInterface> nox_interface =
Teuchos::rcp(new NOX::Epetra::ModelEvaluatorInterface(sg_model));
// Create NOX linear system object
Teuchos::RCP<const Epetra_Vector> u = sg_model->get_x_init();
Teuchos::RCP<Epetra_Operator> A = sg_model->create_W();
Teuchos::RCP<NOX::Epetra::Interface::Required> iReq = nox_interface;
Teuchos::RCP<NOX::Epetra::Interface::Jacobian> iJac = nox_interface;
Teuchos::RCP<NOX::Epetra::LinearSystemAztecOO> linsys;
Teuchos::RCP<Epetra_Operator> M = sg_model->create_WPrec()->PrecOp;
Teuchos::RCP<NOX::Epetra::Interface::Preconditioner> iPrec = nox_interface;
lsParams.set("Preconditioner", "User Defined");
linsys =
Teuchos::rcp(new NOX::Epetra::LinearSystemAztecOO(printParams, lsParams,
iJac, A, iPrec, M,
*u));
// linsys =
// Teuchos::rcp(new NOX::Epetra::LinearSystemAztecOO(printParams, lsParams,
// iReq, iJac, A, *u));
// Build NOX group
Teuchos::RCP<NOX::Epetra::Group> grp =
Teuchos::rcp(new NOX::Epetra::Group(printParams, iReq, *u, linsys));
// Create the Solver convergence test
Teuchos::RCP<NOX::StatusTest::Generic> statusTests =
NOX::StatusTest::buildStatusTests(statusParams, utils);
// Create the solver
Teuchos::RCP<NOX::Solver::Generic> solver =
NOX::Solver::buildSolver(grp, statusTests, noxParams);
// Solve the system
NOX::StatusTest::StatusType status = solver->solve();
// Get final solution
const NOX::Epetra::Group& finalGroup =
dynamic_cast<const NOX::Epetra::Group&>(solver->getSolutionGroup());
const Epetra_Vector& finalSolution =
(dynamic_cast<const NOX::Epetra::Vector&>(finalGroup.getX())).getEpetraVector();
// Convert block Epetra_Vector to orthogonal polynomial of Epetra_Vector's
Teuchos::RCP<Stokhos::EpetraVectorOrthogPoly> x_sg =
sg_model->create_x_sg(View, &finalSolution);
utils.out() << "Final Solution (block vector) = " << std::endl;
std::cout << finalSolution << std::endl;
utils.out() << "Final Solution (polynomial) = " << std::endl;
std::cout << *x_sg << std::endl;
if (status == NOX::StatusTest::Converged && MyPID == 0)
utils.out() << "Example Passed!" << std::endl;
}
catch (std::exception& e) {
std::cout << e.what() << std::endl;
}
catch (string& s) {
std::cout << s << std::endl;
}
catch (char *s) {
std::cout << s << std::endl;
}
catch (...) {
std::cout << "Caught unknown exception!" <<std:: endl;
}
#ifdef HAVE_MPI
MPI_Finalize() ;
#endif
}
/*---------------------------------------------------------------------------
SetupEditorOnWindow
nsIEditor setupEditorOnWindow (in nsIDOMWindow aWindow);
----------------------------------------------------------------------------*/
NS_IMETHODIMP
nsEditingSession::SetupEditorOnWindow(nsIDOMWindow *aWindow)
{
mDoneSetup = true;
nsresult rv;
//MIME CHECKING
//must get the content type
// Note: the doc gets this from the network channel during StartPageLoad,
// so we don't have to get it from there ourselves
nsCOMPtr<nsIDOMDocument> doc;
nsCAutoString mimeCType;
//then lets check the mime type
if (NS_SUCCEEDED(aWindow->GetDocument(getter_AddRefs(doc))) && doc)
{
nsAutoString mimeType;
if (NS_SUCCEEDED(doc->GetContentType(mimeType)))
AppendUTF16toUTF8(mimeType, mimeCType);
if (IsSupportedTextType(mimeCType.get()))
{
mEditorType.AssignLiteral("text");
mimeCType = "text/plain";
}
else if (!mimeCType.EqualsLiteral("text/html") &&
!mimeCType.EqualsLiteral("application/xhtml+xml"))
{
// Neither an acceptable text or html type.
mEditorStatus = eEditorErrorCantEditMimeType;
// Turn editor into HTML -- we will load blank page later
mEditorType.AssignLiteral("html");
mimeCType.AssignLiteral("text/html");
}
// Flush out frame construction to make sure that the subframe's
// presshell is set up if it needs to be.
nsCOMPtr<nsIDocument> document = do_QueryInterface(doc);
if (document) {
document->FlushPendingNotifications(Flush_Frames);
if (mMakeWholeDocumentEditable) {
document->SetEditableFlag(true);
nsCOMPtr<nsIHTMLDocument> htmlDocument = do_QueryInterface(document);
if (htmlDocument) {
// Enable usage of the execCommand API
htmlDocument->SetEditingState(nsIHTMLDocument::eDesignMode);
}
}
}
}
bool needHTMLController = false;
const char *classString = "@mozilla.org/editor/htmleditor;1";
if (mEditorType.EqualsLiteral("textmail"))
{
mEditorFlags = nsIPlaintextEditor::eEditorPlaintextMask |
nsIPlaintextEditor::eEditorEnableWrapHackMask |
nsIPlaintextEditor::eEditorMailMask;
}
else if (mEditorType.EqualsLiteral("text"))
{
mEditorFlags = nsIPlaintextEditor::eEditorPlaintextMask |
nsIPlaintextEditor::eEditorEnableWrapHackMask;
}
else if (mEditorType.EqualsLiteral("htmlmail"))
{
if (mimeCType.EqualsLiteral("text/html"))
{
needHTMLController = true;
mEditorFlags = nsIPlaintextEditor::eEditorMailMask;
}
else //set the flags back to textplain.
mEditorFlags = nsIPlaintextEditor::eEditorPlaintextMask |
nsIPlaintextEditor::eEditorEnableWrapHackMask;
}
else // Defaulted to html
{
needHTMLController = true;
}
if (mInteractive) {
mEditorFlags |= nsIPlaintextEditor::eEditorAllowInteraction;
}
// make the UI state maintainer
mStateMaintainer = new nsComposerCommandsUpdater();
// now init the state maintainer
// This allows notification of error state
// even if we don't create an editor
rv = mStateMaintainer->Init(aWindow);
NS_ENSURE_SUCCESS(rv, rv);
if (mEditorStatus != eEditorCreationInProgress)
{
mStateMaintainer->NotifyDocumentCreated();
return NS_ERROR_FAILURE;
}
// Create editor and do other things
// only if we haven't found some error above,
nsIDocShell *docShell = GetDocShellFromWindow(aWindow);
NS_ENSURE_TRUE(docShell, NS_ERROR_FAILURE);
if (!mInteractive) {
// Disable animation of images in this document:
nsCOMPtr<nsIDOMWindowUtils> utils(do_GetInterface(aWindow));
NS_ENSURE_TRUE(utils, NS_ERROR_FAILURE);
rv = utils->GetImageAnimationMode(&mImageAnimationMode);
NS_ENSURE_SUCCESS(rv, rv);
utils->SetImageAnimationMode(imgIContainer::kDontAnimMode);
}
// create and set editor
nsCOMPtr<nsIEditorDocShell> editorDocShell = do_QueryInterface(docShell, &rv);
NS_ENSURE_SUCCESS(rv, rv);
// Try to reuse an existing editor
nsCOMPtr<nsIEditor> editor = do_QueryReferent(mExistingEditor);
if (editor) {
editor->PreDestroy(false);
} else {
editor = do_CreateInstance(classString, &rv);
NS_ENSURE_SUCCESS(rv, rv);
mExistingEditor = do_GetWeakReference(editor);
}
// set the editor on the docShell. The docShell now owns it.
rv = editorDocShell->SetEditor(editor);
NS_ENSURE_SUCCESS(rv, rv);
// setup the HTML editor command controller
if (needHTMLController)
{
// The third controller takes an nsIEditor as the context
rv = SetupEditorCommandController("@mozilla.org/editor/htmleditorcontroller;1",
aWindow, editor,
&mHTMLCommandControllerId);
NS_ENSURE_SUCCESS(rv, rv);
}
// Set mimetype on editor
rv = editor->SetContentsMIMEType(mimeCType.get());
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsIContentViewer> contentViewer;
rv = docShell->GetContentViewer(getter_AddRefs(contentViewer));
NS_ENSURE_SUCCESS(rv, rv);
NS_ENSURE_TRUE(contentViewer, NS_ERROR_FAILURE);
nsCOMPtr<nsIDOMDocument> domDoc;
rv = contentViewer->GetDOMDocument(getter_AddRefs(domDoc));
NS_ENSURE_SUCCESS(rv, rv);
NS_ENSURE_TRUE(domDoc, NS_ERROR_FAILURE);
// Set up as a doc state listener
// Important! We must have this to broadcast the "obs_documentCreated" message
rv = editor->AddDocumentStateListener(mStateMaintainer);
NS_ENSURE_SUCCESS(rv, rv);
rv = editor->Init(domDoc, nullptr /* root content */,
nullptr, mEditorFlags);
NS_ENSURE_SUCCESS(rv, rv);
nsCOMPtr<nsISelection> selection;
editor->GetSelection(getter_AddRefs(selection));
nsCOMPtr<nsISelectionPrivate> selPriv = do_QueryInterface(selection);
NS_ENSURE_TRUE(selPriv, NS_ERROR_FAILURE);
rv = selPriv->AddSelectionListener(mStateMaintainer);
NS_ENSURE_SUCCESS(rv, rv);
// and as a transaction listener
nsCOMPtr<nsITransactionManager> txnMgr;
editor->GetTransactionManager(getter_AddRefs(txnMgr));
if (txnMgr)
txnMgr->AddListener(mStateMaintainer);
// Set context on all controllers to be the editor
rv = SetEditorOnControllers(aWindow, editor);
NS_ENSURE_SUCCESS(rv, rv);
// Everything went fine!
mEditorStatus = eEditorOK;
// This will trigger documentCreation notification
return editor->PostCreate();
}
nsresult
nsEditingSession::ReattachToWindow(nsIDOMWindow* aWindow)
{
NS_ENSURE_TRUE(mDoneSetup, NS_OK);
NS_ASSERTION(mStateMaintainer, "mStateMaintainer should exist.");
// Imitate nsEditorDocShell::MakeEditable() to reattach the
// old editor ot the window.
nsresult rv;
nsIDocShell *docShell = GetDocShellFromWindow(aWindow);
NS_ENSURE_TRUE(docShell, NS_ERROR_FAILURE);
mDocShell = do_GetWeakReference(docShell);
// Disable plugins.
if (!mInteractive)
{
rv = DisableJSAndPlugins(aWindow);
NS_ENSURE_SUCCESS(rv, rv);
}
// Tells embedder that startup is in progress.
mEditorStatus = eEditorCreationInProgress;
// Adds back web progress listener.
rv = PrepareForEditing(aWindow);
NS_ENSURE_SUCCESS(rv, rv);
// Setup the command controllers again.
rv = SetupEditorCommandController("@mozilla.org/editor/editingcontroller;1",
aWindow,
static_cast<nsIEditingSession*>(this),
&mBaseCommandControllerId);
NS_ENSURE_SUCCESS(rv, rv);
rv = SetupEditorCommandController("@mozilla.org/editor/editordocstatecontroller;1",
aWindow,
static_cast<nsIEditingSession*>(this),
&mDocStateControllerId);
NS_ENSURE_SUCCESS(rv, rv);
if (mStateMaintainer)
mStateMaintainer->Init(aWindow);
// Get editor
nsCOMPtr<nsIEditor> editor;
rv = GetEditorForWindow(aWindow, getter_AddRefs(editor));
NS_ENSURE_TRUE(editor, NS_ERROR_FAILURE);
if (!mInteractive)
{
// Disable animation of images in this document:
nsCOMPtr<nsIDOMWindowUtils> utils(do_GetInterface(aWindow));
NS_ENSURE_TRUE(utils, NS_ERROR_FAILURE);
rv = utils->GetImageAnimationMode(&mImageAnimationMode);
NS_ENSURE_SUCCESS(rv, rv);
utils->SetImageAnimationMode(imgIContainer::kDontAnimMode);
}
// The third controller takes an nsIEditor as the context
rv = SetupEditorCommandController("@mozilla.org/editor/htmleditorcontroller;1",
aWindow, editor,
&mHTMLCommandControllerId);
NS_ENSURE_SUCCESS(rv, rv);
// Set context on all controllers to be the editor
rv = SetEditorOnControllers(aWindow, editor);
NS_ENSURE_SUCCESS(rv, rv);
#ifdef DEBUG
{
bool isEditable;
rv = WindowIsEditable(aWindow, &isEditable);
NS_ENSURE_SUCCESS(rv, rv);
NS_ASSERTION(isEditable, "Window is not editable after reattaching editor.");
}
#endif // DEBUG
return NS_OK;
}
int main(int argc, char *argv[]) {
int n = 32; // spatial discretization (per dimension)
int num_KL = 2; // number of KL terms
int p = 3; // polynomial order
double mu = 0.1; // mean of exponential random field
double s = 0.2; // std. dev. of exponential r.f.
bool nonlinear_expansion = false; // nonlinear expansion of diffusion coeff
// (e.g., log-normal)
bool matrix_free = true; // use matrix-free stochastic operator
bool symmetric = false; // use symmetric formulation
double g_mean_exp = 0.172988; // expected response mean
double g_std_dev_exp = 0.0380007; // expected response std. dev.
double g_tol = 1e-6; // tolerance on determining success
// Initialize MPI
#ifdef HAVE_MPI
MPI_Init(&argc,&argv);
#endif
int MyPID;
try {
{
TEUCHOS_FUNC_TIME_MONITOR("Total PCE Calculation Time");
// Create a communicator for Epetra objects
Teuchos::RCP<const Epetra_Comm> globalComm;
#ifdef HAVE_MPI
globalComm = Teuchos::rcp(new Epetra_MpiComm(MPI_COMM_WORLD));
#else
globalComm = Teuchos::rcp(new Epetra_SerialComm);
#endif
MyPID = globalComm->MyPID();
// Create Stochastic Galerkin basis and expansion
Teuchos::Array< Teuchos::RCP<const Stokhos::OneDOrthogPolyBasis<int,double> > > bases(num_KL);
for (int i=0; i<num_KL; i++)
bases[i] = Teuchos::rcp(new Stokhos::LegendreBasis<int,double>(p, true));
Teuchos::RCP<const Stokhos::CompletePolynomialBasis<int,double> > basis =
Teuchos::rcp(new Stokhos::CompletePolynomialBasis<int,double>(bases));
int sz = basis->size();
Teuchos::RCP<Stokhos::Sparse3Tensor<int,double> > Cijk;
if (nonlinear_expansion)
Cijk = basis->computeTripleProductTensor();
else
Cijk = basis->computeLinearTripleProductTensor();
Teuchos::RCP<Stokhos::OrthogPolyExpansion<int,double> > expansion =
Teuchos::rcp(new Stokhos::AlgebraicOrthogPolyExpansion<int,double>(basis,
Cijk));
if (MyPID == 0)
std::cout << "Stochastic Galerkin expansion size = " << sz << std::endl;
// Create stochastic parallel distribution
int num_spatial_procs = -1;
if (argc > 1)
num_spatial_procs = std::atoi(argv[1]);
Teuchos::ParameterList parallelParams;
parallelParams.set("Number of Spatial Processors", num_spatial_procs);
Teuchos::RCP<Stokhos::ParallelData> sg_parallel_data =
Teuchos::rcp(new Stokhos::ParallelData(basis, Cijk, globalComm,
parallelParams));
Teuchos::RCP<const EpetraExt::MultiComm> sg_comm =
sg_parallel_data->getMultiComm();
Teuchos::RCP<const Epetra_Comm> app_comm =
sg_parallel_data->getSpatialComm();
// Create application
Teuchos::RCP<twoD_diffusion_ME> model =
Teuchos::rcp(new twoD_diffusion_ME(app_comm, n, num_KL, mu, s, basis,
nonlinear_expansion, symmetric));
// Setup stochastic Galerkin algorithmic parameters
Teuchos::RCP<Teuchos::ParameterList> sgParams =
Teuchos::rcp(new Teuchos::ParameterList);
Teuchos::ParameterList& sgOpParams =
sgParams->sublist("SG Operator");
Teuchos::ParameterList& sgPrecParams =
sgParams->sublist("SG Preconditioner");
if (!nonlinear_expansion) {
sgParams->set("Parameter Expansion Type", "Linear");
sgParams->set("Jacobian Expansion Type", "Linear");
}
if (matrix_free) {
sgOpParams.set("Operator Method", "Matrix Free");
sgPrecParams.set("Preconditioner Method", "Approximate Gauss-Seidel");
sgPrecParams.set("Symmetric Gauss-Seidel", symmetric);
sgPrecParams.set("Mean Preconditioner Type", "ML");
Teuchos::ParameterList& precParams =
sgPrecParams.sublist("Mean Preconditioner Parameters");
precParams.set("default values", "SA");
precParams.set("ML output", 0);
precParams.set("max levels",5);
precParams.set("increasing or decreasing","increasing");
precParams.set("aggregation: type", "Uncoupled");
precParams.set("smoother: type","ML symmetric Gauss-Seidel");
precParams.set("smoother: sweeps",2);
precParams.set("smoother: pre or post", "both");
precParams.set("coarse: max size", 200);
#ifdef HAVE_ML_AMESOS
precParams.set("coarse: type","Amesos-KLU");
#else
precParams.set("coarse: type","Jacobi");
#endif
}
else {
sgOpParams.set("Operator Method", "Fully Assembled");
sgPrecParams.set("Preconditioner Method", "None");
}
// Create stochastic Galerkin model evaluator
Teuchos::RCP<Stokhos::SGModelEvaluator> sg_model =
Teuchos::rcp(new Stokhos::SGModelEvaluator(model, basis, Teuchos::null,
expansion, sg_parallel_data,
sgParams));
// Set up stochastic parameters
// The current implementation of the model doesn't actually use these
// values, but is hard-coded to certain uncertainty models
Teuchos::Array<double> point(num_KL, 1.0);
Teuchos::Array<double> basis_vals(sz);
basis->evaluateBases(point, basis_vals);
Teuchos::RCP<Stokhos::EpetraVectorOrthogPoly> sg_p_init =
sg_model->create_p_sg(0);
for (int i=0; i<num_KL; i++) {
sg_p_init->term(i,0)[i] = 0.0;
sg_p_init->term(i,1)[i] = 1.0 / basis_vals[i+1];
}
sg_model->set_p_sg_init(0, *sg_p_init);
// Setup stochastic initial guess
Teuchos::RCP<Stokhos::EpetraVectorOrthogPoly> sg_x_init =
sg_model->create_x_sg();
sg_x_init->init(0.0);
sg_model->set_x_sg_init(*sg_x_init);
// Set up NOX parameters
Teuchos::RCP<Teuchos::ParameterList> noxParams =
Teuchos::rcp(new Teuchos::ParameterList);
// Set the nonlinear solver method
noxParams->set("Nonlinear Solver", "Line Search Based");
// Set the printing parameters in the "Printing" sublist
Teuchos::ParameterList& printParams = noxParams->sublist("Printing");
printParams.set("MyPID", MyPID);
printParams.set("Output Precision", 3);
printParams.set("Output Processor", 0);
printParams.set("Output Information",
NOX::Utils::OuterIteration +
NOX::Utils::OuterIterationStatusTest +
NOX::Utils::InnerIteration +
NOX::Utils::LinearSolverDetails +
NOX::Utils::Warning +
NOX::Utils::Error);
// Create printing utilities
NOX::Utils utils(printParams);
// Sublist for line search
Teuchos::ParameterList& searchParams = noxParams->sublist("Line Search");
searchParams.set("Method", "Full Step");
// Sublist for direction
Teuchos::ParameterList& dirParams = noxParams->sublist("Direction");
dirParams.set("Method", "Newton");
Teuchos::ParameterList& newtonParams = dirParams.sublist("Newton");
newtonParams.set("Forcing Term Method", "Constant");
// Sublist for linear solver for the Newton method
Teuchos::ParameterList& lsParams = newtonParams.sublist("Linear Solver");
if (symmetric)
lsParams.set("Aztec Solver", "CG");
else
lsParams.set("Aztec Solver", "GMRES");
lsParams.set("Max Iterations", 1000);
lsParams.set("Size of Krylov Subspace", 100);
lsParams.set("Tolerance", 1e-12);
lsParams.set("Output Frequency", 1);
if (matrix_free)
lsParams.set("Preconditioner", "User Defined");
else {
lsParams.set("Preconditioner", "ML");
Teuchos::ParameterList& precParams =
lsParams.sublist("ML");
ML_Epetra::SetDefaults("DD", precParams);
lsParams.set("Write Linear System", false);
}
// Sublist for convergence tests
Teuchos::ParameterList& statusParams = noxParams->sublist("Status Tests");
statusParams.set("Test Type", "Combo");
statusParams.set("Number of Tests", 2);
statusParams.set("Combo Type", "OR");
Teuchos::ParameterList& normF = statusParams.sublist("Test 0");
normF.set("Test Type", "NormF");
normF.set("Tolerance", 1e-10);
normF.set("Scale Type", "Scaled");
Teuchos::ParameterList& maxIters = statusParams.sublist("Test 1");
maxIters.set("Test Type", "MaxIters");
maxIters.set("Maximum Iterations", 1);
// Create NOX interface
Teuchos::RCP<NOX::Epetra::ModelEvaluatorInterface> nox_interface =
Teuchos::rcp(new NOX::Epetra::ModelEvaluatorInterface(sg_model));
// Create NOX linear system object
Teuchos::RCP<const Epetra_Vector> u = sg_model->get_x_init();
Teuchos::RCP<Epetra_Operator> A = sg_model->create_W();
Teuchos::RCP<NOX::Epetra::Interface::Required> iReq = nox_interface;
Teuchos::RCP<NOX::Epetra::Interface::Jacobian> iJac = nox_interface;
Teuchos::RCP<NOX::Epetra::LinearSystemAztecOO> linsys;
if (matrix_free) {
Teuchos::RCP<Epetra_Operator> M = sg_model->create_WPrec()->PrecOp;
Teuchos::RCP<NOX::Epetra::Interface::Preconditioner> iPrec = nox_interface;
linsys =
Teuchos::rcp(new NOX::Epetra::LinearSystemAztecOO(printParams, lsParams,
iJac, A, iPrec, M,
*u));
}
else {
linsys =
Teuchos::rcp(new NOX::Epetra::LinearSystemAztecOO(printParams, lsParams,
iReq, iJac, A,
*u));
}
// Build NOX group
Teuchos::RCP<NOX::Epetra::Group> grp =
Teuchos::rcp(new NOX::Epetra::Group(printParams, iReq, *u, linsys));
// Create the Solver convergence test
Teuchos::RCP<NOX::StatusTest::Generic> statusTests =
NOX::StatusTest::buildStatusTests(statusParams, utils);
// Create the solver
Teuchos::RCP<NOX::Solver::Generic> solver =
NOX::Solver::buildSolver(grp, statusTests, noxParams);
// Solve the system
NOX::StatusTest::StatusType status = solver->solve();
// Get final solution
const NOX::Epetra::Group& finalGroup =
dynamic_cast<const NOX::Epetra::Group&>(solver->getSolutionGroup());
const Epetra_Vector& finalSolution =
(dynamic_cast<const NOX::Epetra::Vector&>(finalGroup.getX())).getEpetraVector();
// Save final solution to file
EpetraExt::VectorToMatrixMarketFile("nox_stochastic_solution.mm",
finalSolution);
// Save mean and variance to file
Teuchos::RCP<Stokhos::EpetraVectorOrthogPoly> sg_x_poly =
sg_model->create_x_sg(View, &finalSolution);
Epetra_Vector mean(*(model->get_x_map()));
Epetra_Vector std_dev(*(model->get_x_map()));
sg_x_poly->computeMean(mean);
sg_x_poly->computeStandardDeviation(std_dev);
EpetraExt::VectorToMatrixMarketFile("mean_gal.mm", mean);
EpetraExt::VectorToMatrixMarketFile("std_dev_gal.mm", std_dev);
// Evaluate SG responses at SG parameters
EpetraExt::ModelEvaluator::InArgs sg_inArgs = sg_model->createInArgs();
EpetraExt::ModelEvaluator::OutArgs sg_outArgs =
sg_model->createOutArgs();
Teuchos::RCP<const Epetra_Vector> sg_p = sg_model->get_p_init(1);
Teuchos::RCP<Epetra_Vector> sg_g =
Teuchos::rcp(new Epetra_Vector(*(sg_model->get_g_map(0))));
sg_inArgs.set_p(1, sg_p);
sg_inArgs.set_x(Teuchos::rcp(&finalSolution,false));
sg_outArgs.set_g(0, sg_g);
sg_model->evalModel(sg_inArgs, sg_outArgs);
// Print mean and standard deviation of response
Teuchos::RCP<Stokhos::EpetraVectorOrthogPoly> sg_g_poly =
sg_model->create_g_sg(0, View, sg_g.get());
Epetra_Vector g_mean(*(model->get_g_map(0)));
Epetra_Vector g_std_dev(*(model->get_g_map(0)));
sg_g_poly->computeMean(g_mean);
sg_g_poly->computeStandardDeviation(g_std_dev);
std::cout.precision(16);
// std::cout << "\nResponse Expansion = " << std::endl;
// std::cout.precision(12);
// sg_g_poly->print(std::cout);
std::cout << std::endl;
std::cout << "Response Mean = " << std::endl << g_mean << std::endl;
std::cout << "Response Std. Dev. = " << std::endl << g_std_dev << std::endl;
// Determine if example passed
bool passed = false;
if (status == NOX::StatusTest::Converged &&
std::abs(g_mean[0]-g_mean_exp) < g_tol &&
std::abs(g_std_dev[0]-g_std_dev_exp) < g_tol)
passed = true;
if (MyPID == 0) {
if (passed)
std::cout << "Example Passed!" << std::endl;
else
std::cout << "Example Failed!" << std::endl;
}
}
Teuchos::TimeMonitor::summarize(std::cout);
Teuchos::TimeMonitor::zeroOutTimers();
}
catch (std::exception& e) {
std::cout << e.what() << std::endl;
}
catch (string& s) {
std::cout << s << std::endl;
}
catch (char *s) {
std::cout << s << std::endl;
}
catch (...) {
std::cout << "Caught unknown exception!" <<std:: endl;
}
#ifdef HAVE_MPI
MPI_Finalize() ;
#endif
}
#include "inc.h"
#include <stdio.h>
#include "utils/utils.h"
void output(char* str){
printf("%s\n", str);
}
void outTwo(char* str){
printf("%s\n", str);
}
void outThree(char* str){
utils(str)
}
int main(int argc, char *argv[]) {
// Initialize MPI
#ifdef HAVE_MPI
MPI_Init(&argc,&argv);
#endif
// Create a communicator for Epetra objects
Teuchos::RCP<const Epetra_Comm> globalComm;
#ifdef HAVE_MPI
globalComm = Teuchos::rcp(new Epetra_MpiComm(MPI_COMM_WORLD));
#else
globalComm = Teuchos::rcp(new Epetra_SerialComm);
#endif
int MyPID = globalComm->MyPID();
try {
// Setup command line options
Teuchos::CommandLineProcessor CLP;
CLP.setDocString(
"This example runs a variety of stochastic Galerkin solvers.\n");
int n = 32;
CLP.setOption("num_mesh", &n, "Number of mesh points in each direction");
bool symmetric = false;
CLP.setOption("symmetric", "unsymmetric", &symmetric,
"Symmetric discretization");
int num_spatial_procs = -1;
CLP.setOption("num_spatial_procs", &num_spatial_procs, "Number of spatial processors (set -1 for all available procs)");
bool rebalance_stochastic_graph = false;
CLP.setOption("rebalance", "no-rebalance", &rebalance_stochastic_graph,
"Rebalance parallel stochastic graph (requires Isorropia)");
SG_RF randField = UNIFORM;
CLP.setOption("rand_field", &randField,
num_sg_rf, sg_rf_values, sg_rf_names,
"Random field type");
double mean = 0.2;
CLP.setOption("mean", &mean, "Mean");
double sigma = 0.1;
CLP.setOption("std_dev", &sigma, "Standard deviation");
double weightCut = 1.0;
CLP.setOption("weight_cut", &weightCut, "Weight cut");
int num_KL = 2;
CLP.setOption("num_kl", &num_KL, "Number of KL terms");
int p = 3;
CLP.setOption("order", &p, "Polynomial order");
bool normalize_basis = true;
CLP.setOption("normalize", "unnormalize", &normalize_basis,
"Normalize PC basis");
SG_Solver solve_method = SG_KRYLOV;
CLP.setOption("sg_solver", &solve_method,
num_sg_solver, sg_solver_values, sg_solver_names,
"SG solver method");
Krylov_Method outer_krylov_method = GMRES;
CLP.setOption("outer_krylov_method", &outer_krylov_method,
num_krylov_method, krylov_method_values, krylov_method_names,
"Outer Krylov method (for Krylov-based SG solver)");
Krylov_Solver outer_krylov_solver = AZTECOO;
CLP.setOption("outer_krylov_solver", &outer_krylov_solver,
num_krylov_solver, krylov_solver_values, krylov_solver_names,
"Outer linear solver");
double outer_tol = 1e-12;
CLP.setOption("outer_tol", &outer_tol, "Outer solver tolerance");
int outer_its = 1000;
CLP.setOption("outer_its", &outer_its, "Maximum outer iterations");
Krylov_Method inner_krylov_method = GMRES;
CLP.setOption("inner_krylov_method", &inner_krylov_method,
num_krylov_method, krylov_method_values, krylov_method_names,
"Inner Krylov method (for G-S, Jacobi, etc...)");
Krylov_Solver inner_krylov_solver = AZTECOO;
CLP.setOption("inner_krylov_solver", &inner_krylov_solver,
num_krylov_solver, krylov_solver_values, krylov_solver_names,
"Inner linear solver");
double inner_tol = 3e-13;
CLP.setOption("inner_tol", &inner_tol, "Inner solver tolerance");
int inner_its = 1000;
CLP.setOption("inner_its", &inner_its, "Maximum inner iterations");
SG_Op opMethod = MATRIX_FREE;
CLP.setOption("sg_operator_method", &opMethod,
num_sg_op, sg_op_values, sg_op_names,
"Operator method");
SG_Prec precMethod = AGS;
CLP.setOption("sg_prec_method", &precMethod,
num_sg_prec, sg_prec_values, sg_prec_names,
"Preconditioner method");
double gs_prec_tol = 1e-1;
CLP.setOption("gs_prec_tol", &gs_prec_tol, "Gauss-Seidel preconditioner tolerance");
int gs_prec_its = 1;
CLP.setOption("gs_prec_its", &gs_prec_its, "Maximum Gauss-Seidel preconditioner iterations");
CLP.parse( argc, argv );
if (MyPID == 0) {
std::cout << "Summary of command line options:" << std::endl
<< "\tnum_mesh = " << n << std::endl
<< "\tsymmetric = " << symmetric << std::endl
<< "\tnum_spatial_procs = " << num_spatial_procs << std::endl
<< "\trebalance = " << rebalance_stochastic_graph
<< std::endl
<< "\trand_field = " << sg_rf_names[randField]
<< std::endl
<< "\tmean = " << mean << std::endl
<< "\tstd_dev = " << sigma << std::endl
<< "\tweight_cut = " << weightCut << std::endl
<< "\tnum_kl = " << num_KL << std::endl
<< "\torder = " << p << std::endl
<< "\tnormalize_basis = " << normalize_basis << std::endl
<< "\tsg_solver = " << sg_solver_names[solve_method]
<< std::endl
<< "\touter_krylov_method = "
<< krylov_method_names[outer_krylov_method] << std::endl
<< "\touter_krylov_solver = "
<< krylov_solver_names[outer_krylov_solver] << std::endl
<< "\touter_tol = " << outer_tol << std::endl
<< "\touter_its = " << outer_its << std::endl
<< "\tinner_krylov_method = "
<< krylov_method_names[inner_krylov_method] << std::endl
<< "\tinner_krylov_solver = "
<< krylov_solver_names[inner_krylov_solver] << std::endl
<< "\tinner_tol = " << inner_tol << std::endl
<< "\tinner_its = " << inner_its << std::endl
<< "\tsg_operator_method = " << sg_op_names[opMethod]
<< std::endl
<< "\tsg_prec_method = " << sg_prec_names[precMethod]
<< std::endl
<< "\tgs_prec_tol = " << gs_prec_tol << std::endl
<< "\tgs_prec_its = " << gs_prec_its << std::endl;
}
bool nonlinear_expansion = false;
if (randField == UNIFORM || randField == RYS)
nonlinear_expansion = false;
else if (randField == LOGNORMAL)
nonlinear_expansion = true;
bool scaleOP = true;
{
TEUCHOS_FUNC_TIME_MONITOR("Total PCE Calculation Time");
// Create Stochastic Galerkin basis and expansion
Teuchos::Array< Teuchos::RCP<const Stokhos::OneDOrthogPolyBasis<int,double> > > bases(num_KL);
for (int i=0; i<num_KL; i++)
if (randField == UNIFORM)
bases[i] = Teuchos::rcp(new Stokhos::LegendreBasis<int,double>(p,normalize_basis));
else if (randField == RYS)
bases[i] = Teuchos::rcp(new Stokhos::RysBasis<int,double>(p,weightCut,normalize_basis));
else if (randField == LOGNORMAL)
bases[i] = Teuchos::rcp(new Stokhos::HermiteBasis<int,double>(p,normalize_basis));
// bases[i] = Teuchos::rcp(new Stokhos::DiscretizedStieltjesBasis<int,double>("beta",p,&uniform_weight,-weightCut,weightCut,true));
Teuchos::RCP<const Stokhos::CompletePolynomialBasis<int,double> > basis =
Teuchos::rcp(new Stokhos::CompletePolynomialBasis<int,double>(bases));
int sz = basis->size();
Teuchos::RCP<Stokhos::Sparse3Tensor<int,double> > Cijk;
if (nonlinear_expansion)
Cijk = basis->computeTripleProductTensor(sz);
else
Cijk = basis->computeTripleProductTensor(num_KL+1);
Teuchos::RCP<Stokhos::OrthogPolyExpansion<int,double> > expansion =
Teuchos::rcp(new Stokhos::AlgebraicOrthogPolyExpansion<int,double>(basis,
Cijk));
if (MyPID == 0)
std::cout << "Stochastic Galerkin expansion size = " << sz << std::endl;
// Create stochastic parallel distribution
Teuchos::ParameterList parallelParams;
parallelParams.set("Number of Spatial Processors", num_spatial_procs);
parallelParams.set("Rebalance Stochastic Graph",
rebalance_stochastic_graph);
Teuchos::RCP<Stokhos::ParallelData> sg_parallel_data =
Teuchos::rcp(new Stokhos::ParallelData(basis, Cijk, globalComm,
parallelParams));
Teuchos::RCP<const EpetraExt::MultiComm> sg_comm =
sg_parallel_data->getMultiComm();
Teuchos::RCP<const Epetra_Comm> app_comm =
sg_parallel_data->getSpatialComm();
// Create application
Teuchos::RCP<twoD_diffusion_ME> model =
Teuchos::rcp(new twoD_diffusion_ME(app_comm, n, num_KL, sigma,
mean, basis, nonlinear_expansion,
symmetric));
// Set up NOX parameters
Teuchos::RCP<Teuchos::ParameterList> noxParams =
Teuchos::rcp(new Teuchos::ParameterList);
// Set the nonlinear solver method
noxParams->set("Nonlinear Solver", "Line Search Based");
// Set the printing parameters in the "Printing" sublist
Teuchos::ParameterList& printParams = noxParams->sublist("Printing");
printParams.set("MyPID", MyPID);
printParams.set("Output Precision", 3);
printParams.set("Output Processor", 0);
printParams.set("Output Information",
NOX::Utils::OuterIteration +
NOX::Utils::OuterIterationStatusTest +
NOX::Utils::InnerIteration +
//NOX::Utils::Parameters +
NOX::Utils::Details +
NOX::Utils::LinearSolverDetails +
NOX::Utils::Warning +
NOX::Utils::Error);
// Create printing utilities
NOX::Utils utils(printParams);
// Sublist for line search
Teuchos::ParameterList& searchParams = noxParams->sublist("Line Search");
searchParams.set("Method", "Full Step");
// Sublist for direction
Teuchos::ParameterList& dirParams = noxParams->sublist("Direction");
dirParams.set("Method", "Newton");
Teuchos::ParameterList& newtonParams = dirParams.sublist("Newton");
newtonParams.set("Forcing Term Method", "Constant");
// Sublist for linear solver for the Newton method
Teuchos::ParameterList& lsParams = newtonParams.sublist("Linear Solver");
// Alternative linear solver list for Stratimikos
Teuchos::ParameterList& stratLinSolParams =
newtonParams.sublist("Stratimikos Linear Solver");
// Teuchos::ParameterList& noxStratParams =
// stratLinSolParams.sublist("NOX Stratimikos Options");
Teuchos::ParameterList& stratParams =
stratLinSolParams.sublist("Stratimikos");
// Sublist for convergence tests
Teuchos::ParameterList& statusParams = noxParams->sublist("Status Tests");
statusParams.set("Test Type", "Combo");
statusParams.set("Number of Tests", 2);
statusParams.set("Combo Type", "OR");
Teuchos::ParameterList& normF = statusParams.sublist("Test 0");
normF.set("Test Type", "NormF");
normF.set("Tolerance", outer_tol);
normF.set("Scale Type", "Scaled");
Teuchos::ParameterList& maxIters = statusParams.sublist("Test 1");
maxIters.set("Test Type", "MaxIters");
maxIters.set("Maximum Iterations", 1);
// Create NOX interface
Teuchos::RCP<NOX::Epetra::ModelEvaluatorInterface> det_nox_interface =
Teuchos::rcp(new NOX::Epetra::ModelEvaluatorInterface(model));
// Create NOX linear system object
Teuchos::RCP<const Epetra_Vector> det_u = model->get_x_init();
Teuchos::RCP<Epetra_Operator> det_A = model->create_W();
Teuchos::RCP<NOX::Epetra::Interface::Required> det_iReq = det_nox_interface;
Teuchos::RCP<NOX::Epetra::Interface::Jacobian> det_iJac = det_nox_interface;
Teuchos::ParameterList det_printParams;
det_printParams.set("MyPID", MyPID);
det_printParams.set("Output Precision", 3);
det_printParams.set("Output Processor", 0);
det_printParams.set("Output Information", NOX::Utils::Error);
Teuchos::ParameterList det_lsParams;
Teuchos::ParameterList& det_stratParams =
det_lsParams.sublist("Stratimikos");
if (inner_krylov_solver == AZTECOO) {
det_stratParams.set("Linear Solver Type", "AztecOO");
Teuchos::ParameterList& aztecOOParams =
det_stratParams.sublist("Linear Solver Types").sublist("AztecOO").sublist("Forward Solve");
Teuchos::ParameterList& aztecOOSettings =
aztecOOParams.sublist("AztecOO Settings");
if (inner_krylov_method == GMRES) {
aztecOOSettings.set("Aztec Solver","GMRES");
}
else if (inner_krylov_method == CG) {
aztecOOSettings.set("Aztec Solver","CG");
}
aztecOOSettings.set("Output Frequency", 0);
aztecOOSettings.set("Size of Krylov Subspace", 100);
aztecOOParams.set("Max Iterations", inner_its);
aztecOOParams.set("Tolerance", inner_tol);
Teuchos::ParameterList& verbParams =
det_stratParams.sublist("Linear Solver Types").sublist("AztecOO").sublist("VerboseObject");
verbParams.set("Verbosity Level", "none");
}
else if (inner_krylov_solver == BELOS) {
det_stratParams.set("Linear Solver Type", "Belos");
Teuchos::ParameterList& belosParams =
det_stratParams.sublist("Linear Solver Types").sublist("Belos");
Teuchos::ParameterList* belosSolverParams = NULL;
if (inner_krylov_method == GMRES || inner_krylov_method == FGMRES) {
belosParams.set("Solver Type","Block GMRES");
belosSolverParams =
&(belosParams.sublist("Solver Types").sublist("Block GMRES"));
if (inner_krylov_method == FGMRES)
belosSolverParams->set("Flexible Gmres", true);
}
else if (inner_krylov_method == CG) {
belosParams.set("Solver Type","Block CG");
belosSolverParams =
&(belosParams.sublist("Solver Types").sublist("Block CG"));
}
else if (inner_krylov_method == RGMRES) {
belosParams.set("Solver Type","GCRODR");
belosSolverParams =
&(belosParams.sublist("Solver Types").sublist("GCRODR"));
}
belosSolverParams->set("Convergence Tolerance", inner_tol);
belosSolverParams->set("Maximum Iterations", inner_its);
belosSolverParams->set("Output Frequency",0);
belosSolverParams->set("Output Style",1);
belosSolverParams->set("Verbosity",0);
Teuchos::ParameterList& verbParams = belosParams.sublist("VerboseObject");
verbParams.set("Verbosity Level", "none");
}
det_stratParams.set("Preconditioner Type", "ML");
Teuchos::ParameterList& det_ML =
det_stratParams.sublist("Preconditioner Types").sublist("ML").sublist("ML Settings");
ML_Epetra::SetDefaults("SA", det_ML);
det_ML.set("ML output", 0);
det_ML.set("max levels",5);
det_ML.set("increasing or decreasing","increasing");
det_ML.set("aggregation: type", "Uncoupled");
det_ML.set("smoother: type","ML symmetric Gauss-Seidel");
det_ML.set("smoother: sweeps",2);
det_ML.set("smoother: pre or post", "both");
det_ML.set("coarse: max size", 200);
#ifdef HAVE_ML_AMESOS
det_ML.set("coarse: type","Amesos-KLU");
#else
det_ML.set("coarse: type","Jacobi");
#endif
Teuchos::RCP<NOX::Epetra::LinearSystem> det_linsys =
Teuchos::rcp(new NOX::Epetra::LinearSystemStratimikos(
det_printParams, det_lsParams, det_iJac,
det_A, *det_u));
// Setup stochastic Galerkin algorithmic parameters
Teuchos::RCP<Teuchos::ParameterList> sgParams =
Teuchos::rcp(new Teuchos::ParameterList);
Teuchos::ParameterList& sgOpParams =
sgParams->sublist("SG Operator");
Teuchos::ParameterList& sgPrecParams =
sgParams->sublist("SG Preconditioner");
if (!nonlinear_expansion) {
sgParams->set("Parameter Expansion Type", "Linear");
sgParams->set("Jacobian Expansion Type", "Linear");
}
if (opMethod == MATRIX_FREE)
sgOpParams.set("Operator Method", "Matrix Free");
else if (opMethod == KL_MATRIX_FREE)
sgOpParams.set("Operator Method", "KL Matrix Free");
else if (opMethod == KL_REDUCED_MATRIX_FREE) {
sgOpParams.set("Operator Method", "KL Reduced Matrix Free");
if (randField == UNIFORM || randField == RYS)
sgOpParams.set("Number of KL Terms", num_KL);
else
sgOpParams.set("Number of KL Terms", basis->size());
sgOpParams.set("KL Tolerance", outer_tol);
sgOpParams.set("Sparse 3 Tensor Drop Tolerance", outer_tol);
sgOpParams.set("Do Error Tests", true);
}
else if (opMethod == FULLY_ASSEMBLED)
sgOpParams.set("Operator Method", "Fully Assembled");
else
TEUCHOS_TEST_FOR_EXCEPTION(true, std::logic_error,
"Error! Unknown operator method " << opMethod
<< "." << std::endl);
if (precMethod == MEAN) {
sgPrecParams.set("Preconditioner Method", "Mean-based");
sgPrecParams.set("Mean Preconditioner Type", "ML");
Teuchos::ParameterList& precParams =
sgPrecParams.sublist("Mean Preconditioner Parameters");
precParams = det_ML;
}
else if(precMethod == GS) {
sgPrecParams.set("Preconditioner Method", "Gauss-Seidel");
sgPrecParams.sublist("Deterministic Solver Parameters") = det_lsParams;
sgPrecParams.set("Deterministic Solver", det_linsys);
sgPrecParams.set("Max Iterations", gs_prec_its);
sgPrecParams.set("Tolerance", gs_prec_tol);
}
else if (precMethod == AGS) {
sgPrecParams.set("Preconditioner Method", "Approximate Gauss-Seidel");
if (outer_krylov_method == CG)
sgPrecParams.set("Symmetric Gauss-Seidel", true);
sgPrecParams.set("Mean Preconditioner Type", "ML");
Teuchos::ParameterList& precParams =
sgPrecParams.sublist("Mean Preconditioner Parameters");
precParams = det_ML;
}
else if (precMethod == AJ) {
sgPrecParams.set("Preconditioner Method", "Approximate Jacobi");
sgPrecParams.set("Mean Preconditioner Type", "ML");
Teuchos::ParameterList& precParams =
sgPrecParams.sublist("Mean Preconditioner Parameters");
precParams = det_ML;
Teuchos::ParameterList& jacobiOpParams =
sgPrecParams.sublist("Jacobi SG Operator");
jacobiOpParams.set("Only Use Linear Terms", true);
}
else if (precMethod == ASC) {
sgPrecParams.set("Preconditioner Method", "Approximate Schur Complement");
sgPrecParams.set("Mean Preconditioner Type", "ML");
Teuchos::ParameterList& precParams =
sgPrecParams.sublist("Mean Preconditioner Parameters");
precParams = det_ML;
}
else if (precMethod == KP) {
sgPrecParams.set("Preconditioner Method", "Kronecker Product");
sgPrecParams.set("Only Use Linear Terms", true);
sgPrecParams.set("Mean Preconditioner Type", "ML");
Teuchos::ParameterList& meanPrecParams =
sgPrecParams.sublist("Mean Preconditioner Parameters");
meanPrecParams = det_ML;
sgPrecParams.set("G Preconditioner Type", "Ifpack");
Teuchos::ParameterList& GPrecParams =
sgPrecParams.sublist("G Preconditioner Parameters");
if (outer_krylov_method == GMRES || outer_krylov_method == FGMRES)
GPrecParams.set("Ifpack Preconditioner", "ILUT");
if (outer_krylov_method == CG)
GPrecParams.set("Ifpack Preconditioner", "ICT");
GPrecParams.set("Overlap", 1);
GPrecParams.set("fact: drop tolerance", 1e-4);
GPrecParams.set("fact: ilut level-of-fill", 1.0);
GPrecParams.set("schwarz: combine mode", "Add");
}
else if (precMethod == NONE) {
sgPrecParams.set("Preconditioner Method", "None");
}
else
TEUCHOS_TEST_FOR_EXCEPTION(true, std::logic_error,
"Error! Unknown preconditioner method " << precMethod
<< "." << std::endl);
// Create stochastic Galerkin model evaluator
Teuchos::RCP<Stokhos::SGModelEvaluator> sg_model =
Teuchos::rcp(new Stokhos::SGModelEvaluator(model, basis, Teuchos::null,
expansion, sg_parallel_data,
sgParams, scaleOP));
EpetraExt::ModelEvaluator::InArgs sg_inArgs = sg_model->createInArgs();
EpetraExt::ModelEvaluator::OutArgs sg_outArgs =
sg_model->createOutArgs();
// Set up stochastic parameters
Teuchos::RCP<Stokhos::EpetraVectorOrthogPoly> sg_p_init =
sg_model->create_p_sg(0);
for (int i=0; i<num_KL; i++) {
sg_p_init->term(i,0)[i] = 0.0;
sg_p_init->term(i,1)[i] = 1.0;
}
sg_model->set_p_sg_init(0, *sg_p_init);
// Setup stochastic initial guess
Teuchos::RCP<Stokhos::EpetraVectorOrthogPoly> sg_x_init =
sg_model->create_x_sg();
sg_x_init->init(0.0);
sg_model->set_x_sg_init(*sg_x_init);
// Create NOX interface
Teuchos::RCP<NOX::Epetra::ModelEvaluatorInterface> nox_interface =
Teuchos::rcp(new NOX::Epetra::ModelEvaluatorInterface(sg_model));
// Create NOX stochastic linear system object
Teuchos::RCP<const Epetra_Vector> u = sg_model->get_x_init();
Teuchos::RCP<const Epetra_Map> base_map = model->get_x_map();
Teuchos::RCP<const Epetra_Map> sg_map = sg_model->get_x_map();
Teuchos::RCP<Epetra_Operator> A = sg_model->create_W();
Teuchos::RCP<NOX::Epetra::Interface::Required> iReq = nox_interface;
Teuchos::RCP<NOX::Epetra::Interface::Jacobian> iJac = nox_interface;
// Build linear solver
Teuchos::RCP<NOX::Epetra::LinearSystem> linsys;
if (solve_method==SG_KRYLOV) {
bool has_M =
sg_outArgs.supports(EpetraExt::ModelEvaluator::OUT_ARG_WPrec);
Teuchos::RCP<Epetra_Operator> M;
Teuchos::RCP<NOX::Epetra::Interface::Preconditioner> iPrec;
if (has_M) {
M = sg_model->create_WPrec()->PrecOp;
iPrec = nox_interface;
}
stratParams.set("Preconditioner Type", "None");
if (outer_krylov_solver == AZTECOO) {
stratParams.set("Linear Solver Type", "AztecOO");
Teuchos::ParameterList& aztecOOParams =
stratParams.sublist("Linear Solver Types").sublist("AztecOO").sublist("Forward Solve");
Teuchos::ParameterList& aztecOOSettings =
aztecOOParams.sublist("AztecOO Settings");
if (outer_krylov_method == GMRES) {
aztecOOSettings.set("Aztec Solver","GMRES");
}
else if (outer_krylov_method == CG) {
aztecOOSettings.set("Aztec Solver","CG");
}
aztecOOSettings.set("Output Frequency", 1);
aztecOOSettings.set("Size of Krylov Subspace", 100);
aztecOOParams.set("Max Iterations", outer_its);
aztecOOParams.set("Tolerance", outer_tol);
stratLinSolParams.set("Preconditioner", "User Defined");
if (has_M)
linsys =
Teuchos::rcp(new NOX::Epetra::LinearSystemStratimikos(
printParams, stratLinSolParams, iJac, A, iPrec, M,
*u, true));
else
linsys =
Teuchos::rcp(new NOX::Epetra::LinearSystemStratimikos(
printParams, stratLinSolParams, iJac, A, *u));
}
else if (outer_krylov_solver == BELOS){
stratParams.set("Linear Solver Type", "Belos");
Teuchos::ParameterList& belosParams =
stratParams.sublist("Linear Solver Types").sublist("Belos");
Teuchos::ParameterList* belosSolverParams = NULL;
if (outer_krylov_method == GMRES || outer_krylov_method == FGMRES) {
belosParams.set("Solver Type","Block GMRES");
belosSolverParams =
&(belosParams.sublist("Solver Types").sublist("Block GMRES"));
if (outer_krylov_method == FGMRES)
belosSolverParams->set("Flexible Gmres", true);
}
else if (outer_krylov_method == CG) {
belosParams.set("Solver Type","Block CG");
belosSolverParams =
&(belosParams.sublist("Solver Types").sublist("Block CG"));
}
else if (inner_krylov_method == RGMRES) {
belosParams.set("Solver Type","GCRODR");
belosSolverParams =
&(belosParams.sublist("Solver Types").sublist("GCRODR"));
}
belosSolverParams->set("Convergence Tolerance", outer_tol);
belosSolverParams->set("Maximum Iterations", outer_its);
belosSolverParams->set("Output Frequency",1);
belosSolverParams->set("Output Style",1);
belosSolverParams->set("Verbosity",33);
stratLinSolParams.set("Preconditioner", "User Defined");
if (has_M)
linsys =
Teuchos::rcp(new NOX::Epetra::LinearSystemStratimikos(
printParams, stratLinSolParams, iJac, A, iPrec, M,
*u, true));
else
linsys =
Teuchos::rcp(new NOX::Epetra::LinearSystemStratimikos(
printParams, stratLinSolParams, iJac, A, *u));
}
}
else if (solve_method==SG_GS) {
lsParams.sublist("Deterministic Solver Parameters") = det_lsParams;
lsParams.set("Max Iterations", outer_its);
lsParams.set("Tolerance", outer_tol);
linsys =
Teuchos::rcp(new NOX::Epetra::LinearSystemSGGS(
printParams, lsParams, det_linsys, iReq, iJac,
basis, sg_parallel_data, A, base_map, sg_map));
}
else {
lsParams.sublist("Deterministic Solver Parameters") = det_lsParams;
lsParams.set("Max Iterations", outer_its);
lsParams.set("Tolerance", outer_tol);
Teuchos::ParameterList& jacobiOpParams =
lsParams.sublist("Jacobi SG Operator");
jacobiOpParams.set("Only Use Linear Terms", true);
linsys =
Teuchos::rcp(new NOX::Epetra::LinearSystemSGJacobi(
printParams, lsParams, det_linsys, iReq, iJac,
basis, sg_parallel_data, A, base_map, sg_map));
}
// Build NOX group
Teuchos::RCP<NOX::Epetra::Group> grp =
Teuchos::rcp(new NOX::Epetra::Group(printParams, iReq, *u, linsys));
// Create the Solver convergence test
Teuchos::RCP<NOX::StatusTest::Generic> statusTests =
NOX::StatusTest::buildStatusTests(statusParams, utils);
// Create the solver
Teuchos::RCP<NOX::Solver::Generic> solver =
NOX::Solver::buildSolver(grp, statusTests, noxParams);
// Solve the system
NOX::StatusTest::StatusType status;
{
TEUCHOS_FUNC_TIME_MONITOR("Total Solve Time");
status = solver->solve();
}
// Get final solution
const NOX::Epetra::Group& finalGroup =
dynamic_cast<const NOX::Epetra::Group&>(solver->getSolutionGroup());
const Epetra_Vector& finalSolution =
(dynamic_cast<const NOX::Epetra::Vector&>(finalGroup.getX())).getEpetraVector();
// Save final solution to file
EpetraExt::VectorToMatrixMarketFile("nox_solver_stochastic_solution.mm",
finalSolution);
// Save mean and variance to file
Teuchos::RCP<Stokhos::EpetraVectorOrthogPoly> sg_x_poly =
sg_model->create_x_sg(View, &finalSolution);
Epetra_Vector mean(*(model->get_x_map()));
Epetra_Vector std_dev(*(model->get_x_map()));
sg_x_poly->computeMean(mean);
sg_x_poly->computeStandardDeviation(std_dev);
EpetraExt::VectorToMatrixMarketFile("mean_gal.mm", mean);
EpetraExt::VectorToMatrixMarketFile("std_dev_gal.mm", std_dev);
// Evaluate SG responses at SG parameters
Teuchos::RCP<const Epetra_Vector> sg_p = sg_model->get_p_init(1);
Teuchos::RCP<Epetra_Vector> sg_g =
Teuchos::rcp(new Epetra_Vector(*(sg_model->get_g_map(0))));
sg_inArgs.set_p(1, sg_p);
sg_inArgs.set_x(Teuchos::rcp(&finalSolution,false));
sg_outArgs.set_g(0, sg_g);
sg_model->evalModel(sg_inArgs, sg_outArgs);
// Print mean and standard deviation of response
Teuchos::RCP<Stokhos::EpetraVectorOrthogPoly> sg_g_poly =
sg_model->create_g_sg(0, View, sg_g.get());
Epetra_Vector g_mean(*(model->get_g_map(0)));
Epetra_Vector g_std_dev(*(model->get_g_map(0)));
sg_g_poly->computeMean(g_mean);
sg_g_poly->computeStandardDeviation(g_std_dev);
std::cout.precision(16);
// std::cout << "\nResponse Expansion = " << std::endl;
// std::cout.precision(12);
// sg_g_poly->print(std::cout);
std::cout << "\nResponse Mean = " << std::endl << g_mean << std::endl;
std::cout << "Response Std. Dev. = " << std::endl << g_std_dev << std::endl;
if (status == NOX::StatusTest::Converged && MyPID == 0)
utils.out() << "Example Passed!" << std::endl;
}
Teuchos::TimeMonitor::summarize(std::cout);
Teuchos::TimeMonitor::zeroOutTimers();
}
catch (std::exception& e) {
std::cout << e.what() << std::endl;
}
catch (string& s) {
std::cout << s << std::endl;
}
catch (char *s) {
std::cout << s << std::endl;
}
catch (...) {
std::cout << "Caught unknown exception!" <<std:: endl;
}
#ifdef HAVE_MPI
MPI_Finalize() ;
#endif
}
int main(int argc, char** argv) {
ros::init(argc, argv, "pcd_edit_tool"); //node name
ros::NodeHandle nh;
if (argc < 2) {
ROS_INFO("Please input the pcd name!");
return -1;
}
PclUtils utils(&nh);
pubCloud = nh.advertise<sensor_msgs::PointCloud2> ("editing_cloud", 1);
ros::Timer timer = nh.createTimer(ros::Duration(0.05), timerCallback);
//spin until obtain a snapshot
ROS_INFO("waiting for kinect data...");
while (!utils.got_kinect_cloud()) {
ros::spinOnce();
ros::Duration(0.1).sleep();
}
utils.get_kinect_points(pclKinect_clr_ptr);
display_kinect = true;
ros::spinOnce();
ROS_INFO("Please select point cloud in \'/camera/depth_registered/points\' topic using \'Publish Selected points\'");
double x, y, z;
while (!utils.got_selected_points()) {
ros::spinOnce();
ros::Duration(0.1).sleep();
}
utils.reset_got_selected_points();
utils.get_selected_points(pclSelected_ptr);
for (int i = 0; i < pclSelected_ptr->points.size(); ++i) {
for (int j = 0; j < pclKinect_clr_ptr->points.size(); ++j) {
x = pow(pclKinect_clr_ptr->points[j].x - pclSelected_ptr->points[i].x, 2);
y = pow(pclKinect_clr_ptr->points[j].y - pclSelected_ptr->points[i].y, 2);
z = pow(pclKinect_clr_ptr->points[j].z - pclSelected_ptr->points[i].z, 2);
if (sqrt(x + y +z ) < DISTANCE_TOLERANCE) {
pclEditing_ptr->points.push_back(pclKinect_clr_ptr->points[j]);
break;
}
}
}
ROS_INFO("snapshot with points %d; saving to file %s", (int)pclEditing_ptr->points.size(), argv[1]);
pcl::io::savePCDFile(argv[1], *pclEditing_ptr, true);
display_kinect = false;
ros::spinOnce();
string input;
while (ros::ok()) {
cout<<"+ to add points to cloud, - to delete cloud, r to reset cloud, q to exit: ";
cin >> input;
if (input.compare("+") == 0) {
ROS_INFO("Please select point cloud in \'/camera/depth_registered/points\' topic using \'Publish Selected points\'");
while (!utils.got_selected_points()) {
ros::spinOnce();
ros::Duration(0.1).sleep();
}
utils.reset_got_selected_points();
utils.get_selected_points(pclSelected_ptr);
temp_ptr->points.clear();
for (int i = 0; i < pclSelected_ptr->points.size(); ++i) {
for (int j = 0; j < pclKinect_clr_ptr->points.size(); ++j) {
x = pow(pclKinect_clr_ptr->points[j].x - pclSelected_ptr->points[i].x, 2);
y = pow(pclKinect_clr_ptr->points[j].y - pclSelected_ptr->points[i].y, 2);
z = pow(pclKinect_clr_ptr->points[j].z - pclSelected_ptr->points[i].z, 2);
if (x + y +z < DISTANCE_TOLERANCE) {
temp_ptr->points.push_back(pclKinect_clr_ptr->points[j]);
break;
}
}
}
bool in_cloud = false;
for (int i = 0; i < temp_ptr->points.size(); ++i) {
for (int j = 0; j < pclEditing_ptr->points.size(); ++j) {
x = pow(pclEditing_ptr->points[j].x - temp_ptr->points[i].x, 2);
y = pow(pclEditing_ptr->points[j].y - temp_ptr->points[i].y, 2);
z = pow(pclEditing_ptr->points[j].z - temp_ptr->points[i].z, 2);
if (x + y +z < DISTANCE_TOLERANCE) {
in_cloud = true;
break;
}
}
if (!in_cloud) {
pclEditing_ptr->points.push_back(temp_ptr->points[i]);
}
in_cloud = false;
}
ROS_INFO("snapshot with points %d; saving to file %s", (int)pclEditing_ptr->points.size(), argv[1]);
pcl::io::savePCDFile(argv[1], *pclEditing_ptr, true);
} else if (input.compare("-") == 0) {
ROS_INFO("Please select point cloud in \'/editing_cloud\' topic using \'Publish Selected points\'");
while (!utils.got_selected_points()) {
ros::spinOnce();
ros::Duration(0.1).sleep();
}
utils.reset_got_selected_points();
utils.get_selected_points(pclSelected_ptr);
bool in_cloud = false;
temp_ptr->points.clear();
for (int i = 0; i < pclEditing_ptr->points.size(); ++i) {
for (int j = 0; j < pclSelected_ptr->points.size(); ++j) {
x = pow(pclEditing_ptr->points[i].x - pclSelected_ptr->points[j].x, 2);
y = pow(pclEditing_ptr->points[i].y - pclSelected_ptr->points[j].y, 2);
z = pow(pclEditing_ptr->points[i].z - pclSelected_ptr->points[j].z, 2);
if (x + y + z < DISTANCE_TOLERANCE) {
in_cloud = true;
break;
}
}
if (!in_cloud) {
temp_ptr->points.push_back(pclEditing_ptr->points[i]);
}
in_cloud = false;
}
pcl::copyPointCloud(*temp_ptr, *pclEditing_ptr);
ROS_INFO("snapshot with points %d; saving to file %s", (int)pclEditing_ptr->points.size(), argv[1]);
pcl::io::savePCDFile(argv[1], *pclEditing_ptr, true);
} else if (input.compare("r") == 0 || input.compare("R") == 0) {
ROS_INFO("waiting for kinect data...");
utils.reset_got_kinect_cloud();
while (!utils.got_kinect_cloud()) {
ros::spinOnce();
ros::Duration(0.1).sleep();
}
utils.get_kinect_points(pclKinect_clr_ptr);
display_kinect = true;
ros::spinOnce();
//pcl::copyPointCloud(*pclKinect_clr_ptr, *pclEditing_ptr);
ROS_INFO("Please select point cloud in \'/camera/depth_registered/points\' topic using \'Publish Selected points\'");
while (!utils.got_selected_points()) {
ros::spinOnce();
ros::Duration(0.1).sleep();
}
utils.reset_got_selected_points();
utils.get_selected_points(pclSelected_ptr);
pclEditing_ptr->points.clear();
for (int i = 0; i < pclSelected_ptr->points.size(); ++i) {
for (int j = 0; j < pclKinect_clr_ptr->points.size(); ++j) {
x = pow(pclKinect_clr_ptr->points[j].x - pclSelected_ptr->points[i].x, 2);
y = pow(pclKinect_clr_ptr->points[j].y - pclSelected_ptr->points[i].y, 2);
z = pow(pclKinect_clr_ptr->points[j].z - pclSelected_ptr->points[i].z, 2);
if (sqrt(x + y +z ) < DISTANCE_TOLERANCE) {
pclEditing_ptr->points.push_back(pclKinect_clr_ptr->points[j]);
break;
}
}
}
ROS_INFO("snapshot with points %d; saving to file %s", (int)pclEditing_ptr->points.size(), argv[1]);
pcl::io::savePCDFile(argv[1], *pclEditing_ptr, true);
display_kinect = false;
ros::spinOnce();
} else if (input.compare("q") == 0 || input.compare("Q") == 0) {
ROS_INFO("Quiting...");
ros::spinOnce();
return 0;
}
ros::spinOnce();
}
return 0;
}
//! Main subroutine of Broyden.C
int main(int argc, char *argv[])
{
cout << "Started" << endl;
// Set up the problem interface
Broyden broyden(100,0.99);
// Create a group which uses that problem interface. The group will
// be initialized to contain the default initial guess for the
// specified problem.
Teuchos::RCP<NOX::LAPACK::Group> grp =
Teuchos::rcp(new NOX::LAPACK::Group(broyden));
// Create the top level parameter list
Teuchos::RCP<Teuchos::ParameterList> solverParametersPtr =
Teuchos::rcp(new Teuchos::ParameterList);
Teuchos::ParameterList& solverParameters = *solverParametersPtr;
// Set the nonlinear solver method
//solverParameters.set("Nonlinear Solver", "Tensor-Krylov Based");
solverParameters.set("Nonlinear Solver", "Tensor Based");
// Sublist for printing parameters
Teuchos::ParameterList& printParams = solverParameters.sublist("Printing");
//printParams.set("MyPID", 0);
printParams.set("Output Precision", 3);
printParams.set("Output Processor", 0);
printParams.set("Output Information",
NOX::Utils::OuterIteration +
NOX::Utils::OuterIterationStatusTest +
NOX::Utils::InnerIteration +
NOX::Utils::Parameters +
NOX::Utils::Details +
NOX::Utils::Warning);
NOX::Utils utils(printParams);
// Sublist for direction parameters
Teuchos::ParameterList& directionParameters =
solverParameters.sublist("Direction");
directionParameters.set("Method","Tensor");
// Sublist for local solver parameters
//Teuchos::ParameterList& localSolverParameters =
//directionParameters.sublist("Tensor").sublist("Linear Solver");
//localSolverParameters.set("Tolerance", 1e-4);
//localSolverParameters.set("Reorthogonalize","Always");
//localSolverParameters.set("Output Frequency",1);
//localSolverParameters.set("Max Restarts", 2);
//localSolverParameters.set("Size of Krylov Subspace", 15);
//localSolverParameters.set("Preconditioning","Tridiagonal");
//localSolverParameters.set("Preconditioning Side","None");
//localSolverParameters.set("Use Shortcut Method",false);
// Sublist for line search parameters
Teuchos::ParameterList& globalStrategyParameters =
solverParameters.sublist("Line Search");
globalStrategyParameters.set("Method","Curvilinear");
// Sublist for line search parameters
Teuchos::ParameterList& lineSearchParameters =
globalStrategyParameters.sublist(globalStrategyParameters.
get("Method","Curvilinear"));
lineSearchParameters.set("Lambda Selection","Halving");
lineSearchParameters.set("Max Iters",20);
//
// Update parameters from an input file if the input file was provided in command
// line. Usage -p paramFilename
//
string paramFilename;
bool usingParamInputFile = false;
if (argc > 1)
{
if (argv[1][0]=='-' && argv[1][1]=='p')
{
if (argc < 3)
{
cout << "Error: A parameter input file was expected but not found. \n" << endl;
printParams.set("Output Information", NOX::Utils::Error);
NOX::Utils printing(printParams);
return 0;
}
paramFilename = argv[2];
cout << "Reading parameter information from file \"" << paramFilename << "\""<< endl;
usingParamInputFile = true;
}
}
// Read parameters from file paramFilename - command line arg#1
if (usingParamInputFile && !NOX::parseTextInputFile(paramFilename, solverParameters))
cout << "Using unchanged parameters " << endl;
// Create the convergence tests
Teuchos::RCP<NOX::StatusTest::NormF> statusTestA =
Teuchos::rcp(new NOX::StatusTest::NormF(1.0e-12,
NOX::StatusTest::NormF::Unscaled));
Teuchos::RCP<NOX::StatusTest::MaxIters> statusTestB =
Teuchos::rcp(new NOX::StatusTest::MaxIters(50));
Teuchos::RCP<NOX::StatusTest::Combo> statusTestsCombo =
Teuchos::rcp(new NOX::StatusTest::Combo(NOX::StatusTest::Combo::OR,
statusTestA, statusTestB));
// Create the solver
Teuchos::RCP<NOX::Solver::Generic> solver =
NOX::Solver::buildSolver(grp, statusTestsCombo, solverParametersPtr);
// Print the starting point
grp->computeF();
cout << "\n" << "-- Starting Point --" << "\n";
cout << "|| F(x0) || = " << utils.sciformat(grp->getNormF()) << endl;
// grp.print();
// Solve the nonlinear system
NOX::StatusTest::StatusType status = solver->solve();
// Get the answer
NOX::LAPACK::Group solnGrp =
dynamic_cast<const NOX::LAPACK::Group&>(solver->getSolutionGroup());
// Output the parameter list
if (utils.isPrintType(NOX::Utils::Parameters)) {
cout << "\n" << "-- Parameter List Used in Solver --" << endl;
solver->getList().print(cout);
cout << endl;
}
// Print the answer
if (utils.isPrintType(NOX::Utils::Parameters)) {
cout << "\n" << "-- Final Solution From Solver --" << "\n";
cout << "|| F(x*) || = " << utils.sciformat(solnGrp.getNormF()) << endl;
// solnGrp.print();
}
// Print final status
int returnValue = 1;
if (status == NOX::StatusTest::Converged) {
returnValue = 0;
cout << "Test passed!" << endl;
}
else
cout << "Test failed!" << endl;
return returnValue;
}
int main(int argc, char *argv[])
{
int n = 100;
double alpha = 10.0;
double beta = 0.0;
double scale = 1.0;
int maxNewtonIters = 20;
int ierr = 0;
alpha = alpha / scale;
try {
bool verbose = false;
// Check for verbose output
if (argc>1)
if (argv[1][0]=='-' && argv[1][1]=='v')
verbose = true;
// Create parameter list
Teuchos::RCP<Teuchos::ParameterList> paramList =
Teuchos::rcp(new Teuchos::ParameterList);
// Create LOCA sublist
Teuchos::ParameterList& locaParamsList = paramList->sublist("LOCA");
// Create the stepper sublist and set the stepper parameters
Teuchos::ParameterList& stepperList = locaParamsList.sublist("Stepper");
// Create the "Solver" parameters sublist to be used with NOX Solvers
Teuchos::ParameterList& nlParams = paramList->sublist("NOX");
Teuchos::ParameterList& nlPrintParams = nlParams.sublist("Printing");
if (verbose)
nlPrintParams.set("Output Information",
NOX::Utils::Error +
NOX::Utils::Details +
NOX::Utils::OuterIterationStatusTest +
NOX::Utils::OuterIteration +
NOX::Utils::InnerIteration +
NOX::Utils::Warning +
NOX::Utils::TestDetails +
NOX::Utils::StepperIteration +
NOX::Utils::StepperDetails +
NOX::Utils::StepperParameters);
else
nlPrintParams.set("Output Information", NOX::Utils::Error);
// Create LAPACK Factory
Teuchos::RCP<LOCA::LAPACK::Factory> lapackFactory =
Teuchos::rcp(new LOCA::LAPACK::Factory);
// Create global data object
Teuchos::RCP<LOCA::GlobalData> globalData =
LOCA::createGlobalData(paramList, lapackFactory);
// Set up the problem interface
ChanProblemInterface chan(globalData, n, alpha, beta, scale);
LOCA::ParameterVector p;
p.addParameter("alpha",alpha);
p.addParameter("beta",beta);
p.addParameter("scale",scale);
// Create a group which uses that problem interface. The group will
// be initialized to contain the default initial guess for the
// specified problem.
Teuchos::RCP<LOCA::LAPACK::Group> grp =
Teuchos::rcp(new LOCA::LAPACK::Group(globalData, chan));
grp->setParams(p);
// Set up the status tests
grp->computeF();
double size = sqrt(static_cast<double>(grp->getX().length()));
double normF_0 = grp->getNormF() / size;
double tolerance = 1.0e-8 / normF_0 / normF_0;
Teuchos::RCP<NOX::StatusTest::NormF> statusTestA =
Teuchos::rcp(new NOX::StatusTest::NormF(*grp, tolerance));
Teuchos::RCP<NOX::StatusTest::MaxIters> statusTestB =
Teuchos::rcp(new NOX::StatusTest::MaxIters(maxNewtonIters));
Teuchos::RCP<NOX::StatusTest::Combo> combo =
Teuchos::rcp(new NOX::StatusTest::Combo(NOX::StatusTest::Combo::OR,
statusTestA, statusTestB));
// Create the homotopy group
Teuchos::RCP<LOCA::Homotopy::Group> hGrp =
Teuchos::rcp(new LOCA::Homotopy::Group(locaParamsList, globalData, grp));
// Override default parameters
stepperList.set("Max Nonlinear Iterations", maxNewtonIters);
// Create the stepper
LOCA::Stepper stepper(globalData, hGrp, combo, paramList);
// Solve the nonlinear system
LOCA::Abstract::Iterator::IteratorStatus status = stepper.run();
if (status != LOCA::Abstract::Iterator::Finished) {
ierr = 1;
if (globalData->locaUtils->isPrintType(NOX::Utils::Error))
globalData->locaUtils->out() << "Stepper failed to converge!"
<< std::endl;
}
// Get the final solution from the stepper
Teuchos::RCP<const LOCA::LAPACK::Group> finalGroup =
Teuchos::rcp_dynamic_cast<const LOCA::LAPACK::Group>(stepper.getSolutionGroup());
const NOX::LAPACK::Vector& finalSolution =
dynamic_cast<const NOX::LAPACK::Vector&>(finalGroup->getX());
// Output the parameter list
if (globalData->locaUtils->isPrintType(NOX::Utils::StepperParameters)) {
globalData->locaUtils->out()
<< std::endl << "Final Parameters" << std::endl
<< "****************" << std::endl;
stepper.getList()->print(globalData->locaUtils->out());
globalData->locaUtils->out() << std::endl;
}
// Check some statistics on the solution
NOX::Utils utils(nlPrintParams);
NOX::TestCompare testCompare(cout, utils);
if (utils.isPrintType(NOX::Utils::TestDetails))
cout << endl << "***** Checking solutions statistics *****" << endl;
// Check number of steps
int numSteps = stepper.getStepNumber();
int numSteps_expected = 14;
ierr += testCompare.testValue(numSteps, numSteps_expected, 0.0,
"number of continuation steps",
NOX::TestCompare::Absolute);
// Check number of failed steps
int numFailedSteps = stepper.getNumFailedSteps();
int numFailedSteps_expected = 3;
ierr += testCompare.testValue(numFailedSteps, numFailedSteps_expected,
0.0, "number of failed continuation steps",
NOX::TestCompare::Absolute);
// Check final value of continuation parameter
double alpha_final =
finalGroup->getParam("Homotopy Continuation Parameter");
double alpha_expected = 1.0;
ierr += testCompare.testValue(alpha_final, alpha_expected, 1.0e-14,
"final value of continuation parameter",
NOX::TestCompare::Relative);
// Check norm of solution
double norm_x = finalSolution.norm();
double norm_x_expected = 456.0303417;
ierr += testCompare.testValue(norm_x, norm_x_expected, 1.0e-7,
"norm of final solution",
NOX::TestCompare::Relative);
LOCA::destroyGlobalData(globalData);
}
catch (std::exception& e) {
std::cout << e.what() << std::endl;
ierr = 1;
}
catch (const char *s) {
std::cout << s << std::endl;
ierr = 1;
}
catch (...) {
std::cout << "Caught unknown exception!" << std::endl;
ierr = 1;
}
if (ierr == 0)
std::cout << "All tests passed!" << std::endl;
else
std::cout << ierr << " test(s) failed!" << std::endl;
return 0;
}
