Debian Codegraph @

packages/nox/test/epetra/LOCA_UnitTests/CompositeConstraintMVDX.C

raw
1 // @HEADER
2 // *****************************************************************************
3 // LOCA: Library of Continuation Algorithms Package
4 //
5 // Copyright 2001-2005 NTESS and the LOCA contributors.
6 // SPDX-License-Identifier: BSD-3-Clause
7 // *****************************************************************************
8 // @HEADER
9
10 #include "LOCA.H"
11 #include "LOCA_Epetra.H"
12
13 #include "LOCA_MultiContinuation_CompositeConstraintMVDX.H"
14 #include "NOX_TestCompare.H"
15
16 // Trilinos Objects
17 #ifdef HAVE_MPI
18 #include "Epetra_MpiComm.h"
19 #else
20 #include "Epetra_SerialComm.h"
21 #endif
22 #include "Epetra_Map.h"
23 #include "Epetra_RowMatrix.h"
24 #include "Epetra_CrsMatrix.h"
25
26 // User's application specific files
27 #include "LOCALinearConstraint.H"
28
29 int main(int argc, char *argv[])
30 {
31 int n = 10;
32 int ierr = 0;
33 double reltol = 1.0e-14;
34 double abstol = 1.0e-14;
35 int MyPID = 0;
36
37 try {
38
39 // Initialize MPI
40 #ifdef HAVE_MPI
41 MPI_Init(&argc,&argv);
42 #endif
43
44 // Create a communicator for Epetra objects
45 #ifdef HAVE_MPI
46 Epetra_MpiComm Comm( MPI_COMM_WORLD );
47 #else
48 Epetra_SerialComm Comm;
49 #endif
50
51 MyPID = Comm.MyPID();
52
53 // Create the map
54 Epetra_Map map(n, 0, Comm);
55
56 bool verbose = false;
57 // Check for verbose output
58 if (argc>1)
59 if (argv[1][0]=='-' && argv[1][1]=='v')
60 verbose = true;
61
62 // Seed the random number generator in Teuchos. We create random
63 // bordering matrices and it is possible different processors might generate
64 // different matrices. By setting the seed, this shouldn't happen.
65 Teuchos::ScalarTraits<double>::seedrandom(12345);
66
67 // Create and initialize the parameter vector
68 LOCA::ParameterVector pVector;
69 pVector.addParameter("Param 1", 1.69);
70 pVector.addParameter("Param 2", -9.7);
71 pVector.addParameter("Param 3", 0.35);
72 pVector.addParameter("Param 4", -0.78);
73 pVector.addParameter("Param 5", 2.53);
74
75 // Create parameter list
76 Teuchos::RCP<Teuchos::ParameterList> paramList =
77 Teuchos::rcp(new Teuchos::ParameterList);
78
79 Teuchos::ParameterList& nlParams = paramList->sublist("NOX");
80 Teuchos::ParameterList& nlPrintParams = nlParams.sublist("Printing");
81 nlPrintParams.set("MyPID", MyPID);
82 if (verbose)
83 nlPrintParams.set("Output Information",
84 NOX::Utils::Error +
85 NOX::Utils::Details +
86 NOX::Utils::OuterIteration +
87 NOX::Utils::InnerIteration +
88 NOX::Utils::Warning +
89 NOX::Utils::TestDetails +
90 NOX::Utils::StepperIteration +
91 NOX::Utils::StepperDetails);
92 else
93 nlPrintParams.set("Output Information", NOX::Utils::Error);
94
95 // Create global data object
96 Teuchos::RCP<LOCA::GlobalData> globalData =
97 LOCA::createGlobalData(paramList);
98
99 Epetra_Vector clone_vec(map);
100 NOX::Epetra::Vector nox_clone_vec(clone_vec);
101
102 Teuchos::RCP<NOX::Abstract::Vector> x =
103 nox_clone_vec.clone(NOX::ShapeCopy);
104 x->random();
105
106 Teuchos::RCP<NOX::Abstract::MultiVector> dx1 =
107 nox_clone_vec.createMultiVector(3);
108 Teuchos::RCP<NOX::Abstract::MultiVector> dx2 =
109 nox_clone_vec.createMultiVector(1);
110 Teuchos::RCP<NOX::Abstract::MultiVector> dx3 =
111 nox_clone_vec.createMultiVector(2);
112 Teuchos::RCP<NOX::Abstract::MultiVector> dx4 =
113 nox_clone_vec.createMultiVector(2);
114 dx1->random();
115 dx2->random();
116 dx3->init(0.0);
117 dx4->random();
118
119 Teuchos::RCP<NOX::Abstract::MultiVector> dx_all =
120 dx1->clone(NOX::DeepCopy);
121 dx_all->augment(*dx2);
122 dx_all->augment(*dx3);
123 dx_all->augment(*dx4);
124
125 NOX::Abstract::MultiVector::DenseMatrix dp1(dx1->numVectors(),
126 pVector.length());
127 NOX::Abstract::MultiVector::DenseMatrix dp2(dx2->numVectors(),
128 pVector.length());
129 NOX::Abstract::MultiVector::DenseMatrix dp3(dx3->numVectors(),
130 pVector.length());
131 NOX::Abstract::MultiVector::DenseMatrix dp4(dx4->numVectors(),
132 pVector.length());
133 dp1.random();
134 dp2.random();
135 dp3.random();
136 dp4.random();
137
138 NOX::Abstract::MultiVector::DenseMatrix dp_all(dx_all->numVectors(),
139 pVector.length());
140 for (int j=0; j<dp_all.numCols(); j++) {
141 for (int i=0; i<dp1.numRows(); i++)
142 dp_all(i,j) = dp1(i,j);
143 for (int i=0; i<dp2.numRows(); i++)
144 dp_all(dp1.numRows()+i,j) = dp2(i,j);
145 for (int i=0; i<dp3.numRows(); i++)
146 dp_all(dp1.numRows()+dp2.numRows()+i,j) = dp3(i,j);
147 for (int i=0; i<dp4.numRows(); i++)
148 dp_all(dp1.numRows()+dp2.numRows()+dp3.numRows()+i,j) = dp4(i,j);
149 }
150
151
152 std::vector< Teuchos::RCP<LOCA::MultiContinuation::ConstraintInterfaceMVDX> > constraintObjs(4);
153 Teuchos::RCP<LinearConstraint> linear_constraint;
154
155 linear_constraint = Teuchos::rcp(new LinearConstraint(dx1->numVectors(),
156 pVector,
157 nox_clone_vec));
158 linear_constraint->setDgDx(*dx1);
159 linear_constraint->setDgDp(dp1);
160 linear_constraint->setIsZeroDX(false);
161 constraintObjs[0] = linear_constraint;
162
163 linear_constraint = Teuchos::rcp(new LinearConstraint(dx2->numVectors(),
164 pVector,
165 nox_clone_vec));
166 linear_constraint->setDgDx(*dx2);
167 linear_constraint->setDgDp(dp2);
168 linear_constraint->setIsZeroDX(false);
169 constraintObjs[1] = linear_constraint;
170
171 linear_constraint = Teuchos::rcp(new LinearConstraint(dx3->numVectors(),
172 pVector,
173 nox_clone_vec));
174 linear_constraint->setDgDx(*dx3);
175 linear_constraint->setDgDp(dp3);
176 linear_constraint->setIsZeroDX(true);
177 constraintObjs[2] = linear_constraint;
178
179 linear_constraint = Teuchos::rcp(new LinearConstraint(dx4->numVectors(),
180 pVector,
181 nox_clone_vec));
182 linear_constraint->setDgDx(*dx4);
183 linear_constraint->setDgDp(dp4);
184 linear_constraint->setIsZeroDX(false);
185 constraintObjs[3] = linear_constraint;
186
187 // Check some statistics on the solution
188 NOX::TestCompare testCompare(globalData->locaUtils->out(),
189 *(globalData->locaUtils));
190
191 LOCA::MultiContinuation::CompositeConstraintMVDX composite(globalData,
192 constraintObjs);
193 composite.setX(*x);
194
195 LinearConstraint combined(dx_all->numVectors(), pVector, nox_clone_vec);
196 combined.setDgDx(*dx_all);
197 combined.setDgDp(dp_all);
198 combined.setX(*x);
199
200 int numConstraints = dx_all->numVectors();
201
202 composite.computeConstraints();
203 combined.computeConstraints();
204
205 //
206 // test getDX()
207 //
208
209 composite.computeDX();
210 combined.computeDX();
211
212 const NOX::Abstract::MultiVector *dgdx_composite =
213 composite.getDX();
214 const NOX::Abstract::MultiVector *dgdx_combined =
215 combined.getDX();
216
217 ierr += testCompare.testMultiVector(*dgdx_composite, *dgdx_combined,
218 reltol, abstol,
219 "CompositeConstraintMVDX::getDX()");
220
221
222 //
223 // test multiplyDX()
224 //
225
226 int numMultiply = 5;
227 Teuchos::RCP<NOX::Abstract::MultiVector> A =
228 nox_clone_vec.createMultiVector(numMultiply);
229 A->random();
230 NOX::Abstract::MultiVector::DenseMatrix composite_multiply(numConstraints,
231 numMultiply);
232 NOX::Abstract::MultiVector::DenseMatrix combined_multiply(numConstraints,
233 numMultiply);
234 composite.multiplyDX(2.65, *A, composite_multiply);
235 combined.multiplyDX(2.65, *A, combined_multiply);
236
237 ierr += testCompare.testMatrix(composite_multiply, combined_multiply,
238 reltol, abstol,
239 "CompositeConstraintMVDX::multiplyDX()");
240
241 //
242 // test addDX() (No Trans)
243 //
244
245 int numAdd = 5;
246 NOX::Abstract::MultiVector::DenseMatrix B1(numConstraints, numAdd);
247 B1.random();
248 NOX::Abstract::MultiVector::DenseMatrix B2(numAdd, numConstraints);
249 B2.random();
250
251 Teuchos::RCP<NOX::Abstract::MultiVector> composite_add1 =
252 nox_clone_vec.createMultiVector(numAdd);
253 composite_add1->random();
254 Teuchos::RCP<NOX::Abstract::MultiVector> composite_add2 =
255 nox_clone_vec.createMultiVector(numAdd);
256 composite_add2->random();
257
258 Teuchos::RCP<NOX::Abstract::MultiVector> combined_add1 =
259 composite_add1->clone(NOX::DeepCopy);
260 Teuchos::RCP<NOX::Abstract::MultiVector> combined_add2 =
261 composite_add2->clone(NOX::DeepCopy);
262
263 composite.addDX(Teuchos::NO_TRANS, 1.45, B1, 2.78, *composite_add1);
264 combined.addDX(Teuchos::NO_TRANS, 1.45, B1, 2.78, *combined_add1);
265
266 ierr += testCompare.testMultiVector(
267 *composite_add1, *combined_add1,
268 reltol, abstol,
269 "CompositeConstraintMVDX::addDX() (No Trans)");
270
271 //
272 // test addDX() (Trans)
273 //
274
275 composite.addDX(Teuchos::TRANS, 1.45, B2, 2.78, *composite_add2);
276 combined.addDX(Teuchos::TRANS, 1.45, B2, 2.78, *combined_add2);
277
278 ierr += testCompare.testMultiVector(
279 *composite_add2, *combined_add2,
280 reltol, abstol,
281 "CompositeConstraintMVDX::addDX() (Trans)");
282
283 LOCA::destroyGlobalData(globalData);
284
285 }
286
287 catch (std::exception& e) {
288 std::cout << e.what() << std::endl;
289 ierr = 1;
290 }
291 catch (const char *s) {
292 std::cout << s << std::endl;
293 ierr = 1;
294 }
295 catch (...) {
296 std::cout << "Caught unknown exception!" << std::endl;
297 ierr = 1;
298 }
299
300 if (MyPID == 0) {
301 if (ierr == 0)
302 std::cout << "All tests passed!" << std::endl;
303 else
304 std::cout << ierr << " test(s) failed!" << std::endl;
305 }
306
307 #ifdef HAVE_MPI
308 MPI_Finalize() ;
309 #endif
310
311 return ierr;
312 }