Debian Codegraph @

packages/nox/test/epetra/1Dfem/1DfemScaledInexactTrustRegion.C

raw
1 // @HEADER
2 // *****************************************************************************
3 // NOX: An Object-Oriented Nonlinear Solver Package
4 //
5 // Copyright 2002 NTESS and the NOX contributors.
6 // SPDX-License-Identifier: BSD-3-Clause
7 // *****************************************************************************
8 // @HEADER
9
10 // 1D Finite Element Test Problem
11 /* Solves the nonlinear equation:
12 *
13 * d2u
14 * --- - k * u**2 = 0
15 * dx2
16 *
17 * subject to @ x=0, u=1
18 */
19
20 // NOX Objects
21 #include "NOX.H"
22 #include "NOX_Epetra.H"
23 #include "NOX_SolverStats.hpp"
24 #include "Teuchos_TestingHelpers.hpp"
25
26 // Trilinos Objects
27 #ifdef HAVE_MPI
28 #include "Epetra_MpiComm.h"
29 #else
30 #include "Epetra_SerialComm.h"
31 #endif
32 #include "Epetra_Map.h"
33 #include "Epetra_Vector.h"
34 #include "Epetra_RowMatrix.h"
35 #include "Epetra_CrsMatrix.h"
36 #include "Epetra_Map.h"
37 #include "Epetra_LinearProblem.h"
38 #include "AztecOO.h"
39
40 // User's application specific files
41 #include "1DfemInterface.H"
42 #include "1DfemPrePostOperator.H"
43
44 #include "Teuchos_ParameterList.hpp"
45 #include "Teuchos_StandardCatchMacros.hpp"
46
47 using namespace std;
48
49 int main(int argc, char *argv[])
50 {
51 // Initialize MPI
52 #ifdef HAVE_MPI
53 MPI_Init(&argc,&argv);
54 #endif
55
56 // Create a communicator for Epetra objects
57 #ifdef HAVE_MPI
58 Epetra_MpiComm Comm( MPI_COMM_WORLD );
59 #else
60 Epetra_SerialComm Comm;
61 #endif
62
63 // Get the process ID and the total number of processors
64 int MyPID = Comm.MyPID();
65 int NumProc = Comm.NumProc();
66
67 // Check verbosity level
68 bool verbose = false;
69 if (argc > 1)
70 if (argv[1][0]=='-' && argv[1][1]=='v')
71 verbose = true;
72
73 // Get the number of elements from the command line
74 int NumGlobalElements = 0;
75 if ((argc > 2) && (verbose))
76 NumGlobalElements = atoi(argv[2]) + 1;
77 else if ((argc > 1) && (!verbose))
78 NumGlobalElements = atoi(argv[1]) + 1;
79 else
80 NumGlobalElements = 101;
81
82 bool success = false;
83
84 try {
85
86 // The number of unknowns must be at least equal to the
87 // number of processors.
88 if (NumGlobalElements < NumProc) {
89 std::cout << "numGlobalBlocks = " << NumGlobalElements
90 << " cannot be < number of processors = " << NumProc << std::endl;
91 std::cout << "Test failed!" << std::endl;
92 throw std::runtime_error("NOX Error");
93 }
94
95 // Create the interface between NOX and the application
96 // This object is derived from NOX::Epetra::Interface
97 Teuchos::RCP<Interface> interface =
98 Teuchos::rcp(new Interface(NumGlobalElements, Comm));
99
100 // Set the PDE factor (for nonlinear forcing term). This could be specified
101 // via user input.
102 interface->setPDEfactor(100000.0);
103
104 // Use a scaled vector space. The scaling must also be registered
105 // with the linear solver so the linear system is consistent!
106 Teuchos::RCP<Epetra_Vector> scaleVec =
107 Teuchos::rcp(new Epetra_Vector( *(interface->getSolution())));
108 scaleVec->PutScalar(2.0);
109 Teuchos::RCP<NOX::Epetra::Scaling> scaling =
110 Teuchos::rcp(new NOX::Epetra::Scaling);
111 scaling->addUserScaling(NOX::Epetra::Scaling::Left, scaleVec);
112
113 // Use a weighted vector space for scaling all norms
114 Teuchos::RCP<NOX::Epetra::VectorSpace> weightedVectorSpace =
115 Teuchos::rcp(new NOX::Epetra::VectorSpaceScaledL2(scaling));
116
117 // Get the vector from the Problem
118 Teuchos::RCP<Epetra_Vector> soln = interface->getSolution();
119 Teuchos::RCP<NOX::Epetra::Vector> noxSoln =
120 Teuchos::rcp(new NOX::Epetra::Vector(soln,
121 NOX::Epetra::Vector::CreateCopy,
122 NOX::DeepCopy,
123 weightedVectorSpace));
124
125 // Initial Guess
126 noxSoln->init(2.0);
127
128 // Begin Nonlinear Solver ************************************
129
130 // Create the top level parameter list
131 Teuchos::RCP<Teuchos::ParameterList> nlParamsPtr =
132 Teuchos::rcp(new Teuchos::ParameterList);
133 Teuchos::ParameterList& nlParams = *(nlParamsPtr.get());
134
135 // Set the nonlinear solver method
136 nlParams.set("Nonlinear Solver", "Inexact Trust Region Based");
137 nlParams.sublist("Trust Region").
138 set("Inner Iteration Method", "Inexact Trust Region");
139
140 // Set the printing parameters in the "Printing" sublist
141 Teuchos::ParameterList& printParams = nlParams.sublist("Printing");
142
143 // RPP: Commenting this line out. There is now a default for MPI
144 // specific builds. We are testing that it works here.
145 // //printParams.set("MyPID", MyPID);
146
147 printParams.set("Output Precision", 3);
148 printParams.set("Output Processor", 0);
149 if (verbose)
150 printParams.set("Output Information",
151 NOX::Utils::OuterIteration +
152 NOX::Utils::OuterIterationStatusTest +
153 NOX::Utils::InnerIteration +
154 NOX::Utils::LinearSolverDetails +
155 NOX::Utils::Parameters +
156 NOX::Utils::Details +
157 NOX::Utils::Warning +
158 NOX::Utils::Debug +
159 NOX::Utils::TestDetails +
160 NOX::Utils::Error);
161 else
162 printParams.set("Output Information", NOX::Utils::Error +
163 NOX::Utils::TestDetails);
164
165 // Create a print class for controlling output below
166 NOX::Utils printing(printParams);
167
168 // Sublist for direction
169 Teuchos::ParameterList& dirParams = nlParams.sublist("Direction");
170 dirParams.set("Method", "Newton");
171 Teuchos::ParameterList& newtonParams = dirParams.sublist("Newton");
172 newtonParams.set("Forcing Term Method", "Type 1");
173
174 // Sublist for linear solver for the Newton method
175 Teuchos::ParameterList& lsParams = newtonParams.sublist("Linear Solver");
176 lsParams.set("Aztec Solver", "GMRES");
177 lsParams.set("Max Iterations", 800);
178 lsParams.set("Tolerance", 1e-4);
179
180 // Various Preconditioner options
181 //lsParams.set("Preconditioner", "AztecOO");
182 lsParams.set("Preconditioner", "Ifpack");
183 lsParams.set("Preconditioner Reuse Policy", "Rebuild");
184
185 // Sublist for Cauchy direction
186 Teuchos::ParameterList& cauchyDirParams = nlParams.sublist("Cauchy Direction");
187 cauchyDirParams.set("Method", "Steepest Descent");
188 Teuchos::ParameterList& sdParams = cauchyDirParams.sublist("Steepest Descent");
189 sdParams.set("Scaling Type", "Quadratic Model Min");
190
191 // Add a user defined pre/post operator object
192 Teuchos::RCP<NOX::Abstract::PrePostOperator> ppo =
193 Teuchos::rcp(new UserPrePostOperator(printing));
194 nlParams.sublist("Solver Options").set("User Defined Pre/Post Operator",
195 ppo);
196
197 // Let's force all status tests to do a full check
198 nlParams.sublist("Solver Options").set("Status Test Check Type", "Complete");
199
200 // User supplied (Epetra_RowMatrix)
201 Teuchos::RCP<Epetra_RowMatrix> Analytic = interface->getJacobian();
202
203 // Create the linear system
204 Teuchos::RCP<NOX::Epetra::Interface::Required> iReq = interface;
205 Teuchos::RCP<NOX::Epetra::Interface::Jacobian> iJac = interface;
206 Teuchos::RCP<NOX::Epetra::LinearSystemAztecOO> linSys =
207 Teuchos::rcp(new NOX::Epetra::LinearSystemAztecOO(printParams, lsParams,
208 iReq,
209 iJac, Analytic,
210 *noxSoln,
211 scaling));
212
213 // Create the Group
214 Teuchos::RCP<NOX::Epetra::Group> grpPtr =
215 Teuchos::rcp(new NOX::Epetra::Group(printParams,
216 iReq,
217 *noxSoln,
218 linSys));
219 NOX::Epetra::Group& grp = *grpPtr;
220
221 // uncomment the following for loca supergroups
222 //MF->setGroupForComputeF(*grpPtr);
223 //FD->setGroupForComputeF(*grpPtr);
224
225 // Create the convergence tests
226 Teuchos::RCP<NOX::StatusTest::NormF> absresid =
227 Teuchos::rcp(new NOX::StatusTest::NormF(1.0e-8));
228 Teuchos::RCP<NOX::StatusTest::NormF> relresid =
229 Teuchos::rcp(new NOX::StatusTest::NormF(grp, 1.0e-2));
230 Teuchos::RCP<NOX::StatusTest::NormUpdate> update =
231 Teuchos::rcp(new NOX::StatusTest::NormUpdate(1.0e-5));
232 Teuchos::RCP<NOX::StatusTest::NormWRMS> wrms =
233 Teuchos::rcp(new NOX::StatusTest::NormWRMS(1.0e-2, 1.0e-8));
234 Teuchos::RCP<NOX::StatusTest::Combo> converged =
235 Teuchos::rcp(new NOX::StatusTest::Combo(NOX::StatusTest::Combo::AND));
236 converged->addStatusTest(absresid);
237 converged->addStatusTest(relresid);
238 converged->addStatusTest(wrms);
239 converged->addStatusTest(update);
240 Teuchos::RCP<NOX::StatusTest::MaxIters> maxiters =
241 Teuchos::rcp(new NOX::StatusTest::MaxIters(200));
242 Teuchos::RCP<NOX::StatusTest::FiniteValue> fv =
243 Teuchos::rcp(new NOX::StatusTest::FiniteValue);
244 Teuchos::RCP<NOX::StatusTest::Combo> combo =
245 Teuchos::rcp(new NOX::StatusTest::Combo(NOX::StatusTest::Combo::OR));
246 combo->addStatusTest(fv);
247 combo->addStatusTest(converged);
248 combo->addStatusTest(maxiters);
249
250 // Create the solver
251 Teuchos::RCP<NOX::Solver::Generic> solver =
252 NOX::Solver::buildSolver(grpPtr, combo, nlParamsPtr);
253 NOX::StatusTest::StatusType solvStatus = solver->solve();
254
255 // End Nonlinear Solver **************************************
256
257 // Get the Epetra_Vector with the final solution from the solver
258 const NOX::Epetra::Group& finalGroup =
259 dynamic_cast<const NOX::Epetra::Group&>(solver->getSolutionGroup());
260 const Epetra_Vector& finalSolution =
261 (dynamic_cast<const NOX::Epetra::Vector&>(finalGroup.getX())).
262 getEpetraVector();
263
264 // Output the parameter list
265 if (verbose) {
266 if (printing.isPrintType(NOX::Utils::Parameters)) {
267 printing.out() << std::endl << "Final Parameters" << std::endl
268 << "****************" << std::endl;
269 solver->getList().print(printing.out());
270 printing.out() << std::endl;
271 }
272 }
273
274 // Print solution
275 char file_name[25];
276 FILE *ifp;
277 int NumMyElements = soln->Map().NumMyElements();
278 (void) sprintf(file_name, "output.%d",MyPID);
279 ifp = fopen(file_name, "w");
280 for (int i=0; i<NumMyElements; i++)
281 fprintf(ifp, "%d %E\n", soln->Map().MinMyGID()+i, finalSolution[i]);
282 fclose(ifp);
283
284
285 // Tests
286 int status = 0; // Converged
287
288 // 1. Convergence
289 if (solvStatus != NOX::StatusTest::Converged) {
290 status = 1;
291 if (printing.isPrintType(NOX::Utils::Error))
292 printing.out() << "Nonlinear solver failed to converge!" << std::endl;
293 }
294 #ifndef HAVE_MPI
295 // 2. Linear solve iterations (14) - SERIAL TEST ONLY!
296 // The number of linear iterations changes with # of procs.
297 if (const_cast<Teuchos::ParameterList&>(solver->getList()).sublist("Direction").sublist("Newton").sublist("Linear Solver").sublist("Output").get("Total Number of Linear Iterations",0) != 14) {
298 status = 2;
299 }
300 #endif
301 // 3. Nonlinear solve iterations (17)
302 if (const_cast<Teuchos::ParameterList&>(solver->getList()).sublist("Output").get("Nonlinear Iterations", 0) != 17)
303 status = 3;
304 // 4. Test the pre/post iterate options
305 {
306 UserPrePostOperator & ppo2 =
307 dynamic_cast<UserPrePostOperator&>(*ppo.get());
308 if (ppo2.getNumRunPreIterate() != 17)
309 status = 4;
310 if (ppo2.getNumRunPostIterate() != 17)
311 status = 4;
312 if (ppo2.getNumRunPreSolve() != 1)
313 status = 4;
314 if (ppo2.getNumRunPostSolve() != 1)
315 status = 4;
316 }
317 // 5. Number of Cauchy steps (3)
318 if (const_cast<Teuchos::ParameterList&>(solver->getList()).sublist("Trust Region").sublist("Output").get("Number of Cauchy Steps", 0) != 3)
319 status = 5;
320 // 6. Number of Newton steps (14)
321 if (const_cast<Teuchos::ParameterList&>(solver->getList()).sublist("Trust Region").sublist("Output").get("Number of Newton Steps", 0) != 14)
322 status = 6;
323
324 success = status==0;
325
326 TEUCHOS_TEST_EQUALITY(solver->getSolverStatistics()->numNonlinearSolves,1,std::cout,success);
327 TEUCHOS_TEST_EQUALITY(solver->getSolverStatistics()->numNonlinearIterations,17,std::cout,success);
328 TEUCHOS_TEST_EQUALITY(solver->getSolverStatistics()->numTotalNonlinearIterations,17,std::cout,success);
329
330 TEUCHOS_TEST_ASSERT(solver->getSolverStatistics()->linearSolve.lastLinearSolve_Converged,std::cout,success);
331 if (NumProc == 1) {
332 // linear solve iterations changes with processor count, only check for serial
333 TEUCHOS_TEST_EQUALITY(solver->getSolverStatistics()->linearSolve.lastLinearSolve_NumIterations,1,std::cout,success);
334 TEUCHOS_TEST_EQUALITY(solver->getSolverStatistics()->linearSolve.lastNonlinearSolve_NumLinearIterations,14,std::cout,success);
335 TEUCHOS_TEST_EQUALITY(solver->getSolverStatistics()->linearSolve.allNonlinearSolves_NumLinearIterations,14,std::cout,success);
336 }
337 TEUCHOS_TEST_ASSERT(solver->getSolverStatistics()->linearSolve.lastLinearSolve_AchievedTolerance < 1.0e-4,std::cout,success);
338 TEUCHOS_TEST_EQUALITY(solver->getSolverStatistics()->linearSolve.lastNonlinearSolve_NumLinearSolves,14,std::cout,success);
339 TEUCHOS_TEST_EQUALITY(solver->getSolverStatistics()->linearSolve.allNonlinearSolves_NumLinearSolves,14,std::cout,success);
340
341 TEUCHOS_TEST_EQUALITY(solver->getSolverStatistics()->trustRegion.numCauchySteps,3,std::cout,success);
342 TEUCHOS_TEST_EQUALITY(solver->getSolverStatistics()->trustRegion.numNewtonSteps,14,std::cout,success);
343 TEUCHOS_TEST_EQUALITY(solver->getSolverStatistics()->trustRegion.numDoglegSteps,0,std::cout,success);
344 TEUCHOS_TEST_EQUALITY(solver->getSolverStatistics()->trustRegion.numTrustRegionInnerIterations,17,std::cout,success);
345
346 // Summarize test results
347 if (success)
348 printing.out() << "Test passed!" << std::endl;
349 else
350 printing.out() << "Test failed!" << std::endl;
351 }
352 TEUCHOS_STANDARD_CATCH_STATEMENTS(verbose, std::cerr, success);
353
354 #ifdef HAVE_MPI
355 MPI_Finalize();
356 #endif
357
358 return ( success ? EXIT_SUCCESS : EXIT_FAILURE );
359 }