Debian Codegraph @

packages/panzer/adapters-stk/test/evaluator_tests/tpetra_scatter_residual.cpp

raw
1 // @HEADER
2 // *****************************************************************************
3 // Panzer: A partial differential equation assembly
4 // engine for strongly coupled complex multiphysics systems
5 //
6 // Copyright 2011 NTESS and the Panzer contributors.
7 // SPDX-License-Identifier: BSD-3-Clause
8 // *****************************************************************************
9 // @HEADER
10
11 #include <Teuchos_ConfigDefs.hpp>
12 #include <Teuchos_UnitTestHarness.hpp>
13 #include <Teuchos_RCP.hpp>
14 #include <Teuchos_TimeMonitor.hpp>
15
16 using Teuchos::RCP;
17 using Teuchos::rcp;
18
19 #include "Teuchos_DefaultComm.hpp"
20 #include "Teuchos_GlobalMPISession.hpp"
21
22 #include "Panzer_FieldManagerBuilder.hpp"
23 #include "Panzer_DOFManager.hpp"
24 #include "Panzer_TpetraLinearObjFactory.hpp"
25 #include "Panzer_PureBasis.hpp"
26 #include "Panzer_BasisIRLayout.hpp"
27 #include "Panzer_Workset.hpp"
28 #include "Panzer_GatherOrientation.hpp"
29 #include "Panzer_ScatterResidual_Tpetra.hpp"
30 #include "Panzer_GatherSolution_Tpetra.hpp"
31 #include "Panzer_GlobalEvaluationDataContainer.hpp"
32 #include "Panzer_LOCPair_GlobalEvaluationData.hpp"
33 #include "Panzer_ParameterList_GlobalEvaluationData.hpp"
34
35 #include "Panzer_STK_Version.hpp"
36 #include "PanzerAdaptersSTK_config.hpp"
37 #include "Panzer_STK_Interface.hpp"
38 #include "Panzer_STK_SquareQuadMeshFactory.hpp"
39 #include "Panzer_STK_SetupUtilities.hpp"
40 #include "Panzer_STKConnManager.hpp"
41
42 #include "Teuchos_DefaultMpiComm.hpp"
43 #include "Teuchos_OpaqueWrapper.hpp"
44
45 #include "Thyra_VectorStdOps.hpp"
46 #include "Thyra_VectorBase.hpp"
47 #include "Thyra_SpmdVectorBase.hpp"
48
49 #include "user_app_EquationSetFactory.hpp"
50
51 #include <cstdio> // for get char
52 #include <vector>
53 #include <string>
54
55 #include "Panzer_Evaluator_WithBaseImpl.hpp"
56
57 namespace panzer
58 {
59 typedef Teuchos::ArrayRCP<const double>::size_type size_type;
60
61 using TpetraLinObjFactoryType = panzer::TpetraLinearObjFactory<panzer::Traits, double, panzer::LocalOrdinal, panzer::GlobalOrdinal>;
62 using TpetraLinObjContainerType = panzer::TpetraLinearObjContainer<double, panzer::LocalOrdinal, panzer::GlobalOrdinal>;
63
64 Teuchos::RCP<panzer::PureBasis> buildBasis(std::size_t worksetSize, const std::string &basisName);
65 void testInitialization(const Teuchos::RCP<Teuchos::ParameterList> &ipb);
66 Teuchos::RCP<panzer_stk::STK_Interface> buildMesh(int elemX, int elemY);
67
68 TEUCHOS_UNIT_TEST(assembly, scatter_solution_residual)
69 {
70
71 #ifdef HAVE_MPI
72 Teuchos::RCP<Teuchos::MpiComm<int>> tComm = Teuchos::rcp(new Teuchos::MpiComm<int>(MPI_COMM_WORLD));
73 #else
74 NOPE_PANZER_DOESNT_SUPPORT_SERIAL
75 #endif
76
77 int myRank = tComm->getRank();
78
79 const std::size_t workset_size = 4;
80 const std::string fieldName1_q1 = "U";
81 const std::string fieldName2_q1 = "V";
82 const std::string fieldName_qedge1 = "B";
83
84 Teuchos::RCP<panzer_stk::STK_Interface> mesh = buildMesh(2, 2);
85
86 // build input physics block
87 Teuchos::RCP<panzer::PureBasis> basis_q1 = buildBasis(workset_size, "Q1");
88 Teuchos::RCP<panzer::PureBasis> basis_qedge1 = buildBasis(workset_size, "QEdge1");
89
90 Teuchos::RCP<Teuchos::ParameterList> ipb = Teuchos::parameterList();
91 testInitialization(ipb);
92
93 const int default_int_order = 1;
94 std::string eBlockID = "eblock-0_0";
95 Teuchos::RCP<user_app::MyFactory> eqset_factory = Teuchos::rcp(new user_app::MyFactory);
96 panzer::CellData cellData(workset_size, mesh->getCellTopology("eblock-0_0"));
97 Teuchos::RCP<panzer::GlobalData> gd = panzer::createGlobalData();
98 Teuchos::RCP<panzer::PhysicsBlock> physicsBlock =
99 Teuchos::rcp(new PhysicsBlock(ipb, eBlockID, default_int_order, cellData, eqset_factory, gd, false));
100
101 Teuchos::RCP<std::vector<panzer::Workset>> work_sets = panzer_stk::buildWorksets(*mesh, physicsBlock->elementBlockID(),
102 physicsBlock->getWorksetNeeds());
103 TEST_EQUALITY(work_sets->size(), 1);
104
105 // build connection manager and field manager
106 const Teuchos::RCP<panzer::ConnManager> conn_manager = Teuchos::rcp(new panzer_stk::STKConnManager(mesh));
107 RCP<panzer::DOFManager> dofManager = Teuchos::rcp(new panzer::DOFManager(conn_manager, MPI_COMM_WORLD));
108
109 dofManager->addField(fieldName1_q1, Teuchos::rcp(new panzer::Intrepid2FieldPattern(basis_q1->getIntrepid2Basis())));
110 dofManager->addField(fieldName2_q1, Teuchos::rcp(new panzer::Intrepid2FieldPattern(basis_q1->getIntrepid2Basis())));
111 dofManager->addField(fieldName_qedge1, Teuchos::rcp(new panzer::Intrepid2FieldPattern(basis_qedge1->getIntrepid2Basis())));
112
113 std::vector<std::string> fieldOrder;
114 fieldOrder.push_back(fieldName1_q1);
115 fieldOrder.push_back(fieldName_qedge1);
116 fieldOrder.push_back(fieldName2_q1);
117 dofManager->setFieldOrder(fieldOrder);
118
119 dofManager->buildGlobalUnknowns();
120
121 // setup linear object factory
122 /////////////////////////////////////////////////////////////
123 Teuchos::RCP<TpetraLinObjFactoryType> t_lof = Teuchos::rcp(new TpetraLinObjFactoryType(tComm.getConst(), dofManager));
124 Teuchos::RCP<LinearObjFactory<panzer::Traits>> lof = t_lof;
125 Teuchos::RCP<LinearObjContainer> loc = t_lof->buildGhostedLinearObjContainer();
126 t_lof->initializeGhostedContainer(LinearObjContainer::X | LinearObjContainer::F, *loc);
127 loc->initialize();
128
129 Teuchos::RCP<TpetraLinObjContainerType> t_loc = Teuchos::rcp_dynamic_cast<TpetraLinObjContainerType>(loc);
130
131 Teuchos::RCP<Thyra::VectorBase<double>> x_vec = t_loc->get_x_th();
132 Thyra::assign(x_vec.ptr(), 123.0 + myRank);
133
134 // setup field manager, add evaluator under test
135 /////////////////////////////////////////////////////////////
136
137 PHX::FieldManager<panzer::Traits> fm;
138
139 std::string resName = "";
140 Teuchos::RCP<std::map<std::string, std::string>> names_map =
141 Teuchos::rcp(new std::map<std::string, std::string>);
142 names_map->insert(std::make_pair(fieldName1_q1, resName + fieldName1_q1));
143 names_map->insert(std::make_pair(fieldName2_q1, resName + fieldName2_q1));
144 names_map->insert(std::make_pair(fieldName_qedge1, resName + fieldName_qedge1));
145
146 // evaluators under test
147 {
148 using Teuchos::RCP;
149 using Teuchos::rcp;
150 RCP<std::vector<std::string>> names = rcp(new std::vector<std::string>);
151 names->push_back(resName + fieldName1_q1);
152 names->push_back(resName + fieldName2_q1);
153
154 Teuchos::ParameterList pl;
155 pl.set("Scatter Name", "ScatterQ1");
156 pl.set("Basis", basis_q1.getConst());
157 pl.set("Dependent Names", names);
158 pl.set("Dependent Map", names_map);
159
160 Teuchos::RCP<PHX::Evaluator<panzer::Traits>> evaluator = lof->buildScatter<panzer::Traits::Residual>(pl);
161
162 TEST_EQUALITY(evaluator->evaluatedFields().size(), 1);
163
164 fm.registerEvaluator<panzer::Traits::Residual>(evaluator);
165 fm.requireField<panzer::Traits::Residual>(*evaluator->evaluatedFields()[0]);
166 }
167 {
168 using Teuchos::RCP;
169 using Teuchos::rcp;
170 RCP<std::vector<std::string>> names = rcp(new std::vector<std::string>);
171 names->push_back(resName + fieldName_qedge1);
172
173 Teuchos::ParameterList pl;
174 pl.set("Scatter Name", "ScatterQEdge1");
175 pl.set("Basis", basis_qedge1.getConst());
176 pl.set("Dependent Names", names);
177 pl.set("Dependent Map", names_map);
178
179 Teuchos::RCP<PHX::Evaluator<panzer::Traits>> evaluator = lof->buildScatter<panzer::Traits::Residual>(pl);
180
181 TEST_EQUALITY(evaluator->evaluatedFields().size(), 1);
182
183 fm.registerEvaluator<panzer::Traits::Residual>(evaluator);
184 fm.requireField<panzer::Traits::Residual>(*evaluator->evaluatedFields()[0]);
185 }
186
187 // support evaluators
188 {
189 using Teuchos::RCP;
190 using Teuchos::rcp;
191 RCP<std::vector<std::string>> names = rcp(new std::vector<std::string>);
192 names->push_back(fieldName1_q1);
193 names->push_back(fieldName2_q1);
194
195 Teuchos::ParameterList pl;
196 pl.set("Basis", basis_q1);
197 pl.set("DOF Names", names);
198 pl.set("Indexer Names", names);
199
200 Teuchos::RCP<PHX::Evaluator<panzer::Traits>> evaluator = lof->buildGather<panzer::Traits::Residual>(pl);
201
202 fm.registerEvaluator<panzer::Traits::Residual>(evaluator);
203 }
204 {
205 using Teuchos::RCP;
206 using Teuchos::rcp;
207 RCP<std::vector<std::string>> names = rcp(new std::vector<std::string>);
208 names->push_back(fieldName_qedge1);
209
210 Teuchos::ParameterList pl;
211 pl.set("Basis", basis_qedge1);
212 pl.set("DOF Names", names);
213 pl.set("Indexer Names", names);
214
215 Teuchos::RCP<PHX::Evaluator<panzer::Traits>> evaluator = lof->buildGather<panzer::Traits::Residual>(pl);
216
217 fm.registerEvaluator<panzer::Traits::Residual>(evaluator);
218 }
219
220 panzer::Traits::SD sd;
221 sd.worksets_ = work_sets;
222
223 fm.postRegistrationSetup(sd);
224
225 panzer::Traits::PED ped;
226 ped.gedc->addDataObject("Solution Gather Container", loc);
227 ped.gedc->addDataObject("Residual Scatter Container", loc);
228 fm.preEvaluate<panzer::Traits::Residual>(ped);
229
230 // run tests
231 /////////////////////////////////////////////////////////////
232
233 panzer::Workset &workset = (*work_sets)[0];
234 workset.alpha = 0.0;
235 workset.beta = 2.0; // derivatives multiplied by 2
236 workset.time = 0.0;
237 workset.evaluate_transient_terms = false;
238
239 fm.evaluateFields<panzer::Traits::Residual>(workset);
240 fm.postEvaluate<panzer::Traits::Residual>(0);
241
242 // test Residual fields
243 Teuchos::ArrayRCP<const double> data;
244 Teuchos::RCP<const Thyra::VectorBase<double>> f_vec = t_loc->get_f_th();
245
246 // check all the residual values. This is kind of crappy test since it simply checks twice the target
247 // value and the target. Its this way because you add two entries across elements.
248
249 Teuchos::rcp_dynamic_cast<const Thyra::SpmdVectorBase<double>>(f_vec)->getLocalData(Teuchos::ptrFromRef(data));
250 for (size_type i = 0; i < data.size(); i++)
251 {
252 double target = 123.0 + myRank;
253 TEST_ASSERT(data[i] == target || data[i] == 2.0 * target);
254 }
255
256 }
257
258 TEUCHOS_UNIT_TEST(assembly, scatter_solution_jacobian)
259 {
260 // TODO BWR not checking the jacobian calculation, just the residual part!!!
261
262 #ifdef HAVE_MPI
263 Teuchos::RCP<Teuchos::MpiComm<int>> tComm = Teuchos::rcp(new Teuchos::MpiComm<int>(MPI_COMM_WORLD));
264 #else
265 NOPE_PANZER_DOESNT_SUPPORT_SERIAL
266 #endif
267
268 int myRank = tComm->getRank();
269
270 const std::size_t workset_size = 4;
271 const std::string fieldName1_q1 = "U";
272 const std::string fieldName2_q1 = "V";
273 const std::string fieldName_qedge1 = "B";
274
275 Teuchos::RCP<panzer_stk::STK_Interface> mesh = buildMesh(2, 2);
276
277 // build input physics block
278 Teuchos::RCP<panzer::PureBasis> basis_q1 = buildBasis(workset_size, "Q1");
279 Teuchos::RCP<panzer::PureBasis> basis_qedge1 = buildBasis(workset_size, "QEdge1");
280
281 Teuchos::RCP<Teuchos::ParameterList> ipb = Teuchos::parameterList();
282 testInitialization(ipb);
283
284 const int default_int_order = 1;
285 std::string eBlockID = "eblock-0_0";
286 Teuchos::RCP<user_app::MyFactory> eqset_factory = Teuchos::rcp(new user_app::MyFactory);
287 panzer::CellData cellData(workset_size, mesh->getCellTopology("eblock-0_0"));
288 Teuchos::RCP<panzer::GlobalData> gd = panzer::createGlobalData();
289 Teuchos::RCP<panzer::PhysicsBlock> physicsBlock =
290 Teuchos::rcp(new PhysicsBlock(ipb, eBlockID, default_int_order, cellData, eqset_factory, gd, false));
291
292 Teuchos::RCP<std::vector<panzer::Workset>> work_sets = panzer_stk::buildWorksets(*mesh, physicsBlock->elementBlockID(),
293 physicsBlock->getWorksetNeeds());
294 TEST_EQUALITY(work_sets->size(), 1);
295
296 // build connection manager and field manager
297 const Teuchos::RCP<panzer::ConnManager> conn_manager = Teuchos::rcp(new panzer_stk::STKConnManager(mesh));
298 RCP<panzer::DOFManager> dofManager = Teuchos::rcp(new panzer::DOFManager(conn_manager, MPI_COMM_WORLD));
299
300 dofManager->addField(fieldName1_q1, Teuchos::rcp(new panzer::Intrepid2FieldPattern(basis_q1->getIntrepid2Basis())));
301 dofManager->addField(fieldName2_q1, Teuchos::rcp(new panzer::Intrepid2FieldPattern(basis_q1->getIntrepid2Basis())));
302 dofManager->addField(fieldName_qedge1, Teuchos::rcp(new panzer::Intrepid2FieldPattern(basis_qedge1->getIntrepid2Basis())));
303
304 std::vector<std::string> fieldOrder;
305 fieldOrder.push_back(fieldName1_q1);
306 fieldOrder.push_back(fieldName_qedge1);
307 fieldOrder.push_back(fieldName2_q1);
308 dofManager->setFieldOrder(fieldOrder);
309
310 dofManager->buildGlobalUnknowns();
311
312 // setup linear object factory
313 /////////////////////////////////////////////////////////////
314 Teuchos::RCP<TpetraLinObjFactoryType> t_lof = Teuchos::rcp(new TpetraLinObjFactoryType(tComm.getConst(), dofManager));
315 Teuchos::RCP<LinearObjFactory<panzer::Traits>> lof = t_lof;
316 Teuchos::RCP<LinearObjContainer> loc = t_lof->buildGhostedLinearObjContainer();
317 t_lof->initializeGhostedContainer(LinearObjContainer::X | LinearObjContainer::F | LinearObjContainer::Mat, *loc);
318 loc->initialize();
319
320 Teuchos::RCP<TpetraLinObjContainerType> t_loc = Teuchos::rcp_dynamic_cast<TpetraLinObjContainerType>(loc);
321
322 Teuchos::RCP<Thyra::VectorBase<double>> x_vec = t_loc->get_x_th();
323 Thyra::assign(x_vec.ptr(), 123.0 + myRank);
324
325 // setup field manager, add evaluator under test
326 /////////////////////////////////////////////////////////////
327
328 PHX::FieldManager<panzer::Traits> fm;
329
330 std::vector<PHX::index_size_type> derivative_dimensions;
331 derivative_dimensions.push_back(12);
332 fm.setKokkosExtendedDataTypeDimensions<panzer::Traits::Jacobian>(derivative_dimensions);
333
334 std::string resName = "";
335 Teuchos::RCP<std::map<std::string, std::string>> names_map =
336 Teuchos::rcp(new std::map<std::string, std::string>);
337 names_map->insert(std::make_pair(fieldName1_q1, resName + fieldName1_q1));
338 names_map->insert(std::make_pair(fieldName2_q1, resName + fieldName2_q1));
339 names_map->insert(std::make_pair(fieldName_qedge1, resName + fieldName_qedge1));
340
341 // evaluators under test
342 {
343 using Teuchos::RCP;
344 using Teuchos::rcp;
345 RCP<std::vector<std::string>> names = rcp(new std::vector<std::string>);
346 names->push_back(resName + fieldName1_q1);
347 names->push_back(resName + fieldName2_q1);
348
349 Teuchos::ParameterList pl;
350 pl.set("Scatter Name", "ScatterQ1");
351 pl.set("Basis", basis_q1.getConst());
352 pl.set("Dependent Names", names);
353 pl.set("Dependent Map", names_map);
354
355 Teuchos::RCP<PHX::Evaluator<panzer::Traits>> evaluator = lof->buildScatter<panzer::Traits::Jacobian>(pl);
356
357 TEST_EQUALITY(evaluator->evaluatedFields().size(), 1);
358
359 fm.registerEvaluator<panzer::Traits::Jacobian>(evaluator);
360 fm.requireField<panzer::Traits::Jacobian>(*evaluator->evaluatedFields()[0]);
361 }
362 {
363 using Teuchos::RCP;
364 using Teuchos::rcp;
365 RCP<std::vector<std::string>> names = rcp(new std::vector<std::string>);
366 names->push_back(resName + fieldName_qedge1);
367
368 Teuchos::ParameterList pl;
369 pl.set("Scatter Name", "ScatterQEdge1");
370 pl.set("Basis", basis_qedge1.getConst());
371 pl.set("Dependent Names", names);
372 pl.set("Dependent Map", names_map);
373
374 Teuchos::RCP<PHX::Evaluator<panzer::Traits>> evaluator = lof->buildScatter<panzer::Traits::Jacobian>(pl);
375
376 TEST_EQUALITY(evaluator->evaluatedFields().size(), 1);
377
378 fm.registerEvaluator<panzer::Traits::Jacobian>(evaluator);
379 fm.requireField<panzer::Traits::Jacobian>(*evaluator->evaluatedFields()[0]);
380 }
381
382 // support evaluators
383 {
384 using Teuchos::RCP;
385 using Teuchos::rcp;
386 RCP<std::vector<std::string>> names = rcp(new std::vector<std::string>);
387 names->push_back(fieldName1_q1);
388 names->push_back(fieldName2_q1);
389
390 Teuchos::ParameterList pl;
391 pl.set("Basis", basis_q1);
392 pl.set("DOF Names", names);
393 pl.set("Indexer Names", names);
394
395 Teuchos::RCP<PHX::Evaluator<panzer::Traits>> evaluator = lof->buildGather<panzer::Traits::Jacobian>(pl);
396
397 fm.registerEvaluator<panzer::Traits::Jacobian>(evaluator);
398 }
399 {
400 using Teuchos::RCP;
401 using Teuchos::rcp;
402 RCP<std::vector<std::string>> names = rcp(new std::vector<std::string>);
403 names->push_back(fieldName_qedge1);
404
405 Teuchos::ParameterList pl;
406 pl.set("Basis", basis_qedge1);
407 pl.set("DOF Names", names);
408 pl.set("Indexer Names", names);
409
410 Teuchos::RCP<PHX::Evaluator<panzer::Traits>> evaluator = lof->buildGather<panzer::Traits::Jacobian>(pl);
411
412 fm.registerEvaluator<panzer::Traits::Jacobian>(evaluator);
413 }
414
415 panzer::Traits::SD sd;
416 sd.worksets_ = work_sets;
417
418 fm.postRegistrationSetup(sd);
419
420 panzer::Traits::PED ped;
421 ped.gedc->addDataObject("Solution Gather Container", loc);
422 ped.gedc->addDataObject("Residual Scatter Container", loc);
423 fm.preEvaluate<panzer::Traits::Jacobian>(ped);
424
425 // run tests
426 /////////////////////////////////////////////////////////////
427
428 panzer::Workset &workset = (*work_sets)[0];
429 workset.alpha = 0.0;
430 workset.beta = 2.0; // derivatives multiplied by 2
431 workset.time = 0.0;
432 workset.evaluate_transient_terms = false;
433
434 fm.evaluateFields<panzer::Traits::Jacobian>(workset);
435 fm.postEvaluate<panzer::Traits::Jacobian>(0);
436
437 // test Jacobian fields
438 Teuchos::ArrayRCP<const double> data;
439 Teuchos::RCP<const Thyra::VectorBase<double>> f_vec = t_loc->get_f_th();
440
441 // check all the residual values. This is kind of crappy test since it simply checks twice the target
442 // value and the target. Its this way because you add two entries across elements.
443
444 Teuchos::rcp_dynamic_cast<const Thyra::SpmdVectorBase<double>>(f_vec)->getLocalData(Teuchos::ptrFromRef(data));
445 for (size_type i = 0; i < data.size(); i++)
446 {
447 double target = 123.0 + myRank;
448 TEST_ASSERT(data[i] == target || data[i] == 2.0 * target);
449 }
450
451 }
452
453 TEUCHOS_UNIT_TEST(assembly, scatter_solution_tangent)
454 {
455
456 #ifdef HAVE_MPI
457 Teuchos::RCP<Teuchos::MpiComm<int>> tComm = Teuchos::rcp(new Teuchos::MpiComm<int>(MPI_COMM_WORLD));
458 #else
459 NOPE_PANZER_DOESNT_SUPPORT_SERIAL
460 #endif
461
462 int myRank = tComm->getRank();
463
464 const std::size_t workset_size = 4;
465 const std::string fieldName1_q1 = "U";
466 const std::string fieldName2_q1 = "V";
467 const std::string fieldName_qedge1 = "B";
468 const std::size_t numParams = 3;
469
470 Teuchos::RCP<panzer_stk::STK_Interface> mesh = buildMesh(2, 2);
471
472 // build input physics block
473 Teuchos::RCP<panzer::PureBasis> basis_q1 = buildBasis(workset_size, "Q1");
474 Teuchos::RCP<panzer::PureBasis> basis_qedge1 = buildBasis(workset_size, "QEdge1");
475
476 Teuchos::RCP<Teuchos::ParameterList> ipb = Teuchos::parameterList();
477 testInitialization(ipb);
478
479 const int default_int_order = 1;
480 std::string eBlockID = "eblock-0_0";
481 Teuchos::RCP<user_app::MyFactory> eqset_factory = Teuchos::rcp(new user_app::MyFactory);
482 panzer::CellData cellData(workset_size, mesh->getCellTopology("eblock-0_0"));
483 Teuchos::RCP<panzer::GlobalData> gd = panzer::createGlobalData();
484 Teuchos::RCP<panzer::PhysicsBlock> physicsBlock =
485 Teuchos::rcp(new PhysicsBlock(ipb, eBlockID, default_int_order, cellData, eqset_factory, gd, false));
486
487 Teuchos::RCP<std::vector<panzer::Workset>> work_sets = panzer_stk::buildWorksets(*mesh, physicsBlock->elementBlockID(),
488 physicsBlock->getWorksetNeeds());
489 TEST_EQUALITY(work_sets->size(), 1);
490
491 // build connection manager and field manager
492 const Teuchos::RCP<panzer::ConnManager> conn_manager = Teuchos::rcp(new panzer_stk::STKConnManager(mesh));
493 RCP<panzer::DOFManager> dofManager = Teuchos::rcp(new panzer::DOFManager(conn_manager, MPI_COMM_WORLD));
494
495 dofManager->addField(fieldName1_q1, Teuchos::rcp(new panzer::Intrepid2FieldPattern(basis_q1->getIntrepid2Basis())));
496 dofManager->addField(fieldName2_q1, Teuchos::rcp(new panzer::Intrepid2FieldPattern(basis_q1->getIntrepid2Basis())));
497 dofManager->addField(fieldName_qedge1, Teuchos::rcp(new panzer::Intrepid2FieldPattern(basis_qedge1->getIntrepid2Basis())));
498
499 std::vector<std::string> fieldOrder;
500 fieldOrder.push_back(fieldName1_q1);
501 fieldOrder.push_back(fieldName_qedge1);
502 fieldOrder.push_back(fieldName2_q1);
503 dofManager->setFieldOrder(fieldOrder);
504
505 dofManager->buildGlobalUnknowns();
506
507 // setup linear object factory
508 /////////////////////////////////////////////////////////////
509 Teuchos::RCP<TpetraLinObjFactoryType> t_lof = Teuchos::rcp(new TpetraLinObjFactoryType(tComm.getConst(), dofManager));
510 Teuchos::RCP<LinearObjFactory<panzer::Traits>> lof = t_lof;
511 Teuchos::RCP<LinearObjContainer> loc = t_lof->buildGhostedLinearObjContainer();
512 t_lof->initializeGhostedContainer(LinearObjContainer::X | LinearObjContainer::F , *loc);
513 loc->initialize();
514
515 Teuchos::RCP<TpetraLinObjContainerType> t_loc = Teuchos::rcp_dynamic_cast<TpetraLinObjContainerType>(loc);
516 Teuchos::RCP<Thyra::VectorBase<double>> x_vec = t_loc->get_x_th();
517 Thyra::assign(x_vec.ptr(), 123.0 + myRank);
518
519 std::vector<Teuchos::RCP<GlobalEvaluationData>> tangentContainers;
520
521 using LOCPair = panzer::LOCPair_GlobalEvaluationData;
522 using Teuchos::rcp_dynamic_cast;
523
524 // generate tangent data
525 for (std::size_t i=0;i<numParams; ++i){
526 auto locPair = Teuchos::rcp(new LOCPair(t_lof, panzer::LinearObjContainer::X));
527
528 auto global_t_loc = rcp_dynamic_cast<TpetraLinObjContainerType>(locPair->getGlobalLOC());
529 Teuchos::RCP<Thyra::VectorBase<double>> global_x_vec = global_t_loc->get_x_th();
530 Thyra::assign(global_x_vec.ptr(), 0.123 + myRank + i);
531
532 auto ghosted_t_loc = rcp_dynamic_cast<TpetraLinObjContainerType>(locPair->getGhostedLOC());
533 Teuchos::RCP<Thyra::VectorBase<double>> ghosted_x_vec = ghosted_t_loc->get_x_th();
534 Thyra::assign(ghosted_x_vec.ptr(), 0.123 + myRank + i);
535
536 tangentContainers.push_back(locPair);
537 }
538
539 // setup field manager, add evaluator under test
540 /////////////////////////////////////////////////////////////
541
542 auto fm = Teuchos::rcp(new PHX::FieldManager<panzer::Traits>);
543
544 std::vector<PHX::index_size_type> derivative_dimensions;
545 derivative_dimensions.push_back(numParams);
546 fm->setKokkosExtendedDataTypeDimensions<panzer::Traits::Tangent>(derivative_dimensions);
547
548 std::string resName = "";
549 Teuchos::RCP<std::map<std::string, std::string>> names_map =
550 Teuchos::rcp(new std::map<std::string, std::string>);
551 names_map->insert(std::make_pair(fieldName1_q1, resName + fieldName1_q1));
552 names_map->insert(std::make_pair(fieldName2_q1, resName + fieldName2_q1));
553 names_map->insert(std::make_pair(fieldName_qedge1, resName + fieldName_qedge1));
554
555 // Guide to what's happening in this test
556 // 1) U,V,B gathers request tangent fields so those are first gathered with gatherTangent
557 // 2) When U,V,B gathers occur, the tangents are stored as derivatives. The first tangent is the first derivative and so on.
558 // 3) U,V,B are overloaded to also be the residual fields we are scattering
559 // 4) This means their derivatives, e.g., U.dx(i) are considered to be dfdp_i -> derivatives of the residuals w.r.t. parameters.
560 // 5) dfdp_i = f.dx(i) so the number of tangents is the number of params
561
562 // evaluators under test
563 {
564 using Teuchos::RCP;
565 using Teuchos::rcp;
566 RCP<std::vector<std::string>> names = rcp(new std::vector<std::string>);
567 names->push_back(resName + fieldName1_q1);
568 names->push_back(resName + fieldName2_q1);
569
570 Teuchos::ParameterList pl;
571 pl.set("Scatter Name", "ScatterQ1");
572 pl.set("Basis", basis_q1.getConst());
573 pl.set("Dependent Names", names);
574 pl.set("Dependent Map", names_map);
575
576 Teuchos::RCP<PHX::Evaluator<panzer::Traits>> evaluator = lof->buildScatter<panzer::Traits::Tangent>(pl);
577
578 TEST_EQUALITY(evaluator->evaluatedFields().size(), 1);
579
580 fm->registerEvaluator<panzer::Traits::Tangent>(evaluator);
581 fm->requireField<panzer::Traits::Tangent>(*evaluator->evaluatedFields()[0]);
582 }
583 {
584 using Teuchos::RCP;
585 using Teuchos::rcp;
586 RCP<std::vector<std::string>> names = rcp(new std::vector<std::string>);
587 names->push_back(resName + fieldName_qedge1);
588
589 Teuchos::ParameterList pl;
590 pl.set("Scatter Name", "ScatterQEdge1");
591 pl.set("Basis", basis_qedge1.getConst());
592 pl.set("Dependent Names", names);
593 pl.set("Dependent Map", names_map);
594
595 Teuchos::RCP<PHX::Evaluator<panzer::Traits>> evaluator = lof->buildScatter<panzer::Traits::Tangent>(pl);
596
597 TEST_EQUALITY(evaluator->evaluatedFields().size(), 1);
598
599 fm->registerEvaluator<panzer::Traits::Tangent>(evaluator);
600 fm->requireField<panzer::Traits::Tangent>(*evaluator->evaluatedFields()[0]);
601 }
602
603 // support evaluators
604 {
605 using Teuchos::RCP;
606 using Teuchos::rcp;
607 RCP<std::vector<std::string>> names = rcp(new std::vector<std::string>);
608 names->push_back(fieldName1_q1);
609 names->push_back(fieldName2_q1);
610
611 Teuchos::ParameterList pl;
612 pl.set("Basis", basis_q1);
613 pl.set("DOF Names", names);
614 pl.set("Indexer Names", names);
615 Teuchos::RCP<std::vector<std::vector<std::string>>> tangent_names =
616 Teuchos::rcp(new std::vector<std::vector<std::string>>(2));
617 for (std::size_t i = 0; i < numParams; ++i)
618 {
619 std::stringstream ss1, ss2;
620 ss1 << fieldName1_q1 << " Tangent " << i;
621 ss2 << fieldName2_q1 << " Tangent " << i;
622 (*tangent_names)[0].push_back(ss1.str());
623 (*tangent_names)[1].push_back(ss2.str());
624 }
625 pl.set("Tangent Names", tangent_names);
626
627 Teuchos::RCP<PHX::Evaluator<panzer::Traits>> evaluator = lof->buildGather<panzer::Traits::Tangent>(pl);
628
629 fm->registerEvaluator<panzer::Traits::Tangent>(evaluator);
630 }
631 for (std::size_t i = 0; i < numParams; ++i) {
632 using Teuchos::RCP;
633 using Teuchos::rcp;
634 RCP<std::vector<std::string>> names = rcp(new std::vector<std::string>);
635 RCP<std::vector<std::string>> tangent_names = rcp(new std::vector<std::string>);
636 names->push_back(fieldName1_q1);
637 names->push_back(fieldName2_q1);
638 {
639 std::stringstream ss1, ss2;
640 ss1 << fieldName1_q1 << " Tangent " << i;
641 ss2 << fieldName2_q1 << " Tangent " << i;
642 tangent_names->push_back(ss1.str());
643 tangent_names->push_back(ss2.str());
644 }
645
646 Teuchos::ParameterList pl;
647 pl.set("Basis", basis_q1);
648 pl.set("DOF Names", tangent_names);
649 pl.set("Indexer Names", names);
650
651 std::stringstream ss;
652 ss << "Tangent Container " << i;
653 pl.set("Global Data Key", ss.str());
654
655 Teuchos::RCP<PHX::Evaluator<panzer::Traits>> evaluator =
656 lof->buildGatherTangent<panzer::Traits::Tangent>(pl);
657
658 fm->registerEvaluator<panzer::Traits::Tangent>(evaluator);
659 }
660 {
661 using Teuchos::RCP;
662 using Teuchos::rcp;
663 RCP<std::vector<std::string>> names = rcp(new std::vector<std::string>);
664 names->push_back(fieldName_qedge1);
665
666 Teuchos::ParameterList pl;
667 pl.set("Basis", basis_qedge1);
668 pl.set("DOF Names", names);
669 pl.set("Indexer Names", names);
670 Teuchos::RCP<std::vector<std::vector<std::string>>> tangent_names =
671 Teuchos::rcp(new std::vector<std::vector<std::string>>(1));
672 for (std::size_t i = 0; i < numParams; ++i)
673 {
674 std::stringstream ss;
675 ss << fieldName_qedge1 << " Tangent " << i;
676 (*tangent_names)[0].push_back(ss.str());
677 }
678 pl.set("Tangent Names", tangent_names);
679
680 Teuchos::RCP<PHX::Evaluator<panzer::Traits>> evaluator = lof->buildGather<panzer::Traits::Tangent>(pl);
681
682 fm->registerEvaluator<panzer::Traits::Tangent>(evaluator);
683 }
684 for (std::size_t i = 0; i < numParams; ++i) {
685 using Teuchos::RCP;
686 using Teuchos::rcp;
687 RCP<std::vector<std::string>> names = rcp(new std::vector<std::string>);
688 RCP<std::vector<std::string>> tangent_names = rcp(new std::vector<std::string>);
689 names->push_back(fieldName_qedge1);
690 {
691 std::stringstream ss;
692 ss << fieldName_qedge1 << " Tangent " << i;
693 tangent_names->push_back(ss.str());
694 }
695
696 Teuchos::ParameterList pl;
697 pl.set("Basis", basis_qedge1);
698 pl.set("DOF Names", tangent_names);
699 pl.set("Indexer Names", names);
700
701 std::stringstream ss;
702 ss << "Tangent Container " << i;
703 pl.set("Global Data Key", ss.str());
704
705 Teuchos::RCP<PHX::Evaluator<panzer::Traits>> evaluator =
706 lof->buildGatherTangent<panzer::Traits::Tangent>(pl);
707
708 fm->registerEvaluator<panzer::Traits::Tangent>(evaluator);
709 }
710 panzer::Traits::SD sd;
711 sd.worksets_ = work_sets;
712
713 fm->postRegistrationSetup(sd);
714
715 panzer::Traits::PED ped;
716 ped.gedc->addDataObject("Solution Gather Container", loc);
717 ped.gedc->addDataObject("Residual Scatter Container", loc);
718 for (size_t i=0; i<numParams; ++i) {
719 std::stringstream ss;
720 ss << "Tangent Container " << i;
721 ped.gedc->addDataObject(ss.str(), tangentContainers[i]);
722 }
723 std::vector<std::string> params;
724 std::vector<Teuchos::RCP<LOCPair>> paramContainers;
725 for (std::size_t i = 0; i<numParams; ++i) {
726 std::stringstream ss;
727 ss << "param" << i;
728 params.push_back(ss.str());
729 auto paramContainer = Teuchos::rcp(new LOCPair(t_lof, panzer::LinearObjContainer::X | panzer::LinearObjContainer::F));
730 ped.gedc->addDataObject(ss.str(),paramContainer->getGhostedLOC());
731 paramContainers.push_back(paramContainer);
732 }
733 Teuchos::RCP<panzer::GlobalEvaluationData> activeParams =
734 Teuchos::rcp(new panzer::ParameterList_GlobalEvaluationData(params));
735 ped.gedc->addDataObject("PARAMETER_NAMES",activeParams);
736
737 fm->preEvaluate<panzer::Traits::Tangent>(ped);
738
739 // run tests
740 /////////////////////////////////////////////////////////////
741
742 panzer::Workset &workset = (*work_sets)[0];
743 workset.alpha = 0.0;
744 workset.beta = 2.0; // derivatives multiplied by 2
745 workset.time = 0.0;
746 workset.evaluate_transient_terms = false;
747
748 fm->evaluateFields<panzer::Traits::Tangent>(workset);
749 fm->postEvaluate<panzer::Traits::Tangent>(0);
750
751 fm = Teuchos::null;
752
753 // test Tangent fields
754 {
755 Teuchos::ArrayRCP<const double> data;
756 Teuchos::RCP<const Thyra::VectorBase<double>> f_vec = t_loc->get_f_th();
757
758 // check all the residual values. This is kind of crappy test since it simply checks twice the target
759 // value and the target. Its this way because you add two entries across elements.
760
761 Teuchos::rcp_dynamic_cast<const Thyra::SpmdVectorBase<double>>(f_vec)->getLocalData(Teuchos::ptrFromRef(data));
762 for (size_type i = 0; i < data.size(); i++)
763 {
764 double target = 123.0 + myRank;
765 TEST_ASSERT(data[i] == target || data[i] == 2.0 * target);
766 }
767 }
768 for (std::size_t i=0; i<numParams; ++i)
769 {
770 // now check the tangent values
771 Teuchos::ArrayRCP<const double> data;
772 Teuchos::RCP<const Thyra::VectorBase<double>> f_vec = Teuchos::rcp_dynamic_cast<TpetraLinObjContainerType>(paramContainers[i]->getGhostedLOC())->get_f_th();
773 Teuchos::rcp_dynamic_cast<const Thyra::SpmdVectorBase<double>>(f_vec)->getLocalData(Teuchos::ptrFromRef(data));
774
775 for (size_type j = 0; j < data.size(); ++j)
776 {
777 const double target = .123 + myRank + i;
778 TEST_ASSERT(data[j] == target || data[j] == 2.0 * target);
779 }
780 }
781 }
782
783 Teuchos::RCP<panzer::PureBasis> buildBasis(std::size_t worksetSize, const std::string &basisName)
784 {
785 Teuchos::RCP<shards::CellTopology> topo =
786 Teuchos::rcp(new shards::CellTopology(shards::getCellTopologyData<shards::Quadrilateral<4>>()));
787
788 panzer::CellData cellData(worksetSize, topo);
789 return Teuchos::rcp(new panzer::PureBasis(basisName, 1, cellData));
790 }
791
792 Teuchos::RCP<panzer_stk::STK_Interface> buildMesh(int elemX, int elemY)
793 {
794 RCP<Teuchos::ParameterList> pl = rcp(new Teuchos::ParameterList);
795 pl->set("X Blocks", 1);
796 pl->set("Y Blocks", 1);
797 pl->set("X Elements", elemX);
798 pl->set("Y Elements", elemY);
799
800 panzer_stk::SquareQuadMeshFactory factory;
801 factory.setParameterList(pl);
802 RCP<panzer_stk::STK_Interface> mesh = factory.buildUncommitedMesh(MPI_COMM_WORLD);
803 factory.completeMeshConstruction(*mesh, MPI_COMM_WORLD);
804
805 return mesh;
806 }
807
808 void testInitialization(const Teuchos::RCP<Teuchos::ParameterList> &ipb)
809 {
810 // Physics block
811 ipb->setName("test physics");
812 {
813 Teuchos::ParameterList &p = ipb->sublist("a");
814 p.set("Type", "Energy");
815 p.set("Prefix", "");
816 p.set("Model ID", "solid");
817 p.set("Basis Type", "HGrad");
818 p.set("Basis Order", 1);
819 p.set("Integration Order", 1);
820 }
821 {
822 Teuchos::ParameterList &p = ipb->sublist("b");
823 p.set("Type", "Energy");
824 p.set("Prefix", "ION_");
825 p.set("Model ID", "solid");
826 p.set("Basis Type", "HCurl");
827 p.set("Basis Order", 1);
828 p.set("Integration Order", 1);
829 }
830 }
831
832 }