Debian Codegraph @

packages/panzer/adapters-stk/test/evaluator_tests/tpetra_blocked_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_BlockedDOFManager.hpp"
24 #include "Panzer_BlockedTpetraLinearObjFactory.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_BlockedTpetra.hpp"
30 #include "Panzer_GatherSolution_BlockedTpetra.hpp"
31 #include "Panzer_LOCPair_GlobalEvaluationData.hpp"
32 #include "Panzer_GlobalEvaluationDataContainer.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_ProductVectorBase.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 TpetraBlockedLinObjFactoryType = panzer::BlockedTpetraLinearObjFactory<panzer::Traits, double, panzer::LocalOrdinal, panzer::GlobalOrdinal>;
62 using TpetraBlockedLinObjContainerType = panzer::BlockedTpetraLinearObjContainer<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(block_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::BlockedDOFManager> dofManager = Teuchos::rcp(new panzer::BlockedDOFManager(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::vector<std::string>> fieldOrder(3);
114 fieldOrder[0].push_back(fieldName1_q1);
115 fieldOrder[1].push_back(fieldName_qedge1);
116 fieldOrder[2].push_back(fieldName2_q1);
117 dofManager->setFieldOrder(fieldOrder);
118
119 // dofManager->setOrientationsRequired(true);
120 dofManager->buildGlobalUnknowns();
121
122 // setup linear object factory
123 /////////////////////////////////////////////////////////////
124 Teuchos::RCP<TpetraBlockedLinObjFactoryType> bt_lof = Teuchos::rcp(new TpetraBlockedLinObjFactoryType(tComm.getConst(), dofManager));
125 Teuchos::RCP<LinearObjFactory<panzer::Traits>> lof = bt_lof;
126 Teuchos::RCP<LinearObjContainer> loc = bt_lof->buildGhostedLinearObjContainer();
127 bt_lof->initializeGhostedContainer(LinearObjContainer::X | LinearObjContainer::F, *loc);
128 loc->initialize();
129
130 Teuchos::RCP<TpetraBlockedLinObjContainerType> b_loc = Teuchos::rcp_dynamic_cast<TpetraBlockedLinObjContainerType>(loc);
131
132 Teuchos::RCP<Thyra::ProductVectorBase<double>> p_vec = Teuchos::rcp_dynamic_cast<Thyra::ProductVectorBase<double>>(b_loc->get_x());
133 Thyra::assign(p_vec->getNonconstVectorBlock(0).ptr(), 123.0 + myRank);
134 Thyra::assign(p_vec->getNonconstVectorBlock(1).ptr(), 456.0 + myRank);
135 Thyra::assign(p_vec->getNonconstVectorBlock(2).ptr(), 789.0 + myRank);
136
137 // setup field manager, add evaluator under test
138 /////////////////////////////////////////////////////////////
139
140 PHX::FieldManager<panzer::Traits> fm;
141
142 std::string resName = "";
143 Teuchos::RCP<std::map<std::string, std::string>> names_map =
144 Teuchos::rcp(new std::map<std::string, std::string>);
145 names_map->insert(std::make_pair(fieldName1_q1, resName + fieldName1_q1));
146 names_map->insert(std::make_pair(fieldName2_q1, resName + fieldName2_q1));
147 names_map->insert(std::make_pair(fieldName_qedge1, resName + fieldName_qedge1));
148
149 // evaluators under test
150 {
151 using Teuchos::RCP;
152 using Teuchos::rcp;
153 RCP<std::vector<std::string>> names = rcp(new std::vector<std::string>);
154 names->push_back(resName + fieldName1_q1);
155 names->push_back(resName + fieldName2_q1);
156
157 Teuchos::ParameterList pl;
158 pl.set("Scatter Name", "ScatterQ1");
159 pl.set("Basis", basis_q1.getConst());
160 pl.set("Dependent Names", names);
161 pl.set("Dependent Map", names_map);
162
163 Teuchos::RCP<PHX::Evaluator<panzer::Traits>> evaluator = lof->buildScatter<panzer::Traits::Residual>(pl);
164
165 TEST_EQUALITY(evaluator->evaluatedFields().size(), 1);
166
167 fm.registerEvaluator<panzer::Traits::Residual>(evaluator);
168 fm.requireField<panzer::Traits::Residual>(*evaluator->evaluatedFields()[0]);
169 }
170 {
171 using Teuchos::RCP;
172 using Teuchos::rcp;
173 RCP<std::vector<std::string>> names = rcp(new std::vector<std::string>);
174 names->push_back(resName + fieldName_qedge1);
175
176 Teuchos::ParameterList pl;
177 pl.set("Scatter Name", "ScatterQEdge1");
178 pl.set("Basis", basis_qedge1.getConst());
179 pl.set("Dependent Names", names);
180 pl.set("Dependent Map", names_map);
181
182 Teuchos::RCP<PHX::Evaluator<panzer::Traits>> evaluator = lof->buildScatter<panzer::Traits::Residual>(pl);
183
184 TEST_EQUALITY(evaluator->evaluatedFields().size(), 1);
185
186 fm.registerEvaluator<panzer::Traits::Residual>(evaluator);
187 fm.requireField<panzer::Traits::Residual>(*evaluator->evaluatedFields()[0]);
188 }
189
190 // support evaluators
191 {
192 using Teuchos::RCP;
193 using Teuchos::rcp;
194 RCP<std::vector<std::string>> names = rcp(new std::vector<std::string>);
195 names->push_back(fieldName1_q1);
196 names->push_back(fieldName2_q1);
197
198 Teuchos::ParameterList pl;
199 pl.set("Basis", basis_q1);
200 pl.set("DOF Names", names);
201 pl.set("Indexer Names", names);
202
203 Teuchos::RCP<PHX::Evaluator<panzer::Traits>> evaluator = lof->buildGather<panzer::Traits::Residual>(pl);
204
205 fm.registerEvaluator<panzer::Traits::Residual>(evaluator);
206 }
207 {
208 using Teuchos::RCP;
209 using Teuchos::rcp;
210 RCP<std::vector<std::string>> names = rcp(new std::vector<std::string>);
211 names->push_back(fieldName_qedge1);
212
213 Teuchos::ParameterList pl;
214 pl.set("Basis", basis_qedge1);
215 pl.set("DOF Names", names);
216 pl.set("Indexer Names", names);
217
218 Teuchos::RCP<PHX::Evaluator<panzer::Traits>> evaluator = lof->buildGather<panzer::Traits::Residual>(pl);
219
220 fm.registerEvaluator<panzer::Traits::Residual>(evaluator);
221 }
222
223 std::vector<PHX::index_size_type> derivative_dimensions;
224 derivative_dimensions.push_back(12);
225 fm.setKokkosExtendedDataTypeDimensions<panzer::Traits::Jacobian>(derivative_dimensions);
226
227 panzer::Traits::SD sd;
228 sd.worksets_ = work_sets;
229
230 fm.postRegistrationSetup(sd);
231
232 panzer::Traits::PED ped;
233 ped.gedc->addDataObject("Solution Gather Container", loc);
234 ped.gedc->addDataObject("Residual Scatter Container", loc);
235 fm.preEvaluate<panzer::Traits::Residual>(ped);
236
237 // run tests
238 /////////////////////////////////////////////////////////////
239
240 panzer::Workset &workset = (*work_sets)[0];
241 workset.alpha = 0.0;
242 workset.beta = 2.0; // derivatives multiplied by 2
243 workset.time = 0.0;
244 workset.evaluate_transient_terms = false;
245
246 fm.evaluateFields<panzer::Traits::Residual>(workset);
247
248 // test Residual fields
249 Teuchos::ArrayRCP<const double> data;
250 Teuchos::RCP<const Thyra::ProductVectorBase<double>> f_vec = Teuchos::rcp_dynamic_cast<Thyra::ProductVectorBase<double>>(b_loc->get_f());
251
252 // check all the residual values. This is kind of crappy test since it simply checks twice the target
253 // value and the target. Its this way because you add two entries across elements.
254
255 Teuchos::rcp_dynamic_cast<const Thyra::SpmdVectorBase<double>>(f_vec->getVectorBlock(0))->getLocalData(Teuchos::ptrFromRef(data));
256 TEST_EQUALITY(static_cast<size_t>(data.size()), b_loc->getMapForBlock(0)->getLocalNumElements());
257 for (size_type i = 0; i < data.size(); i++)
258 {
259 double target = 123.0 + myRank;
260 TEST_ASSERT(data[i] == target || data[i] == 2.0 * target);
261 }
262
263 Teuchos::rcp_dynamic_cast<const Thyra::SpmdVectorBase<double>>(f_vec->getVectorBlock(1))->getLocalData(Teuchos::ptrFromRef(data));
264 TEST_EQUALITY(static_cast<size_t>(data.size()), b_loc->getMapForBlock(1)->getLocalNumElements());
265 for (size_type i = 0; i < data.size(); i++)
266 {
267 double target = 456.0 + myRank;
268 TEST_ASSERT(data[i] == target || data[i] == 2.0 * target);
269 }
270
271 Teuchos::rcp_dynamic_cast<const Thyra::SpmdVectorBase<double>>(f_vec->getVectorBlock(2))->getLocalData(Teuchos::ptrFromRef(data));
272 TEST_EQUALITY(static_cast<size_t>(data.size()), b_loc->getMapForBlock(2)->getLocalNumElements());
273 for (size_type i = 0; i < data.size(); i++)
274 {
275 double target = 789.0 + myRank;
276 TEST_ASSERT(data[i] == target || data[i] == 2.0 * target);
277 }
278 }
279
280 TEUCHOS_UNIT_TEST(block_assembly, scatter_solution_jacobian)
281 {
282
283 #ifdef HAVE_MPI
284 Teuchos::RCP<Teuchos::MpiComm<int>> tComm = Teuchos::rcp(new Teuchos::MpiComm<int>(MPI_COMM_WORLD));
285 #else
286 NOPE_PANZER_DOESNT_SUPPORT_SERIAL
287 #endif
288
289 int myRank = tComm->getRank();
290
291 const std::size_t workset_size = 4;
292 const std::string fieldName1_q1 = "U";
293 const std::string fieldName2_q1 = "V";
294 const std::string fieldName_qedge1 = "B";
295
296 Teuchos::RCP<panzer_stk::STK_Interface> mesh = buildMesh(2, 2);
297
298 // build input physics block
299 Teuchos::RCP<panzer::PureBasis> basis_q1 = buildBasis(workset_size, "Q1");
300 Teuchos::RCP<panzer::PureBasis> basis_qedge1 = buildBasis(workset_size, "QEdge1");
301
302 Teuchos::RCP<Teuchos::ParameterList> ipb = Teuchos::parameterList();
303 testInitialization(ipb);
304
305 const int default_int_order = 1;
306 std::string eBlockID = "eblock-0_0";
307 Teuchos::RCP<user_app::MyFactory> eqset_factory = Teuchos::rcp(new user_app::MyFactory);
308 panzer::CellData cellData(workset_size, mesh->getCellTopology("eblock-0_0"));
309 Teuchos::RCP<panzer::GlobalData> gd = panzer::createGlobalData();
310 Teuchos::RCP<panzer::PhysicsBlock> physicsBlock =
311 Teuchos::rcp(new PhysicsBlock(ipb, eBlockID, default_int_order, cellData, eqset_factory, gd, false));
312
313 Teuchos::RCP<std::vector<panzer::Workset>> work_sets = panzer_stk::buildWorksets(*mesh, physicsBlock->elementBlockID(),
314 physicsBlock->getWorksetNeeds());
315 TEST_EQUALITY(work_sets->size(), 1);
316
317 // build connection manager and field manager
318 const Teuchos::RCP<panzer::ConnManager> conn_manager = Teuchos::rcp(new panzer_stk::STKConnManager(mesh));
319 RCP<panzer::BlockedDOFManager> dofManager = Teuchos::rcp(new panzer::BlockedDOFManager(conn_manager, MPI_COMM_WORLD));
320
321 dofManager->addField(fieldName1_q1, Teuchos::rcp(new panzer::Intrepid2FieldPattern(basis_q1->getIntrepid2Basis())));
322 dofManager->addField(fieldName2_q1, Teuchos::rcp(new panzer::Intrepid2FieldPattern(basis_q1->getIntrepid2Basis())));
323 dofManager->addField(fieldName_qedge1, Teuchos::rcp(new panzer::Intrepid2FieldPattern(basis_qedge1->getIntrepid2Basis())));
324
325 std::vector<std::vector<std::string>> fieldOrder(3);
326 fieldOrder[0].push_back(fieldName1_q1);
327 fieldOrder[1].push_back(fieldName_qedge1);
328 fieldOrder[2].push_back(fieldName2_q1);
329 dofManager->setFieldOrder(fieldOrder);
330
331 // dofManager->setOrientationsRequired(true);
332 dofManager->buildGlobalUnknowns();
333
334 // setup linear object factory
335 /////////////////////////////////////////////////////////////
336
337 Teuchos::RCP<TpetraBlockedLinObjFactoryType> bt_lof = Teuchos::rcp(new TpetraBlockedLinObjFactoryType(tComm.getConst(), dofManager));
338 Teuchos::RCP<LinearObjFactory<panzer::Traits>> lof = bt_lof;
339 Teuchos::RCP<LinearObjContainer> loc = bt_lof->buildGhostedLinearObjContainer();
340 bt_lof->initializeGhostedContainer(LinearObjContainer::X | LinearObjContainer::F | LinearObjContainer::Mat, *loc);
341 loc->initialize();
342
343 Teuchos::RCP<TpetraBlockedLinObjContainerType> b_loc = Teuchos::rcp_dynamic_cast<TpetraBlockedLinObjContainerType>(loc);
344
345 Teuchos::RCP<Thyra::ProductVectorBase<double>> p_vec = Teuchos::rcp_dynamic_cast<Thyra::ProductVectorBase<double>>(b_loc->get_x());
346 Thyra::assign(p_vec->getNonconstVectorBlock(0).ptr(), 123.0 + myRank);
347 Thyra::assign(p_vec->getNonconstVectorBlock(1).ptr(), 456.0 + myRank);
348 Thyra::assign(p_vec->getNonconstVectorBlock(2).ptr(), 789.0 + myRank);
349
350 // setup field manager, add evaluator under test
351 /////////////////////////////////////////////////////////////
352
353 PHX::FieldManager<panzer::Traits> fm;
354
355 std::string resName = "";
356 Teuchos::RCP<std::map<std::string, std::string>> names_map =
357 Teuchos::rcp(new std::map<std::string, std::string>);
358 names_map->insert(std::make_pair(fieldName1_q1, resName + fieldName1_q1));
359 names_map->insert(std::make_pair(fieldName2_q1, resName + fieldName2_q1));
360 names_map->insert(std::make_pair(fieldName_qedge1, resName + fieldName_qedge1));
361
362 // evaluators under test
363 {
364 using Teuchos::RCP;
365 using Teuchos::rcp;
366 RCP<std::vector<std::string>> names = rcp(new std::vector<std::string>);
367 names->push_back(resName + fieldName1_q1);
368 names->push_back(resName + fieldName2_q1);
369
370 Teuchos::ParameterList pl;
371 pl.set("Scatter Name", "ScatterQ1");
372 pl.set("Basis", basis_q1.getConst());
373 pl.set("Dependent Names", names);
374 pl.set("Dependent Map", names_map);
375
376 Teuchos::RCP<PHX::Evaluator<panzer::Traits>> evaluator = lof->buildScatter<panzer::Traits::Jacobian>(pl);
377
378 TEST_EQUALITY(evaluator->evaluatedFields().size(), 1);
379
380 fm.registerEvaluator<panzer::Traits::Jacobian>(evaluator);
381 fm.requireField<panzer::Traits::Jacobian>(*evaluator->evaluatedFields()[0]);
382 }
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(resName + fieldName_qedge1);
388
389 Teuchos::ParameterList pl;
390 pl.set("Scatter Name", "ScatterQEdge1");
391 pl.set("Basis", basis_qedge1.getConst());
392 pl.set("Dependent Names", names);
393 pl.set("Dependent Map", names_map);
394
395 Teuchos::RCP<PHX::Evaluator<panzer::Traits>> evaluator = lof->buildScatter<panzer::Traits::Jacobian>(pl);
396
397 TEST_EQUALITY(evaluator->evaluatedFields().size(), 1);
398
399 fm.registerEvaluator<panzer::Traits::Jacobian>(evaluator);
400 fm.requireField<panzer::Traits::Jacobian>(*evaluator->evaluatedFields()[0]);
401 }
402
403 // support evaluators
404 {
405 using Teuchos::RCP;
406 using Teuchos::rcp;
407 RCP<std::vector<std::string>> names = rcp(new std::vector<std::string>);
408 names->push_back(fieldName1_q1);
409 names->push_back(fieldName2_q1);
410
411 Teuchos::ParameterList pl;
412 pl.set("Basis", basis_q1);
413 pl.set("DOF Names", names);
414 pl.set("Indexer Names", names);
415
416 Teuchos::RCP<PHX::Evaluator<panzer::Traits>> evaluator = lof->buildGather<panzer::Traits::Jacobian>(pl);
417
418 fm.registerEvaluator<panzer::Traits::Jacobian>(evaluator);
419 }
420 {
421 using Teuchos::RCP;
422 using Teuchos::rcp;
423 RCP<std::vector<std::string>> names = rcp(new std::vector<std::string>);
424 names->push_back(fieldName_qedge1);
425
426 Teuchos::ParameterList pl;
427 pl.set("Basis", basis_qedge1);
428 pl.set("DOF Names", names);
429 pl.set("Indexer Names", names);
430
431 Teuchos::RCP<PHX::Evaluator<panzer::Traits>> evaluator = lof->buildGather<panzer::Traits::Jacobian>(pl);
432
433 fm.registerEvaluator<panzer::Traits::Jacobian>(evaluator);
434 }
435
436 std::vector<PHX::index_size_type> derivative_dimensions;
437 derivative_dimensions.push_back(12);
438 fm.setKokkosExtendedDataTypeDimensions<panzer::Traits::Jacobian>(derivative_dimensions);
439
440 panzer::Traits::SD sd;
441 sd.worksets_ = work_sets;
442
443 fm.postRegistrationSetup(sd);
444
445 panzer::Traits::PED ped;
446 ped.gedc->addDataObject("Solution Gather Container", loc);
447 ped.gedc->addDataObject("Residual Scatter Container", loc);
448 fm.preEvaluate<panzer::Traits::Jacobian>(ped);
449
450 // run tests
451 /////////////////////////////////////////////////////////////
452
453 panzer::Workset &workset = (*work_sets)[0];
454 workset.alpha = 0.0;
455 workset.beta = 2.0; // derivatives multiplied by 2
456 workset.time = 0.0;
457 workset.evaluate_transient_terms = false;
458
459 fm.evaluateFields<panzer::Traits::Jacobian>(workset);
460
461 // test Jacobian fields
462 Teuchos::ArrayRCP<const double> data;
463 Teuchos::RCP<const Thyra::ProductVectorBase<double>> f_vec = Teuchos::rcp_dynamic_cast<Thyra::ProductVectorBase<double>>(b_loc->get_f());
464
465 // check all the residual values. This is kind of crappy test since it simply checks twice the target
466 // value and the target. Its this way because you add two entries across elements.
467
468 Teuchos::rcp_dynamic_cast<const Thyra::SpmdVectorBase<double>>(f_vec->getVectorBlock(0))->getLocalData(Teuchos::ptrFromRef(data));
469 TEST_EQUALITY(static_cast<size_t>(data.size()), b_loc->getMapForBlock(0)->getLocalNumElements());
470 out << std::endl;
471 for (size_type i = 0; i < data.size(); i++)
472 {
473 double target = 123.0 + myRank;
474 TEST_ASSERT(data[i] == target || data[i] == 2.0 * target);
475 out << data[i] << std::endl;
476 }
477
478 Teuchos::rcp_dynamic_cast<const Thyra::SpmdVectorBase<double>>(f_vec->getVectorBlock(1))->getLocalData(Teuchos::ptrFromRef(data));
479 TEST_EQUALITY(static_cast<size_t>(data.size()), b_loc->getMapForBlock(1)->getLocalNumElements());
480 out << std::endl;
481 for (size_type i = 0; i < data.size(); i++)
482 {
483 double target = 456.0 + myRank;
484 TEST_ASSERT(data[i] == target || data[i] == 2.0 * target);
485 out << data[i] << std::endl;
486 }
487
488 Teuchos::rcp_dynamic_cast<const Thyra::SpmdVectorBase<double>>(f_vec->getVectorBlock(2))->getLocalData(Teuchos::ptrFromRef(data));
489 TEST_EQUALITY(static_cast<size_t>(data.size()), b_loc->getMapForBlock(2)->getLocalNumElements());
490 out << std::endl;
491 for (size_type i = 0; i < data.size(); i++)
492 {
493 double target = 789.0 + myRank;
494 TEST_ASSERT(data[i] == target || data[i] == 2.0 * target);
495 out << data[i] << std::endl;
496 }
497 }
498
499 TEUCHOS_UNIT_TEST(block_assembly, scatter_solution_tangent)
500 {
501
502 #ifdef HAVE_MPI
503 Teuchos::RCP<Teuchos::MpiComm<int>> tComm = Teuchos::rcp(new Teuchos::MpiComm<int>(MPI_COMM_WORLD));
504 #else
505 NOPE_PANZER_DOESNT_SUPPORT_SERIAL
506 #endif
507
508 int myRank = tComm->getRank();
509
510 const std::size_t workset_size = 4;
511 const std::string fieldName1_q1 = "U";
512 const std::string fieldName2_q1 = "V";
513 const std::string fieldName_qedge1 = "B";
514 const std::size_t numParams = 2;
515
516 Teuchos::RCP<panzer_stk::STK_Interface> mesh = buildMesh(2, 2);
517
518 // build input physics block
519 Teuchos::RCP<panzer::PureBasis> basis_q1 = buildBasis(workset_size, "Q1");
520 Teuchos::RCP<panzer::PureBasis> basis_qedge1 = buildBasis(workset_size, "QEdge1");
521
522 Teuchos::RCP<Teuchos::ParameterList> ipb = Teuchos::parameterList();
523 testInitialization(ipb);
524
525 const int default_int_order = 1;
526 std::string eBlockID = "eblock-0_0";
527 Teuchos::RCP<user_app::MyFactory> eqset_factory = Teuchos::rcp(new user_app::MyFactory);
528 panzer::CellData cellData(workset_size, mesh->getCellTopology("eblock-0_0"));
529 Teuchos::RCP<panzer::GlobalData> gd = panzer::createGlobalData();
530 Teuchos::RCP<panzer::PhysicsBlock> physicsBlock =
531 Teuchos::rcp(new PhysicsBlock(ipb, eBlockID, default_int_order, cellData, eqset_factory, gd, false));
532
533 Teuchos::RCP<std::vector<panzer::Workset>> work_sets = panzer_stk::buildWorksets(*mesh, physicsBlock->elementBlockID(),
534 physicsBlock->getWorksetNeeds());
535 TEST_EQUALITY(work_sets->size(), 1);
536
537 // build connection manager and field manager
538 const Teuchos::RCP<panzer::ConnManager> conn_manager = Teuchos::rcp(new panzer_stk::STKConnManager(mesh));
539 RCP<panzer::BlockedDOFManager> dofManager = Teuchos::rcp(new panzer::BlockedDOFManager(conn_manager, MPI_COMM_WORLD));
540
541 dofManager->addField(fieldName1_q1, Teuchos::rcp(new panzer::Intrepid2FieldPattern(basis_q1->getIntrepid2Basis())));
542 dofManager->addField(fieldName2_q1, Teuchos::rcp(new panzer::Intrepid2FieldPattern(basis_q1->getIntrepid2Basis())));
543 dofManager->addField(fieldName_qedge1, Teuchos::rcp(new panzer::Intrepid2FieldPattern(basis_qedge1->getIntrepid2Basis())));
544
545 std::vector<std::vector<std::string>> fieldOrder(3);
546 fieldOrder[0].push_back(fieldName1_q1);
547 fieldOrder[1].push_back(fieldName_qedge1);
548 fieldOrder[2].push_back(fieldName2_q1);
549 dofManager->setFieldOrder(fieldOrder);
550
551 // dofManager->setOrientationsRequired(true);
552 dofManager->buildGlobalUnknowns();
553
554 // setup linear object factory
555 /////////////////////////////////////////////////////////////
556 Teuchos::RCP<TpetraBlockedLinObjFactoryType> bt_lof = Teuchos::rcp(new TpetraBlockedLinObjFactoryType(tComm.getConst(), dofManager));
557 Teuchos::RCP<LinearObjFactory<panzer::Traits>> lof = bt_lof;
558 Teuchos::RCP<LinearObjContainer> loc = bt_lof->buildGhostedLinearObjContainer();
559 bt_lof->initializeGhostedContainer(LinearObjContainer::X | LinearObjContainer::F, *loc);
560 loc->initialize();
561
562 Teuchos::RCP<TpetraBlockedLinObjContainerType> b_loc = Teuchos::rcp_dynamic_cast<TpetraBlockedLinObjContainerType>(loc);
563
564 Teuchos::RCP<Thyra::ProductVectorBase<double>> p_vec = Teuchos::rcp_dynamic_cast<Thyra::ProductVectorBase<double>>(b_loc->get_x());
565 Thyra::assign(p_vec->getNonconstVectorBlock(0).ptr(), 123.0 + myRank);
566 Thyra::assign(p_vec->getNonconstVectorBlock(1).ptr(), 456.0 + myRank);
567 Thyra::assign(p_vec->getNonconstVectorBlock(2).ptr(), 789.0 + myRank);
568
569 std::vector<Teuchos::RCP<GlobalEvaluationData>> tangentContainers;
570
571 using LOCPair = panzer::LOCPair_GlobalEvaluationData;
572 using Teuchos::rcp_dynamic_cast;
573
574 // generate tangent data
575 for (std::size_t i=0;i<numParams; ++i){
576 auto locPair = Teuchos::rcp(new LOCPair(bt_lof, panzer::LinearObjContainer::X));
577
578 auto global_bt_loc = rcp_dynamic_cast<TpetraBlockedLinObjContainerType>(locPair->getGlobalLOC());
579 Teuchos::RCP<Thyra::ProductVectorBase<double>> global_p_vec = Teuchos::rcp_dynamic_cast<Thyra::ProductVectorBase<double>>(global_bt_loc->get_x());
580 Thyra::assign(global_p_vec->getNonconstVectorBlock(0).ptr(), 0.123 + myRank + i);
581 Thyra::assign(global_p_vec->getNonconstVectorBlock(1).ptr(), 0.456 + myRank + i);
582 Thyra::assign(global_p_vec->getNonconstVectorBlock(2).ptr(), 0.789 + myRank + i);
583
584 auto ghosted_bt_loc = rcp_dynamic_cast<TpetraBlockedLinObjContainerType>(locPair->getGhostedLOC());
585 Teuchos::RCP<Thyra::ProductVectorBase<double>> ghosted_p_vec = Teuchos::rcp_dynamic_cast<Thyra::ProductVectorBase<double>>(ghosted_bt_loc->get_x());
586 Thyra::assign(ghosted_p_vec->getNonconstVectorBlock(0).ptr(), 0.123 + myRank + i);
587 Thyra::assign(ghosted_p_vec->getNonconstVectorBlock(1).ptr(), 0.456 + myRank + i);
588 Thyra::assign(ghosted_p_vec->getNonconstVectorBlock(2).ptr(), 0.789 + myRank + i);
589
590 tangentContainers.push_back(locPair);
591 }
592
593 // setup field manager, add evaluator under test
594 /////////////////////////////////////////////////////////////
595
596 auto fm = Teuchos::rcp(new PHX::FieldManager<panzer::Traits>);
597
598 std::vector<PHX::index_size_type> derivative_dimensions;
599 derivative_dimensions.push_back(numParams);
600 fm->setKokkosExtendedDataTypeDimensions<panzer::Traits::Tangent>(derivative_dimensions);
601
602 std::string resName = "";
603 Teuchos::RCP<std::map<std::string, std::string>> names_map =
604 Teuchos::rcp(new std::map<std::string, std::string>);
605 names_map->insert(std::make_pair(fieldName1_q1, resName + fieldName1_q1));
606 names_map->insert(std::make_pair(fieldName2_q1, resName + fieldName2_q1));
607 names_map->insert(std::make_pair(fieldName_qedge1, resName + fieldName_qedge1));
608
609 // evaluators under test
610 {
611 using Teuchos::RCP;
612 using Teuchos::rcp;
613 RCP<std::vector<std::string>> names = rcp(new std::vector<std::string>);
614 names->push_back(resName + fieldName1_q1);
615 names->push_back(resName + fieldName2_q1);
616
617 Teuchos::ParameterList pl;
618 pl.set("Scatter Name", "ScatterQ1");
619 pl.set("Basis", basis_q1.getConst());
620 pl.set("Dependent Names", names);
621 pl.set("Dependent Map", names_map);
622
623 Teuchos::RCP<PHX::Evaluator<panzer::Traits>> evaluator = lof->buildScatter<panzer::Traits::Tangent>(pl);
624
625 TEST_EQUALITY(evaluator->evaluatedFields().size(), 1);
626
627 fm->registerEvaluator<panzer::Traits::Tangent>(evaluator);
628 fm->requireField<panzer::Traits::Tangent>(*evaluator->evaluatedFields()[0]);
629 }
630 {
631 using Teuchos::RCP;
632 using Teuchos::rcp;
633 RCP<std::vector<std::string>> names = rcp(new std::vector<std::string>);
634 names->push_back(resName + fieldName_qedge1);
635
636 Teuchos::ParameterList pl;
637 pl.set("Scatter Name", "ScatterQEdge1");
638 pl.set("Basis", basis_qedge1.getConst());
639 pl.set("Dependent Names", names);
640 pl.set("Dependent Map", names_map);
641
642 Teuchos::RCP<PHX::Evaluator<panzer::Traits>> evaluator = lof->buildScatter<panzer::Traits::Tangent>(pl);
643
644 TEST_EQUALITY(evaluator->evaluatedFields().size(), 1);
645
646 fm->registerEvaluator<panzer::Traits::Tangent>(evaluator);
647 fm->requireField<panzer::Traits::Tangent>(*evaluator->evaluatedFields()[0]);
648 }
649
650 // support evaluators
651 {
652 using Teuchos::RCP;
653 using Teuchos::rcp;
654 RCP<std::vector<std::string>> names = rcp(new std::vector<std::string>);
655 names->push_back(fieldName1_q1);
656 names->push_back(fieldName2_q1);
657
658 Teuchos::ParameterList pl;
659 pl.set("Basis", basis_q1);
660 pl.set("DOF Names", names);
661 pl.set("Indexer Names", names);
662 Teuchos::RCP<std::vector<std::vector<std::string>>> tangent_names =
663 Teuchos::rcp(new std::vector<std::vector<std::string>>(2));
664 for (std::size_t i = 0; i < numParams; ++i)
665 {
666 std::stringstream ss1, ss2;
667 ss1 << fieldName1_q1 << " Tangent " << i;
668 ss2 << fieldName2_q1 << " Tangent " << i;
669 (*tangent_names)[0].push_back(ss1.str());
670 (*tangent_names)[1].push_back(ss2.str());
671 }
672 pl.set("Tangent Names", tangent_names);
673
674 Teuchos::RCP<PHX::Evaluator<panzer::Traits>> evaluator = lof->buildGather<panzer::Traits::Tangent>(pl);
675
676 fm->registerEvaluator<panzer::Traits::Tangent>(evaluator);
677 }
678 for (std::size_t i = 0; i < numParams; ++i) {
679 using Teuchos::RCP;
680 using Teuchos::rcp;
681 RCP<std::vector<std::string>> names = rcp(new std::vector<std::string>);
682 RCP<std::vector<std::string>> tangent_names = rcp(new std::vector<std::string>);
683 names->push_back(fieldName1_q1);
684 names->push_back(fieldName2_q1);
685 {
686 std::stringstream ss1, ss2;
687 ss1 << fieldName1_q1 << " Tangent " << i;
688 ss2 << fieldName2_q1 << " Tangent " << i;
689 tangent_names->push_back(ss1.str());
690 tangent_names->push_back(ss2.str());
691 }
692
693 Teuchos::ParameterList pl;
694 pl.set("Basis", basis_q1);
695 pl.set("DOF Names", tangent_names);
696 pl.set("Indexer Names", names);
697
698 std::stringstream ss;
699 ss << "Tangent Container " << i;
700 pl.set("Global Data Key", ss.str());
701
702 Teuchos::RCP<PHX::Evaluator<panzer::Traits>> evaluator =
703 lof->buildGatherTangent<panzer::Traits::Tangent>(pl);
704
705 fm->registerEvaluator<panzer::Traits::Tangent>(evaluator);
706 }
707 {
708 using Teuchos::RCP;
709 using Teuchos::rcp;
710 RCP<std::vector<std::string>> names = rcp(new std::vector<std::string>);
711 names->push_back(fieldName_qedge1);
712
713 Teuchos::ParameterList pl;
714 pl.set("Basis", basis_qedge1);
715 pl.set("DOF Names", names);
716 pl.set("Indexer Names", names);
717 Teuchos::RCP<std::vector<std::vector<std::string>>> tangent_names =
718 Teuchos::rcp(new std::vector<std::vector<std::string>>(1));
719 for (std::size_t i = 0; i < numParams; ++i)
720 {
721 std::stringstream ss;
722 ss << fieldName_qedge1 << " Tangent " << i;
723 (*tangent_names)[0].push_back(ss.str());
724 }
725 pl.set("Tangent Names", tangent_names);
726
727 Teuchos::RCP<PHX::Evaluator<panzer::Traits>> evaluator = lof->buildGather<panzer::Traits::Tangent>(pl);
728
729 fm->registerEvaluator<panzer::Traits::Tangent>(evaluator);
730 }
731 for (std::size_t i = 0; i < numParams; ++i) {
732 using Teuchos::RCP;
733 using Teuchos::rcp;
734 RCP<std::vector<std::string>> names = rcp(new std::vector<std::string>);
735 RCP<std::vector<std::string>> tangent_names = rcp(new std::vector<std::string>);
736 names->push_back(fieldName_qedge1);
737 {
738 std::stringstream ss;
739 ss << fieldName_qedge1 << " Tangent " << i;
740 tangent_names->push_back(ss.str());
741 }
742
743 Teuchos::ParameterList pl;
744 pl.set("Basis", basis_qedge1);
745 pl.set("DOF Names", tangent_names);
746 pl.set("Indexer Names", names);
747
748 std::stringstream ss;
749 ss << "Tangent Container " << i;
750 pl.set("Global Data Key", ss.str());
751
752 Teuchos::RCP<PHX::Evaluator<panzer::Traits>> evaluator =
753 lof->buildGatherTangent<panzer::Traits::Tangent>(pl);
754
755 fm->registerEvaluator<panzer::Traits::Tangent>(evaluator);
756 }
757
758 panzer::Traits::SD sd;
759 sd.worksets_ = work_sets;
760
761 fm->postRegistrationSetup(sd);
762
763 panzer::Traits::PED ped;
764 ped.gedc->addDataObject("Solution Gather Container", loc);
765 ped.gedc->addDataObject("Residual Scatter Container", loc);
766 for (size_t i=0; i<numParams; ++i) {
767 std::stringstream ss;
768 ss << "Tangent Container " << i;
769 ped.gedc->addDataObject(ss.str(), tangentContainers[i]);
770 }
771 std::vector<std::string> params;
772 std::vector<Teuchos::RCP<LOCPair>> paramContainers;
773 for (std::size_t i = 0; i<numParams; ++i) {
774 std::stringstream ss;
775 ss << "param" << i;
776 params.push_back(ss.str());
777 auto paramContainer = Teuchos::rcp(new LOCPair(bt_lof, panzer::LinearObjContainer::X | panzer::LinearObjContainer::F));
778 ped.gedc->addDataObject(ss.str(),paramContainer->getGhostedLOC());
779 paramContainers.push_back(paramContainer);
780 }
781 Teuchos::RCP<panzer::GlobalEvaluationData> activeParams =
782 Teuchos::rcp(new panzer::ParameterList_GlobalEvaluationData(params));
783 ped.gedc->addDataObject("PARAMETER_NAMES",activeParams);
784 fm->preEvaluate<panzer::Traits::Tangent>(ped);
785
786 // run tests
787 /////////////////////////////////////////////////////////////
788
789 panzer::Workset &workset = (*work_sets)[0];
790 workset.alpha = 0.0;
791 workset.beta = 2.0; // derivatives multiplied by 2
792 workset.time = 0.0;
793 workset.evaluate_transient_terms = false;
794
795 fm->evaluateFields<panzer::Traits::Tangent>(workset);
796 fm->postEvaluate<panzer::Traits::Tangent>(0);
797
798 fm = Teuchos::null;
799
800 // test Tangent fields
801 Teuchos::ArrayRCP<const double> data;
802 Teuchos::RCP<const Thyra::ProductVectorBase<double>> f_vec = Teuchos::rcp_dynamic_cast<Thyra::ProductVectorBase<double>>(b_loc->get_f());
803
804 // check all the residual values. This is kind of crappy test since it simply checks twice the target
805 // value and the target. Its this way because you add two entries across elements.
806
807 Teuchos::rcp_dynamic_cast<const Thyra::SpmdVectorBase<double>>(f_vec->getVectorBlock(0))->getLocalData(Teuchos::ptrFromRef(data));
808 TEST_EQUALITY(static_cast<size_t>(data.size()), b_loc->getMapForBlock(0)->getLocalNumElements());
809 for (size_type i = 0; i < data.size(); i++)
810 {
811 double target = 123.0 + myRank;
812 TEST_ASSERT(data[i] == target || data[i] == 2.0 * target);
813 }
814
815 Teuchos::rcp_dynamic_cast<const Thyra::SpmdVectorBase<double>>(f_vec->getVectorBlock(1))->getLocalData(Teuchos::ptrFromRef(data));
816 TEST_EQUALITY(static_cast<size_t>(data.size()), b_loc->getMapForBlock(1)->getLocalNumElements());
817 for (size_type i = 0; i < data.size(); i++)
818 {
819 double target = 456.0 + myRank;
820 TEST_ASSERT(data[i] == target || data[i] == 2.0 * target);
821 }
822
823 Teuchos::rcp_dynamic_cast<const Thyra::SpmdVectorBase<double>>(f_vec->getVectorBlock(2))->getLocalData(Teuchos::ptrFromRef(data));
824 TEST_EQUALITY(static_cast<size_t>(data.size()), b_loc->getMapForBlock(2)->getLocalNumElements());
825 for (size_type i = 0; i < data.size(); i++)
826 {
827 double target = 789.0 + myRank;
828 TEST_ASSERT(data[i] == target || data[i] == 2.0 * target);
829 }
830
831 for (std::size_t i=0; i<numParams; ++i) {
832 Teuchos::RCP<const Thyra::ProductVectorBase<double>> param_f_vec =
833 Teuchos::rcp_dynamic_cast<Thyra::ProductVectorBase<double>>(
834 Teuchos::rcp_dynamic_cast<TpetraBlockedLinObjContainerType>(paramContainers[i]->getGhostedLOC())->get_f());
835
836 Teuchos::rcp_dynamic_cast<const Thyra::SpmdVectorBase<double>>(param_f_vec->getVectorBlock(0))->getLocalData(Teuchos::ptrFromRef(data));
837 TEST_EQUALITY(static_cast<size_t>(data.size()), b_loc->getMapForBlock(0)->getLocalNumElements());
838 for (size_type j = 0; j < data.size(); j++)
839 {
840 double target = .123 + myRank + i;
841 TEST_ASSERT(data[j] == target || data[j] == 2.0 * target);
842 }
843 Teuchos::rcp_dynamic_cast<const Thyra::SpmdVectorBase<double>>(param_f_vec->getVectorBlock(1))->getLocalData(Teuchos::ptrFromRef(data));
844 TEST_EQUALITY(static_cast<size_t>(data.size()), b_loc->getMapForBlock(1)->getLocalNumElements());
845 for (size_type j = 0; j < data.size(); j++)
846 {
847 double target = .456 + myRank + i;
848 TEST_ASSERT(data[j] == target || data[j] == 2.0 * target);
849 }
850 Teuchos::rcp_dynamic_cast<const Thyra::SpmdVectorBase<double>>(param_f_vec->getVectorBlock(2))->getLocalData(Teuchos::ptrFromRef(data));
851 TEST_EQUALITY(static_cast<size_t>(data.size()), b_loc->getMapForBlock(2)->getLocalNumElements());
852 for (size_type j = 0; j < data.size(); j++)
853 {
854 double target = .789 + myRank + i;
855 TEST_ASSERT(data[j] == target || data[j] == 2.0 * target);
856 }
857 }
858 }
859
860 Teuchos::RCP<panzer::PureBasis> buildBasis(std::size_t worksetSize, const std::string &basisName)
861 {
862 Teuchos::RCP<shards::CellTopology> topo =
863 Teuchos::rcp(new shards::CellTopology(shards::getCellTopologyData<shards::Quadrilateral<4>>()));
864
865 panzer::CellData cellData(worksetSize, topo);
866 return Teuchos::rcp(new panzer::PureBasis(basisName, 1, cellData));
867 }
868
869 Teuchos::RCP<panzer_stk::STK_Interface> buildMesh(int elemX, int elemY)
870 {
871 RCP<Teuchos::ParameterList> pl = rcp(new Teuchos::ParameterList);
872 pl->set("X Blocks", 1);
873 pl->set("Y Blocks", 1);
874 pl->set("X Elements", elemX);
875 pl->set("Y Elements", elemY);
876
877 panzer_stk::SquareQuadMeshFactory factory;
878 factory.setParameterList(pl);
879 RCP<panzer_stk::STK_Interface> mesh = factory.buildUncommitedMesh(MPI_COMM_WORLD);
880 factory.completeMeshConstruction(*mesh, MPI_COMM_WORLD);
881
882 return mesh;
883 }
884
885 void testInitialization(const Teuchos::RCP<Teuchos::ParameterList> &ipb)
886 {
887 // Physics block
888 ipb->setName("test physics");
889 {
890 Teuchos::ParameterList &p = ipb->sublist("a");
891 p.set("Type", "Energy");
892 p.set("Prefix", "");
893 p.set("Model ID", "solid");
894 p.set("Basis Type", "HGrad");
895 p.set("Basis Order", 1);
896 p.set("Integration Order", 1);
897 }
898 {
899 Teuchos::ParameterList &p = ipb->sublist("b");
900 p.set("Type", "Energy");
901 p.set("Prefix", "ION_");
902 p.set("Model ID", "solid");
903 p.set("Basis Type", "HCurl");
904 p.set("Basis Order", 1);
905 p.set("Integration Order", 1);
906 }
907 }
908
909 }