// @HEADER // ***************************************************************************** // NOX: An Object-Oriented Nonlinear Solver Package // // Copyright 2002 NTESS and the NOX contributors. // SPDX-License-Identifier: BSD-3-Clause // ***************************************************************************** // @HEADER // 1D Finite Element NonlinearCG Test Problem /* Solves the nonlinear equation: * * d2u * --- - k * u**2 = 0 * dx2 * * subject to @ x=0, u=1 * * using nonlinear CG direction and linesearch methods. This problem is not challenging but serves primarily to demonstrate use of NonlinearCG as well as ensure it is not broken. Preconditioning is performed using 5 gmres iterations with the analytic jacobian matrix for the problem. Note that solving these linear systems completely, omitting orthogonalization and using a full step (1.0) is equivalent to using Newton's method. */ // NOX Objects #include "NOX.H" #include "NOX_Epetra.H" // Trilinos Objects #ifdef HAVE_MPI #include "Epetra_MpiComm.h" #else #include "Epetra_SerialComm.h" #endif #include "Epetra_Map.h" #include "Epetra_Vector.h" #include "Epetra_RowMatrix.h" #include "Epetra_CrsMatrix.h" #include "Epetra_Map.h" #include "Epetra_LinearProblem.h" #include "AztecOO.h" // User's application specific files #include "1DfemInterface.H" #include "1DfemPrePostOperator.H" #include "Teuchos_ParameterList.hpp" #include "Teuchos_StandardCatchMacros.hpp" using namespace std; int main(int argc, char *argv[]) { // Initialize MPI #ifdef HAVE_MPI MPI_Init(&argc,&argv); #endif // Create a communicator for Epetra objects #ifdef HAVE_MPI Epetra_MpiComm Comm( MPI_COMM_WORLD ); #else Epetra_SerialComm Comm; #endif // Get the process ID and the total number of processors int MyPID = Comm.MyPID(); int NumProc = Comm.NumProc(); // Check verbosity level bool verbose = false; if (argc > 1) if (argv[1][0]=='-' && argv[1][1]=='v') verbose = true; // Get the number of elements from the command line int NumGlobalElements = 0; if ((argc > 2) && (verbose)) NumGlobalElements = atoi(argv[2]) + 1; else if ((argc > 1) && (!verbose)) NumGlobalElements = atoi(argv[1]) + 1; else NumGlobalElements = 101; bool success = false; try { // The number of unknowns must be at least equal to the number of // processors. if (NumGlobalElements < NumProc) { std::cout << "numGlobalBlocks = " << NumGlobalElements << " cannot be < number of processors = " << NumProc << std::endl; std::cout << "Test failed!" << std::endl; throw std::runtime_error("NOX Error"); } // Create the interface between NOX and the application // This object is derived from NOX::Epetra::Interface Teuchos::RCP interface = Teuchos::rcp(new Interface(NumGlobalElements, Comm)); // Get the vector from the Problem Teuchos::RCP soln = interface->getSolution(); Teuchos::RCP noxSoln = Teuchos::rcp(new NOX::Epetra::Vector(soln, NOX::Epetra::Vector::CreateView)); // Set the PDE factor (for nonlinear forcing term). This could be // specified via user input. interface->setPDEfactor(1000.0); // Set the initial guess soln->PutScalar(1.0); // Begin Nonlinear Solver ************************************ // Create the top level parameter list Teuchos::RCP nlParamsPtr = Teuchos::rcp(new Teuchos::ParameterList); Teuchos::ParameterList& nlParams = *(nlParamsPtr.get()); // Set the nonlinear solver method nlParams.set("Nonlinear Solver", "Line Search Based"); // Set the printing parameters in the "Printing" sublist Teuchos::ParameterList& printParams = nlParams.sublist("Printing"); printParams.set("MyPID", MyPID); printParams.set("Output Precision", 3); printParams.set("Output Processor", 0); if (verbose) printParams.set("Output Information", NOX::Utils::OuterIteration + NOX::Utils::OuterIterationStatusTest + NOX::Utils::InnerIteration + NOX::Utils::LinearSolverDetails + NOX::Utils::Parameters + NOX::Utils::Details + NOX::Utils::Warning + NOX::Utils::Debug + NOX::Utils::TestDetails + NOX::Utils::Error); else printParams.set("Output Information", NOX::Utils::Error + NOX::Utils::TestDetails); // Create a print class for controlling output below NOX::Utils printing(printParams); // Sublist for line search Teuchos::ParameterList& searchParams = nlParams.sublist("Line Search"); searchParams.set("Method", "NonlinearCG"); // "Full Step" can also work well sometimes // Sublist for direction Teuchos::ParameterList& dirParams = nlParams.sublist("Direction"); dirParams.set("Method", "NonlinearCG"); Teuchos::ParameterList& nonlinearcg = dirParams.sublist("Nonlinear CG"); nonlinearcg.set("Restart Frequency", 100); nonlinearcg.set("Precondition", "On"); nonlinearcg.set("Orthogonalize", "Fletcher-Reeves"); // or "Polak-Ribiere" // Sublist for linear solver for the Newton method Teuchos::ParameterList& lsParams = nonlinearcg.sublist("Linear Solver"); lsParams.set("Aztec Solver", "GMRES"); //lsParams.set("Preconditioner Operator", "Use Jacobian"); lsParams.set("Preconditioner", "AztecOO"); lsParams.set("AztecOO Preconditioner Iterations", 15); lsParams.set("Preconditioner Reuse Policy", "Recompute"); // Let's force all status tests to do a full check nlParams.sublist("Solver Options").set("Status Test Check Type", "Complete"); // 1. User supplied (Epetra_RowMatrix) Teuchos::RCP Analytic = interface->getJacobian(); // Create the linear system Teuchos::RCP iReq = interface; Teuchos::RCP iJac = interface; Teuchos::RCP linSys = Teuchos::rcp(new NOX::Epetra::LinearSystemAztecOO(printParams, lsParams, interface, iJac, Analytic, *soln)); // Create the Group NOX::Epetra::Vector initialGuess(soln, NOX::Epetra::Vector::CreateView); Teuchos::RCP grpPtr = Teuchos::rcp(new NOX::Epetra::Group(printParams, iReq, initialGuess, linSys)); // Create the convergence tests Teuchos::RCP absresid = Teuchos::rcp(new NOX::StatusTest::NormF(1.0e-8)); Teuchos::RCP maxiters = Teuchos::rcp(new NOX::StatusTest::MaxIters(20)); Teuchos::RCP fv = Teuchos::rcp(new NOX::StatusTest::FiniteValue); Teuchos::RCP combo = Teuchos::rcp(new NOX::StatusTest::Combo(NOX::StatusTest::Combo::OR)); combo->addStatusTest(fv); combo->addStatusTest(absresid); combo->addStatusTest(maxiters); // Create the solver Teuchos::RCP solver = NOX::Solver::buildSolver(grpPtr, combo, nlParamsPtr); NOX::StatusTest::StatusType solvStatus = solver->solve(); // End Nonlinear Solver ************************************** // Get the Epetra_Vector with the final solution from the solver const NOX::Epetra::Group& finalGroup = dynamic_cast(solver->getSolutionGroup()); const Epetra_Vector& finalSolution = (dynamic_cast(finalGroup.getX())). getEpetraVector(); // Output the parameter list if (verbose) { if (printing.isPrintType(NOX::Utils::Parameters)) { printing.out() << std::endl << "Final Parameters" << std::endl << "****************" << std::endl; solver->getList().print(printing.out()); printing.out() << std::endl; } } // Print solution char file_name[25]; FILE *ifp; int NumMyElements = soln->Map().NumMyElements(); (void) sprintf(file_name, "output.%d",MyPID); ifp = fopen(file_name, "w"); for (int i=0; iMap().MinMyGID()+i, finalSolution[i]); fclose(ifp); // Tests int status = 0; // Converged // 1. Convergence if (solvStatus != NOX::StatusTest::Converged) { status = 1; if (printing.isPrintType(NOX::Utils::Error)) printing.out() << "Nonlinear solver failed to converge!" << std::endl; } // 2. Nonlinear solve iterations (10) if (const_cast(solver->getList()).sublist("Output").get("Nonlinear Iterations", 0) > 13) status = 2; success = status==0; // Summarize test results if (success) printing.out() << "Test passed!" << std::endl; else printing.out() << "Test failed!" << std::endl; printing.out() << "Status = " << status << std::endl; } TEUCHOS_STANDARD_CATCH_STATEMENTS(verbose, std::cerr, success); #ifdef HAVE_MPI MPI_Finalize(); #endif return ( success ? EXIT_SUCCESS : EXIT_FAILURE ); }