Debian Codegraph @

packages/panzer/adapters-stk/test/evaluator_tests/tpetra_blocked_gather_solution.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 ///////////////////////////////////////////////////////////////////////////////
12 //
13 // Include Files
14 //
15 ///////////////////////////////////////////////////////////////////////////////
16
17 // C++
18 #include <cstdio>
19 #include <string>
20 #include <vector>
21
22 // Kokkos
23 #include "Kokkos_View_Fad.hpp"
24
25 // Panzer
26 #include "PanzerAdaptersSTK_config.hpp"
27 #include "Panzer_BasisIRLayout.hpp"
28 #include "Panzer_BlockedTpetraLinearObjFactory.hpp"
29 #include "Panzer_BlockedDOFManager.hpp"
30 #include "Panzer_DOFManager.hpp"
31 #include "Panzer_Evaluator_WithBaseImpl.hpp"
32 #include "Panzer_FieldManagerBuilder.hpp"
33 #include "Panzer_GatherOrientation.hpp"
34 #include "Panzer_PureBasis.hpp"
35 #include "Panzer_STKConnManager.hpp"
36 #include "Panzer_STK_Interface.hpp"
37 #include "Panzer_STK_SetupUtilities.hpp"
38 #include "Panzer_STK_SquareQuadMeshFactory.hpp"
39 #include "Panzer_STK_Version.hpp"
40 #include "Panzer_Workset.hpp"
41 #include "Panzer_LOCPair_GlobalEvaluationData.hpp"
42 #include "Panzer_GlobalEvaluationDataContainer.hpp"
43
44 // Teuchos
45 #include "Teuchos_DefaultMpiComm.hpp"
46 #include "Teuchos_GlobalMPISession.hpp"
47 #include "Teuchos_OpaqueWrapper.hpp"
48 #include "Teuchos_RCP.hpp"
49 #include "Teuchos_TimeMonitor.hpp"
50 #include "Teuchos_UnitTestHarness.hpp"
51
52 // Thyra
53 #include "Thyra_ProductVectorBase.hpp"
54 #include "Thyra_VectorStdOps.hpp"
55
56 // Tpetra
57 #include "Tpetra_Vector.hpp"
58
59 // user_app
60 #include "user_app_EquationSetFactory.hpp"
61
62 typedef double ScalarT;
63 using LocalOrdinalT = panzer::LocalOrdinal;
64 using GlobalOrdinalT = panzer::GlobalOrdinal;
65
66 typedef Tpetra::Vector<ScalarT, LocalOrdinalT, GlobalOrdinalT> VectorType;
67 typedef Tpetra::Operator<ScalarT, LocalOrdinalT, GlobalOrdinalT> OperatorType;
68 typedef Tpetra::CrsMatrix<ScalarT, LocalOrdinalT, GlobalOrdinalT> CrsMatrixType;
69 typedef Tpetra::CrsGraph<LocalOrdinalT, GlobalOrdinalT> CrsGraphType;
70 typedef Tpetra::Map<LocalOrdinalT, GlobalOrdinalT> MapType;
71 typedef Tpetra::Import<LocalOrdinalT, GlobalOrdinalT> ImportType;
72 typedef Tpetra::Export<LocalOrdinalT, GlobalOrdinalT> ExportType;
73
74 typedef Thyra::TpetraLinearOp<ScalarT, LocalOrdinalT, GlobalOrdinalT> ThyraLinearOp;
75
76 typedef panzer::BlockedTpetraLinearObjFactory<panzer::Traits, ScalarT, LocalOrdinalT, GlobalOrdinalT> BlockedTpetraLinObjFactoryType;
77 typedef panzer::TpetraLinearObjFactory<panzer::Traits, ScalarT, LocalOrdinalT, GlobalOrdinalT> TpetraLinObjFactoryType;
78 typedef panzer::BlockedTpetraLinearObjContainer<ScalarT, LocalOrdinalT, GlobalOrdinalT> BlockedTpetraLinObjContainerType;
79 typedef panzer::TpetraLinearObjContainer<ScalarT, LocalOrdinalT, GlobalOrdinalT> TpetraLinObjContainerType;
80
81 namespace panzer
82 {
83
84 Teuchos::RCP<panzer::PureBasis> buildBasis(std::size_t worksetSize, const std::string &basisName);
85 void testInitialization(const Teuchos::RCP<Teuchos::ParameterList> &ipb);
86 Teuchos::RCP<panzer_stk::STK_Interface> buildMesh(int elemX, int elemY);
87 void testGatherScatter(const bool enable_tangents, Teuchos::FancyOStream &out, bool &success);
88
89 // Test without tangent fields in gather evaluator
90 TEUCHOS_UNIT_TEST(tpetra_assembly, gather_solution_no_tangents)
91 {
92 testGatherScatter(false, out, success);
93 }
94
95 // Test with tangent fields in gather evaluator
96 TEUCHOS_UNIT_TEST(tpetra_assembly, gather_solution_tangents)
97 {
98 testGatherScatter(true, out, success);
99 }
100
101 // enable_tangents determines whether tangent fields dx/dp are added to gather evaluator.
102 // These are used when computing df/dx*dx/dp with the tangent evaluation type
103 void testGatherScatter(const bool enable_tangents, Teuchos::FancyOStream &out, bool &success)
104 {
105 #ifdef HAVE_MPI
106 Teuchos::RCP<const Teuchos::MpiComm<int>> tComm = Teuchos::rcp(new Teuchos::MpiComm<int>(MPI_COMM_WORLD));
107 #else
108 Teuchos::RCP<const Teuchos::SerialComm<int>> tComm = Teuchos::rcp(new Teuchos::SerialComm<int>(MPI_COMM_WORLD));
109 #endif
110
111 int myRank = tComm->getRank();
112 int numProcs = tComm->getSize();
113
114 const std::size_t workset_size = 4 / numProcs;
115 const std::string fieldName1_q1 = "U";
116 const std::string fieldName2_q1 = "V";
117 const std::string fieldName_qedge1 = "B";
118 const int num_tangent = enable_tangents ? 5 : 0;
119
120 Teuchos::RCP<panzer_stk::STK_Interface> mesh = buildMesh(2, 2);
121
122 // build input physics block
123 Teuchos::RCP<panzer::PureBasis> basis_q1 = buildBasis(workset_size, "Q1");
124 Teuchos::RCP<panzer::PureBasis> basis_qedge1 = buildBasis(workset_size, "QEdge1");
125
126 Teuchos::RCP<Teuchos::ParameterList> ipb = Teuchos::parameterList();
127 testInitialization(ipb);
128
129 const int default_int_order = 1;
130 std::string eBlockID = "eblock-0_0";
131 Teuchos::RCP<user_app::MyFactory> eqset_factory = Teuchos::rcp(new user_app::MyFactory);
132 panzer::CellData cellData(workset_size, mesh->getCellTopology("eblock-0_0"));
133 Teuchos::RCP<panzer::GlobalData> gd = panzer::createGlobalData();
134 Teuchos::RCP<panzer::PhysicsBlock> physicsBlock =
135 Teuchos::rcp(new PhysicsBlock(ipb, eBlockID, default_int_order, cellData, eqset_factory, gd, false));
136
137 Teuchos::RCP<std::vector<panzer::Workset>> work_sets = panzer_stk::buildWorksets(*mesh, physicsBlock->elementBlockID(),
138 physicsBlock->getWorksetNeeds());
139 TEST_EQUALITY(work_sets->size(), 1);
140
141 // build connection manager and field manager
142 const Teuchos::RCP<panzer::ConnManager> conn_manager = Teuchos::rcp(new panzer_stk::STKConnManager(mesh));
143 Teuchos::RCP<panzer::BlockedDOFManager> blocked_dofManager = Teuchos::rcp(new panzer::BlockedDOFManager(conn_manager, MPI_COMM_WORLD));
144
145 blocked_dofManager->addField(fieldName1_q1, Teuchos::rcp(new panzer::Intrepid2FieldPattern(basis_q1->getIntrepid2Basis())));
146 blocked_dofManager->addField(fieldName2_q1, Teuchos::rcp(new panzer::Intrepid2FieldPattern(basis_q1->getIntrepid2Basis())));
147 blocked_dofManager->addField(fieldName_qedge1, Teuchos::rcp(new panzer::Intrepid2FieldPattern(basis_qedge1->getIntrepid2Basis())));
148
149 std::vector<std::vector<std::string> > fieldOrder(3);
150 fieldOrder[0].push_back(fieldName1_q1);
151 fieldOrder[1].push_back(fieldName_qedge1);
152 fieldOrder[2].push_back(fieldName2_q1);
153 blocked_dofManager->setFieldOrder(fieldOrder);
154
155 blocked_dofManager->buildGlobalUnknowns();
156
157 // setup linear object factory
158 /////////////////////////////////////////////////////////////
159
160 Teuchos::RCP<BlockedTpetraLinObjFactoryType> t_lof = Teuchos::rcp(new BlockedTpetraLinObjFactoryType(tComm.getConst(), blocked_dofManager));
161 Teuchos::RCP<LinearObjFactory<panzer::Traits>> lof = t_lof;
162 Teuchos::RCP<LinearObjContainer> loc = t_lof->buildGhostedLinearObjContainer();
163 t_lof->initializeGhostedContainer(LinearObjContainer::X, *loc);
164 loc->initialize();
165
166 Teuchos::RCP<BlockedTpetraLinObjContainerType> t_loc = Teuchos::rcp_dynamic_cast<BlockedTpetraLinObjContainerType>(loc);
167 Teuchos::RCP<Thyra::VectorBase<double>> x_vec = t_loc->get_x_th();
168 Thyra::assign(x_vec.ptr(), 123.0 + myRank);
169
170 // need a place to evaluate the tangent fields, so we create a
171 // unblocked DOFManager and LOF and set up if needed
172 std::vector<Teuchos::RCP<GlobalEvaluationData>> tangentContainers;
173 Teuchos::RCP<panzer::DOFManager> dofManager = Teuchos::rcp(new panzer::DOFManager(conn_manager, MPI_COMM_WORLD));
174 Teuchos::RCP<TpetraLinObjFactoryType> tangent_lof = Teuchos::rcp(new TpetraLinObjFactoryType(tComm.getConst(), dofManager));
175 Teuchos::RCP<LinearObjFactory<panzer::Traits>> parent_tangent_lof = tangent_lof;
176
177 if (enable_tangents)
178 {
179 using Teuchos::RCP;
180 using Teuchos::rcp;
181 using Teuchos::rcp_dynamic_cast;
182 using Thyra::ProductVectorBase;
183 using LOCPair = panzer::LOCPair_GlobalEvaluationData;
184
185 std::vector<std::string> tangent_fieldOrder;
186 for (int i(0); i < num_tangent; ++i) {
187 std::stringstream ssedge;
188 ssedge << fieldName_qedge1 << " Tangent " << i;
189 std::stringstream ss1, ss2;
190 ss1 << fieldName1_q1 << " Tangent " << i;
191 ss2 << fieldName2_q1 << " Tangent " << i;
192
193 dofManager->addField(ss1.str(), Teuchos::rcp(new panzer::Intrepid2FieldPattern(basis_q1->getIntrepid2Basis())));
194 dofManager->addField(ss2.str(), Teuchos::rcp(new panzer::Intrepid2FieldPattern(basis_q1->getIntrepid2Basis())));
195 dofManager->addField(ssedge.str(), Teuchos::rcp(new panzer::Intrepid2FieldPattern(basis_qedge1->getIntrepid2Basis())));
196 tangent_fieldOrder.push_back(ss1.str());
197 tangent_fieldOrder.push_back(ss2.str());
198 tangent_fieldOrder.push_back(ssedge.str());
199 }
200 dofManager->setFieldOrder(tangent_fieldOrder);
201 dofManager->buildGlobalUnknowns();
202
203 // generate and evaluate some fields
204 Teuchos::RCP<LinearObjContainer> tangent_loc = tangent_lof->buildGhostedLinearObjContainer();
205 tangent_lof->initializeGhostedContainer(LinearObjContainer::X, *tangent_loc);
206 tangent_loc->initialize();
207
208 for (int i(0); i < num_tangent; ++i)
209 {
210 auto locPair = Teuchos::rcp(new LOCPair(tangent_lof, panzer::LinearObjContainer::X));
211
212 auto global_t_loc = rcp_dynamic_cast<TpetraLinObjContainerType>(locPair->getGlobalLOC());
213 Teuchos::RCP<Thyra::VectorBase<double>> global_x_vec = global_t_loc->get_x_th();
214 Thyra::assign(global_x_vec.ptr(), 0.123 + myRank + i);
215
216 auto ghosted_t_loc = rcp_dynamic_cast<TpetraLinObjContainerType>(locPair->getGhostedLOC());
217 Teuchos::RCP<Thyra::VectorBase<double>> ghosted_x_vec = ghosted_t_loc->get_x_th();
218 Thyra::assign(ghosted_x_vec.ptr(), 0.123 + myRank + i);
219
220 tangentContainers.push_back(locPair);
221 } // end loop over the tangents
222 } // end if (enable_tangents)
223
224 // setup field manager, add evaluator under test
225 /////////////////////////////////////////////////////////////
226
227 PHX::FieldManager<panzer::Traits> fm;
228
229 std::vector<PHX::index_size_type> derivative_dimensions;
230 derivative_dimensions.push_back(12);
231 fm.setKokkosExtendedDataTypeDimensions<panzer::Traits::Jacobian>(derivative_dimensions);
232
233 std::vector<PHX::index_size_type> tan_derivative_dimensions;
234 if (enable_tangents)
235 tan_derivative_dimensions.push_back(num_tangent);
236 else
237 tan_derivative_dimensions.push_back(0);
238 fm.setKokkosExtendedDataTypeDimensions<panzer::Traits::Tangent>(tan_derivative_dimensions);
239
240 Teuchos::RCP<PHX::FieldTag> evalField_q1, evalField_qedge1;
241 {
242 using Teuchos::RCP;
243 using Teuchos::rcp;
244 RCP<std::vector<std::string>> names = rcp(new std::vector<std::string>);
245 names->push_back(fieldName1_q1);
246 names->push_back(fieldName2_q1);
247
248 Teuchos::ParameterList pl;
249 pl.set("Basis", basis_q1);
250 pl.set("DOF Names", names);
251 pl.set("Indexer Names", names);
252
253 Teuchos::RCP<PHX::Evaluator<panzer::Traits>> evaluator = lof->buildGather<panzer::Traits::Residual>(pl);
254
255 TEST_EQUALITY(evaluator->evaluatedFields().size(), 2);
256
257 fm.registerEvaluator<panzer::Traits::Residual>(evaluator);
258 fm.requireField<panzer::Traits::Residual>(*evaluator->evaluatedFields()[0]);
259 }
260 {
261 using Teuchos::RCP;
262 using Teuchos::rcp;
263 RCP<std::vector<std::string>> names = rcp(new std::vector<std::string>);
264 names->push_back(fieldName_qedge1);
265
266 Teuchos::ParameterList pl;
267 pl.set("Basis", basis_qedge1);
268 pl.set("DOF Names", names);
269 pl.set("Indexer Names", names);
270
271 Teuchos::RCP<PHX::Evaluator<panzer::Traits>> evaluator = lof->buildGather<panzer::Traits::Residual>(pl);
272
273 TEST_EQUALITY(evaluator->evaluatedFields().size(), 1);
274
275 fm.registerEvaluator<panzer::Traits::Residual>(evaluator);
276 fm.requireField<panzer::Traits::Residual>(*evaluator->evaluatedFields()[0]);
277 }
278
279 {
280 using Teuchos::RCP;
281 using Teuchos::rcp;
282 RCP<std::vector<std::string>> names = rcp(new std::vector<std::string>);
283 names->push_back(fieldName1_q1);
284 names->push_back(fieldName2_q1);
285
286 Teuchos::ParameterList pl;
287 pl.set("Basis", basis_q1);
288 pl.set("DOF Names", names);
289 pl.set("Indexer Names", names);
290
291 Teuchos::RCP<PHX::Evaluator<panzer::Traits>> evaluator = lof->buildGather<panzer::Traits::Jacobian>(pl);
292
293 TEST_EQUALITY(evaluator->evaluatedFields().size(), 2);
294
295 fm.registerEvaluator<panzer::Traits::Jacobian>(evaluator);
296 fm.requireField<panzer::Traits::Jacobian>(*evaluator->evaluatedFields()[0]);
297 }
298 {
299 using Teuchos::RCP;
300 using Teuchos::rcp;
301 RCP<std::vector<std::string>> names = rcp(new std::vector<std::string>);
302 names->push_back(fieldName_qedge1);
303
304 Teuchos::ParameterList pl;
305 pl.set("Basis", basis_qedge1);
306 pl.set("DOF Names", names);
307 pl.set("Indexer Names", names);
308
309 Teuchos::RCP<PHX::Evaluator<panzer::Traits>> evaluator = lof->buildGather<panzer::Traits::Jacobian>(pl);
310
311 TEST_EQUALITY(evaluator->evaluatedFields().size(), 1);
312
313 fm.registerEvaluator<panzer::Traits::Jacobian>(evaluator);
314 fm.requireField<panzer::Traits::Jacobian>(*evaluator->evaluatedFields()[0]);
315 }
316
317 {
318 using Teuchos::RCP;
319 using Teuchos::rcp;
320 RCP<std::vector<std::string>> names = rcp(new std::vector<std::string>);
321 names->push_back(fieldName1_q1);
322 names->push_back(fieldName2_q1);
323
324 Teuchos::ParameterList pl;
325 pl.set("Basis", basis_q1);
326 pl.set("DOF Names", names);
327 pl.set("Indexer Names", names);
328
329 if (enable_tangents)
330 {
331 RCP<std::vector<std::vector<std::string>>> tangent_names =
332 rcp(new std::vector<std::vector<std::string>>(2));
333 for (int i = 0; i < num_tangent; ++i)
334 {
335 std::stringstream ss1, ss2;
336 ss1 << fieldName1_q1 << " Tangent " << i;
337 ss2 << fieldName2_q1 << " Tangent " << i;
338 (*tangent_names)[0].push_back(ss1.str());
339 (*tangent_names)[1].push_back(ss2.str());
340 }
341 pl.set("Tangent Names", tangent_names);
342 }
343
344 Teuchos::RCP<PHX::Evaluator<panzer::Traits>> evaluator = lof->buildGather<panzer::Traits::Tangent>(pl);
345
346 TEST_EQUALITY(evaluator->evaluatedFields().size(), 2);
347
348 fm.registerEvaluator<panzer::Traits::Tangent>(evaluator);
349 fm.requireField<panzer::Traits::Tangent>(*evaluator->evaluatedFields()[0]);
350 }
351 {
352 using Teuchos::RCP;
353 using Teuchos::rcp;
354 RCP<std::vector<std::string>> names = rcp(new std::vector<std::string>);
355 names->push_back(fieldName_qedge1);
356
357 Teuchos::ParameterList pl;
358 pl.set("Basis", basis_qedge1);
359 pl.set("DOF Names", names);
360 pl.set("Indexer Names", names);
361
362 if (enable_tangents)
363 {
364 RCP<std::vector<std::vector<std::string>>> tangent_names =
365 rcp(new std::vector<std::vector<std::string>>(1));
366 for (int i = 0; i < num_tangent; ++i)
367 {
368 std::stringstream ss;
369 ss << fieldName_qedge1 << " Tangent " << i;
370 (*tangent_names)[0].push_back(ss.str());
371 }
372 pl.set("Tangent Names", tangent_names);
373 }
374
375 Teuchos::RCP<PHX::Evaluator<panzer::Traits>> evaluator = lof->buildGather<panzer::Traits::Tangent>(pl);
376
377 TEST_EQUALITY(evaluator->evaluatedFields().size(), 1);
378
379 fm.registerEvaluator<panzer::Traits::Tangent>(evaluator);
380 fm.requireField<panzer::Traits::Tangent>(*evaluator->evaluatedFields()[0]);
381 }
382
383 if (enable_tangents)
384 {
385 for (int i = 0; i < num_tangent; ++i)
386 {
387 using Teuchos::RCP;
388 using Teuchos::rcp;
389 RCP<std::vector<std::string>> names = rcp(new std::vector<std::string>);
390 RCP<std::vector<std::string>> tangent_names = rcp(new std::vector<std::string>);
391 names->push_back(fieldName1_q1);
392 names->push_back(fieldName2_q1);
393 {
394 std::stringstream ss1, ss2;
395 ss1 << fieldName1_q1 << " Tangent " << i;
396 ss2 << fieldName2_q1 << " Tangent " << i;
397 tangent_names->push_back(ss1.str());
398 tangent_names->push_back(ss2.str());
399 }
400
401 Teuchos::ParameterList pl;
402 pl.set("Basis", basis_q1);
403 pl.set("DOF Names", tangent_names);
404 pl.set("Indexer Names", tangent_names);
405
406 {
407 std::stringstream ss;
408 ss << "Tangent Container " << i;
409 pl.set("Global Data Key", ss.str());
410 }
411
412 Teuchos::RCP<PHX::Evaluator<panzer::Traits>> evaluator =
413 parent_tangent_lof->buildGatherTangent<panzer::Traits::Tangent>(pl);
414
415 TEST_EQUALITY(evaluator->evaluatedFields().size(), 2);
416
417 fm.registerEvaluator<panzer::Traits::Tangent>(evaluator);
418 }
419 for (int i = 0; i < num_tangent; ++i)
420 {
421 using Teuchos::RCP;
422 using Teuchos::rcp;
423 RCP<std::vector<std::string>> names = rcp(new std::vector<std::string>);
424 RCP<std::vector<std::string>> tangent_names = rcp(new std::vector<std::string>);
425 names->push_back(fieldName_qedge1);
426 {
427 std::stringstream ss;
428 ss << fieldName_qedge1 << " Tangent " << i;
429 tangent_names->push_back(ss.str());
430 }
431
432 Teuchos::ParameterList pl;
433 pl.set("Basis", basis_qedge1);
434 pl.set("DOF Names", tangent_names);
435 pl.set("Indexer Names", tangent_names);
436
437 {
438 std::stringstream ss;
439 ss << "Tangent Container " << i;
440 pl.set("Global Data Key", ss.str());
441 }
442
443 Teuchos::RCP<PHX::Evaluator<panzer::Traits>> evaluator =
444 parent_tangent_lof->buildGatherTangent<panzer::Traits::Tangent>(pl);
445
446 TEST_EQUALITY(evaluator->evaluatedFields().size(), 1);
447
448 fm.registerEvaluator<panzer::Traits::Tangent>(evaluator);
449 }
450 }
451
452 panzer::Traits::SD sd;
453
454 panzer::Workset &workset = (*work_sets)[0];
455 workset.alpha = 0.0;
456 workset.beta = 2.0; // derivatives multiplied by 2
457 workset.time = 0.0;
458 workset.evaluate_transient_terms = false;
459
460 sd.worksets_ = work_sets;
461
462 fm.postRegistrationSetup(sd);
463
464 panzer::Traits::PED ped;
465 ped.gedc->addDataObject("Solution Gather Container", loc);
466 if (enable_tangents)
467 {
468 for (int i(0); i < num_tangent; ++i)
469 {
470 std::stringstream ss;
471 ss << "Tangent Container " << i;
472 ped.gedc->addDataObject(ss.str(), tangentContainers[i]);
473 }
474 }
475
476 fm.preEvaluate<panzer::Traits::Residual>(ped);
477 fm.evaluateFields<panzer::Traits::Residual>(workset);
478 fm.postEvaluate<panzer::Traits::Residual>(0);
479
480 fm.preEvaluate<panzer::Traits::Jacobian>(ped);
481 fm.evaluateFields<panzer::Traits::Jacobian>(workset);
482 fm.postEvaluate<panzer::Traits::Jacobian>(0);
483
484 fm.preEvaluate<panzer::Traits::Tangent>(ped);
485 fm.evaluateFields<panzer::Traits::Tangent>(workset);
486 fm.postEvaluate<panzer::Traits::Tangent>(0);
487
488 // test Residual fields
489 {
490 PHX::MDField<panzer::Traits::Residual::ScalarT, panzer::Cell, panzer::BASIS>
491 fieldData1_q1(fieldName1_q1, basis_q1->functional);
492 PHX::MDField<panzer::Traits::Residual::ScalarT, panzer::Cell, panzer::BASIS>
493 fieldData2_q1(fieldName2_q1, basis_qedge1->functional);
494
495 fm.getFieldData<panzer::Traits::Residual>(fieldData1_q1);
496 fm.getFieldData<panzer::Traits::Residual>(fieldData2_q1);
497
498 TEST_EQUALITY(fieldData1_q1.extent(0), Teuchos::as<unsigned int>(4 / numProcs));
499 TEST_EQUALITY(fieldData1_q1.extent(1), 4);
500 TEST_EQUALITY(fieldData2_q1.extent(0), Teuchos::as<unsigned int>(4 / numProcs));
501 TEST_EQUALITY(fieldData2_q1.extent(1), 4);
502 TEST_EQUALITY(fieldData1_q1.size(), Teuchos::as<unsigned int>(4 * 4 / numProcs));
503 TEST_EQUALITY(fieldData2_q1.size(), Teuchos::as<unsigned int>(4 * 4 / numProcs));
504
505 auto fieldData1_q1_h = Kokkos::create_mirror_view(fieldData1_q1.get_static_view());
506 auto fieldData2_q1_h = Kokkos::create_mirror_view(fieldData2_q1.get_static_view());
507 Kokkos::deep_copy(fieldData1_q1_h, fieldData1_q1.get_static_view());
508 Kokkos::deep_copy(fieldData2_q1_h, fieldData2_q1.get_static_view());
509
510 for (unsigned int i = 0; i < fieldData1_q1.extent(0); i++)
511 for (unsigned int j = 0; j < fieldData1_q1.extent(1); j++)
512 TEST_EQUALITY(fieldData1_q1_h(i, j), 123.0 + myRank);
513
514 for (unsigned int i = 0; i < fieldData2_q1.extent(0); i++)
515 for (unsigned int j = 0; j < fieldData2_q1.extent(1); j++)
516 TEST_EQUALITY(fieldData2_q1_h(i, j), 123.0 + myRank);
517 }
518 {
519 PHX::MDField<panzer::Traits::Residual::ScalarT, panzer::Cell, panzer::BASIS>
520 fieldData_qedge1(fieldName_qedge1, basis_qedge1->functional);
521
522 fm.getFieldData<panzer::Traits::Residual>(fieldData_qedge1);
523
524 auto fieldData_qedge1_h = Kokkos::create_mirror_view(fieldData_qedge1.get_static_view());
525 Kokkos::deep_copy(fieldData_qedge1_h, fieldData_qedge1.get_static_view());
526
527 TEST_EQUALITY(fieldData_qedge1.extent(0), Teuchos::as<unsigned int>(4 / numProcs));
528 TEST_EQUALITY(fieldData_qedge1.extent(1), 4);
529 TEST_EQUALITY(fieldData_qedge1.size(), Teuchos::as<unsigned int>(4 * 4 / numProcs));
530
531 for (unsigned int cell = 0; cell < fieldData_qedge1.extent(0); ++cell)
532 for (unsigned int pt = 0; pt < fieldData_qedge1.extent(1); pt++)
533 TEST_EQUALITY(fieldData_qedge1_h(cell, pt), 123.0 + myRank);
534 }
535
536 // test Jacobian fields
537 {
538 PHX::MDField<panzer::Traits::Jacobian::ScalarT, panzer::Cell, panzer::BASIS>
539 fieldData1_q1(fieldName1_q1, basis_q1->functional);
540 PHX::MDField<panzer::Traits::Jacobian::ScalarT, panzer::Cell, panzer::BASIS>
541 fieldData2_q1(fieldName2_q1, basis_qedge1->functional);
542
543 fm.getFieldData<panzer::Traits::Jacobian>(fieldData1_q1);
544 fm.getFieldData<panzer::Traits::Jacobian>(fieldData2_q1);
545
546 auto fieldData1_q1_h = Kokkos::create_mirror_view(fieldData1_q1.get_static_view());
547 auto fieldData2_q1_h = Kokkos::create_mirror_view(fieldData2_q1.get_static_view());
548 Kokkos::deep_copy(fieldData1_q1_h, fieldData1_q1.get_static_view());
549 Kokkos::deep_copy(fieldData2_q1_h, fieldData2_q1.get_static_view());
550
551 for (unsigned int cell = 0; cell < fieldData1_q1.extent(0); ++cell)
552 {
553 for (unsigned int pt = 0; pt < fieldData1_q1.extent(1); pt++)
554 {
555 TEST_EQUALITY(fieldData1_q1_h(cell, pt), 123.0 + myRank);
556 TEST_EQUALITY(fieldData1_q1_h(cell, pt).availableSize(), 12);
557 }
558 }
559 for (unsigned int cell = 0; cell < fieldData2_q1.extent(0); ++cell)
560 {
561 for (unsigned int pt = 0; pt < fieldData2_q1.extent(1); pt++)
562 {
563 TEST_EQUALITY(fieldData2_q1_h(cell, pt), 123.0 + myRank);
564 TEST_EQUALITY(fieldData2_q1_h(cell, pt).availableSize(), 12);
565 }
566 }
567 }
568 {
569 PHX::MDField<panzer::Traits::Jacobian::ScalarT, panzer::Cell, panzer::BASIS>
570 fieldData_qedge1(fieldName_qedge1, basis_qedge1->functional);
571
572 fm.getFieldData<panzer::Traits::Jacobian>(fieldData_qedge1);
573
574 auto fieldData_qedge1_h = Kokkos::create_mirror_view(fieldData_qedge1.get_static_view());
575 Kokkos::deep_copy(fieldData_qedge1_h, fieldData_qedge1.get_static_view());
576
577 for (unsigned int cell = 0; cell < fieldData_qedge1.extent(0); ++cell)
578 {
579 for (unsigned int pt = 0; pt < fieldData_qedge1.extent(1); ++pt)
580 {
581 TEST_EQUALITY(fieldData_qedge1_h(cell, pt), 123.0 + myRank);
582 TEST_EQUALITY(fieldData_qedge1_h(cell, pt).availableSize(), 12);
583 }
584 }
585 }
586
587 // test Tangent fields
588 {
589 PHX::MDField<panzer::Traits::Tangent::ScalarT, panzer::Cell, panzer::BASIS>
590 fieldData1_q1(fieldName1_q1, basis_q1->functional);
591 PHX::MDField<panzer::Traits::Tangent::ScalarT, panzer::Cell, panzer::BASIS>
592 fieldData2_q1(fieldName2_q1, basis_qedge1->functional);
593
594 fm.getFieldData<panzer::Traits::Tangent>(fieldData1_q1);
595 fm.getFieldData<panzer::Traits::Tangent>(fieldData2_q1);
596
597 auto fieldData1_q1_h = Kokkos::create_mirror_view(fieldData1_q1.get_static_view());
598 auto fieldData2_q1_h = Kokkos::create_mirror_view(fieldData2_q1.get_static_view());
599 Kokkos::deep_copy(fieldData1_q1_h, fieldData1_q1.get_static_view());
600 Kokkos::deep_copy(fieldData2_q1_h, fieldData2_q1.get_static_view());
601
602 for (unsigned int cell = 0; cell < fieldData1_q1.extent(0); ++cell)
603 {
604 for (unsigned int pt = 0; pt < fieldData1_q1.extent(1); pt++)
605 {
606 if (enable_tangents)
607 {
608 TEST_EQUALITY(fieldData1_q1_h(cell, pt).val(), 123.0 + myRank);
609 TEST_EQUALITY(fieldData1_q1_h(cell, pt).availableSize(), num_tangent);
610 for (int i = 0; i < num_tangent; ++i)
611 TEST_EQUALITY(fieldData1_q1_h(cell, pt).dx(i), 0.123 + myRank + i);
612 }
613 else
614 {
615 TEST_EQUALITY(fieldData1_q1_h(cell, pt), 123.0 + myRank);
616 TEST_EQUALITY(fieldData1_q1_h(cell, pt).availableSize(), 0);
617 }
618 }
619 }
620 for (unsigned int cell = 0; cell < fieldData2_q1.extent(0); ++cell)
621 {
622 for (unsigned int pt = 0; pt < fieldData2_q1.extent(1); pt++)
623 {
624 if (enable_tangents)
625 {
626 TEST_EQUALITY(fieldData2_q1_h(cell, pt).val(), 123.0 + myRank);
627 TEST_EQUALITY(fieldData2_q1_h(cell, pt).availableSize(), num_tangent);
628 for (int i = 0; i < num_tangent; ++i)
629 {
630 TEST_EQUALITY(fieldData2_q1_h(cell, pt).dx(i), 0.123 + myRank + i);
631 TEST_EQUALITY(fieldData2_q1_h(cell, pt).dx(i), 0.123 + myRank + i);
632 }
633 }
634 else
635 {
636 TEST_EQUALITY(fieldData2_q1_h(cell, pt), 123.0 + myRank);
637 TEST_EQUALITY(fieldData2_q1_h(cell, pt).availableSize(), 0);
638 }
639 }
640 }
641 }
642 {
643 PHX::MDField<panzer::Traits::Tangent::ScalarT, panzer::Cell, panzer::BASIS>
644 fieldData_qedge1(fieldName_qedge1, basis_qedge1->functional);
645
646 fm.getFieldData<panzer::Traits::Tangent>(fieldData_qedge1);
647
648 auto fieldData_qedge1_h = Kokkos::create_mirror_view(fieldData_qedge1.get_static_view());
649 Kokkos::deep_copy(fieldData_qedge1_h, fieldData_qedge1.get_static_view());
650
651 for (unsigned int cell = 0; cell < fieldData_qedge1.extent(0); ++cell)
652 {
653 for (unsigned int pt = 0; pt < fieldData_qedge1.extent(1); ++pt)
654 {
655 if (enable_tangents)
656 {
657 TEST_EQUALITY(fieldData_qedge1_h(cell, pt).val(), 123.0 + myRank);
658 TEST_EQUALITY(fieldData_qedge1_h(cell, pt).availableSize(), num_tangent);
659 for (int i = 0; i < num_tangent; ++i)
660 TEST_EQUALITY(fieldData_qedge1_h(cell, pt).dx(i), 0.123 + myRank + i);
661 }
662 else
663 {
664 TEST_EQUALITY(fieldData_qedge1_h(cell, pt), 123.0 + myRank);
665 TEST_EQUALITY(fieldData_qedge1_h(cell, pt).availableSize(), 0);
666 }
667 }
668 }
669 }
670 }
671
672 Teuchos::RCP<panzer::PureBasis> buildBasis(std::size_t worksetSize, const std::string &basisName)
673 {
674 Teuchos::RCP<shards::CellTopology> topo =
675 Teuchos::rcp(new shards::CellTopology(shards::getCellTopologyData<shards::Quadrilateral<4>>()));
676
677 panzer::CellData cellData(worksetSize, topo);
678 return Teuchos::rcp(new panzer::PureBasis(basisName, 1, cellData));
679 }
680
681 Teuchos::RCP<panzer_stk::STK_Interface> buildMesh(int elemX, int elemY)
682 {
683 Teuchos::RCP<Teuchos::ParameterList> pl = rcp(new Teuchos::ParameterList);
684 pl->set("X Blocks", 1);
685 pl->set("Y Blocks", 1);
686 pl->set("X Elements", elemX);
687 pl->set("Y Elements", elemY);
688
689 panzer_stk::SquareQuadMeshFactory factory;
690 factory.setParameterList(pl);
691 Teuchos::RCP<panzer_stk::STK_Interface> mesh = factory.buildUncommitedMesh(MPI_COMM_WORLD);
692 factory.completeMeshConstruction(*mesh, MPI_COMM_WORLD);
693
694 return mesh;
695 }
696
697 void testInitialization(const Teuchos::RCP<Teuchos::ParameterList> &ipb)
698 {
699 // Physics block
700 ipb->setName("test physics");
701 {
702 Teuchos::ParameterList &p = ipb->sublist("a");
703 p.set("Type", "Energy");
704 p.set("Prefix", "");
705 p.set("Model ID", "solid");
706 p.set("Basis Type", "HGrad");
707 p.set("Basis Order", 1);
708 p.set("Integration Order", 1);
709 }
710 {
711 Teuchos::ParameterList &p = ipb->sublist("b");
712 p.set("Type", "Energy");
713 p.set("Prefix", "ION_");
714 p.set("Model ID", "solid");
715 p.set("Basis Type", "HCurl");
716 p.set("Basis Order", 1);
717 p.set("Integration Order", 1);
718 }
719 }
720
721 }