Debian Codegraph @

packages/panzer/adapters-stk/test/evaluator_tests/tpetra_blocked_scatter_dirichlet_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_ScatterDirichletResidual_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 "Tpetra_CrsMatrix.hpp"
50 #include "Tpetra_Map.hpp"
51
52 #include "user_app_EquationSetFactory.hpp"
53
54 #include <cstdio> // for get char
55 #include <vector>
56 #include <string>
57
58 #include "Panzer_Evaluator_WithBaseImpl.hpp"
59
60 namespace panzer
61 {
62 typedef Teuchos::ArrayRCP<const double>::size_type size_type;
63
64 using TpetraBlockedLinObjFactoryType = panzer::BlockedTpetraLinearObjFactory<panzer::Traits, double, panzer::LocalOrdinal, panzer::GlobalOrdinal>;
65 using TpetraBlockedLinObjContainerType = panzer::BlockedTpetraLinearObjContainer<double, panzer::LocalOrdinal, panzer::GlobalOrdinal>;
66 using Tpetra_CrsMatrix = Tpetra::CrsMatrix<double, panzer::LocalOrdinal, panzer::GlobalOrdinal>;
67 using Thyra_TpetraLinearOp = Thyra::TpetraLinearOp<double, LocalOrdinal, GlobalOrdinal>;
68
69 Teuchos::RCP<panzer::PureBasis> buildBasis(std::size_t worksetSize, const std::string &basisName);
70 void testInitialization(const Teuchos::RCP<Teuchos::ParameterList> &ipb);
71 Teuchos::RCP<panzer_stk::STK_Interface> buildMesh(int elemX, int elemY);
72
73 TEUCHOS_UNIT_TEST(block_assembly, scatter_dirichlet_residual)
74 {
75
76 #ifdef HAVE_MPI
77 Teuchos::RCP<Teuchos::MpiComm<int>> tComm = Teuchos::rcp(new Teuchos::MpiComm<int>(MPI_COMM_WORLD));
78 #else
79 NOPE_PANZER_DOESNT_SUPPORT_SERIAL
80 #endif
81
82 int myRank = tComm->getRank();
83
84 const std::size_t workset_size = 4;
85 const std::string fieldName1_q1 = "U";
86 const std::string fieldName2_q1 = "V";
87 const std::string fieldName_qedge1 = "B";
88
89 Teuchos::RCP<panzer_stk::STK_Interface> mesh = buildMesh(2, 2);
90
91 // build input physics block
92 Teuchos::RCP<panzer::PureBasis> basis_q1 = buildBasis(workset_size, "Q1");
93 Teuchos::RCP<panzer::PureBasis> basis_qedge1 = buildBasis(workset_size, "QEdge1");
94
95 Teuchos::RCP<Teuchos::ParameterList> ipb = Teuchos::parameterList();
96 testInitialization(ipb);
97
98 const int default_int_order = 1;
99 std::string eBlockID = "eblock-0_0";
100 Teuchos::RCP<user_app::MyFactory> eqset_factory = Teuchos::rcp(new user_app::MyFactory);
101 panzer::CellData cellData(workset_size, mesh->getCellTopology("eblock-0_0"));
102 Teuchos::RCP<panzer::GlobalData> gd = panzer::createGlobalData();
103 Teuchos::RCP<panzer::PhysicsBlock> physicsBlock =
104 Teuchos::rcp(new PhysicsBlock(ipb, eBlockID, default_int_order, cellData, eqset_factory, gd, false));
105
106 Teuchos::RCP<std::vector<panzer::Workset>> work_sets = panzer_stk::buildWorksets(*mesh, physicsBlock->elementBlockID(),
107 physicsBlock->getWorksetNeeds());
108 TEST_EQUALITY(work_sets->size(), 1);
109
110 // build connection manager and field manager
111 const Teuchos::RCP<panzer::ConnManager> conn_manager = Teuchos::rcp(new panzer_stk::STKConnManager(mesh));
112 RCP<panzer::BlockedDOFManager> dofManager = Teuchos::rcp(new panzer::BlockedDOFManager(conn_manager, MPI_COMM_WORLD));
113
114 dofManager->addField(fieldName1_q1, Teuchos::rcp(new panzer::Intrepid2FieldPattern(basis_q1->getIntrepid2Basis())));
115 dofManager->addField(fieldName2_q1, Teuchos::rcp(new panzer::Intrepid2FieldPattern(basis_q1->getIntrepid2Basis())));
116 dofManager->addField(fieldName_qedge1, Teuchos::rcp(new panzer::Intrepid2FieldPattern(basis_qedge1->getIntrepid2Basis())));
117
118 std::vector<std::vector<std::string>> fieldOrder(3);
119 fieldOrder[0].push_back(fieldName1_q1);
120 fieldOrder[1].push_back(fieldName_qedge1);
121 fieldOrder[2].push_back(fieldName2_q1);
122 dofManager->setFieldOrder(fieldOrder);
123
124 // dofManager->setOrientationsRequired(true);
125 dofManager->buildGlobalUnknowns();
126
127 // setup linear object factory
128 /////////////////////////////////////////////////////////////
129
130 Teuchos::RCP<TpetraBlockedLinObjFactoryType> bt_lof = Teuchos::rcp(new TpetraBlockedLinObjFactoryType(tComm.getConst(), dofManager));
131 Teuchos::RCP<LinearObjFactory<panzer::Traits>> lof = bt_lof;
132 Teuchos::RCP<LinearObjContainer> dd_loc = bt_lof->buildGhostedLinearObjContainer();
133 Teuchos::RCP<LinearObjContainer> loc = bt_lof->buildGhostedLinearObjContainer();
134 bt_lof->initializeGhostedContainer(LinearObjContainer::F, *dd_loc);
135 dd_loc->initialize();
136
137 bt_lof->initializeGhostedContainer(LinearObjContainer::X | LinearObjContainer::F, *loc);
138 loc->initialize();
139
140 Teuchos::RCP<TpetraBlockedLinObjContainerType> b_dd_loc = Teuchos::rcp_dynamic_cast<TpetraBlockedLinObjContainerType>(dd_loc);
141 Teuchos::RCP<TpetraBlockedLinObjContainerType> b_loc = Teuchos::rcp_dynamic_cast<TpetraBlockedLinObjContainerType>(loc);
142 Teuchos::RCP<Thyra::ProductVectorBase<double>> p_vec = Teuchos::rcp_dynamic_cast<Thyra::ProductVectorBase<double>>(b_loc->get_x());
143 Thyra::assign(p_vec->getNonconstVectorBlock(0).ptr(), 123.0 + myRank);
144 Thyra::assign(p_vec->getNonconstVectorBlock(1).ptr(), 456.0 + myRank);
145 Thyra::assign(p_vec->getNonconstVectorBlock(2).ptr(), 789.0 + myRank);
146
147 // setup field manager, add evaluator under test
148 /////////////////////////////////////////////////////////////
149
150 PHX::FieldManager<panzer::Traits> fm;
151
152 std::string resName = "";
153 Teuchos::RCP<std::map<std::string, std::string>> names_map =
154 Teuchos::rcp(new std::map<std::string, std::string>);
155 names_map->insert(std::make_pair(fieldName1_q1, resName + fieldName1_q1));
156 names_map->insert(std::make_pair(fieldName2_q1, resName + fieldName2_q1));
157 names_map->insert(std::make_pair(fieldName_qedge1, resName + fieldName_qedge1));
158
159 // evaluators under test
160 {
161 using Teuchos::RCP;
162 using Teuchos::rcp;
163 RCP<std::vector<std::string>> names = rcp(new std::vector<std::string>);
164 names->push_back(resName + fieldName1_q1);
165 names->push_back(resName + fieldName2_q1);
166
167 Teuchos::ParameterList pl;
168 pl.set("Scatter Name", "ScatterQ1");
169 pl.set("Basis", basis_q1);
170 pl.set("Dependent Names", names);
171 pl.set("Dependent Map", names_map);
172 pl.set("Side Subcell Dimension", 1);
173 pl.set("Local Side ID", 2);
174 pl.set("Check Apply BC", false);
175
176 Teuchos::RCP<PHX::Evaluator<panzer::Traits>> evaluator = lof->buildScatterDirichlet<panzer::Traits::Residual>(pl);
177
178 TEST_EQUALITY(evaluator->evaluatedFields().size(), 1);
179
180 fm.registerEvaluator<panzer::Traits::Residual>(evaluator);
181 fm.requireField<panzer::Traits::Residual>(*evaluator->evaluatedFields()[0]);
182 }
183 {
184 using Teuchos::RCP;
185 using Teuchos::rcp;
186 RCP<std::vector<std::string>> names = rcp(new std::vector<std::string>);
187 names->push_back(resName + fieldName_qedge1);
188
189 Teuchos::ParameterList pl;
190 pl.set("Scatter Name", "ScatterQEdge1");
191 pl.set("Basis", basis_qedge1);
192 pl.set("Dependent Names", names);
193 pl.set("Dependent Map", names_map);
194 pl.set("Side Subcell Dimension", 1);
195 pl.set("Local Side ID", 2);
196 pl.set("Check Apply BC", false);
197
198 Teuchos::RCP<PHX::Evaluator<panzer::Traits>> evaluator = lof->buildScatterDirichlet<panzer::Traits::Residual>(pl);
199
200 TEST_EQUALITY(evaluator->evaluatedFields().size(), 1);
201
202 fm.registerEvaluator<panzer::Traits::Residual>(evaluator);
203 fm.requireField<panzer::Traits::Residual>(*evaluator->evaluatedFields()[0]);
204 }
205
206 // support evaluators
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(fieldName1_q1);
212 names->push_back(fieldName2_q1);
213
214 Teuchos::ParameterList pl;
215 pl.set("Basis", basis_q1);
216 pl.set("DOF Names", names);
217 pl.set("Indexer Names", names);
218
219 Teuchos::RCP<PHX::Evaluator<panzer::Traits>> evaluator = lof->buildGather<panzer::Traits::Residual>(pl);
220
221 fm.registerEvaluator<panzer::Traits::Residual>(evaluator);
222 }
223 {
224 using Teuchos::RCP;
225 using Teuchos::rcp;
226 RCP<std::vector<std::string>> names = rcp(new std::vector<std::string>);
227 names->push_back(fieldName_qedge1);
228
229 Teuchos::ParameterList pl;
230 pl.set("Basis", basis_qedge1);
231 pl.set("DOF Names", names);
232 pl.set("Indexer Names", names);
233
234 Teuchos::RCP<PHX::Evaluator<panzer::Traits>> evaluator = lof->buildGather<panzer::Traits::Residual>(pl);
235
236 fm.registerEvaluator<panzer::Traits::Residual>(evaluator);
237 }
238
239 std::vector<PHX::index_size_type> derivative_dimensions;
240 derivative_dimensions.push_back(12);
241 fm.setKokkosExtendedDataTypeDimensions<panzer::Traits::Jacobian>(derivative_dimensions);
242
243 panzer::Traits::SD sd;
244 sd.worksets_ = work_sets;
245
246 fm.postRegistrationSetup(sd);
247
248 // panzer::Traits::PED ped;
249 // ped.dirichletData.ghostedCounter = dd_loc;
250 // fm.preEvaluate<panzer::Traits::Residual>(ped);
251 panzer::Traits::PED ped;
252 ped.gedc->addDataObject("Dirichlet Counter", dd_loc);
253 ped.gedc->addDataObject("Solution Gather Container", loc);
254 ped.gedc->addDataObject("Residual Scatter Container", loc);
255 fm.preEvaluate<panzer::Traits::Residual>(ped);
256
257 // run tests
258 /////////////////////////////////////////////////////////////
259
260 panzer::Workset &workset = (*work_sets)[0];
261 workset.alpha = 0.0;
262 workset.beta = 2.0; // derivatives multiplied by 2
263 workset.time = 0.0;
264 workset.evaluate_transient_terms = false;
265
266 fm.evaluateFields<panzer::Traits::Residual>(workset);
267
268 // test Residual fields
269 panzer::index_t dd_count(0);
270 Teuchos::ArrayRCP<const double> data, dd_data;
271 Teuchos::RCP<const Thyra::ProductVectorBase<double>> f_vec = Teuchos::rcp_dynamic_cast<Thyra::ProductVectorBase<double>>(b_loc->get_f());
272 Teuchos::RCP<const Thyra::ProductVectorBase<double>> dd_vec = Teuchos::rcp_dynamic_cast<Thyra::ProductVectorBase<double>>(b_dd_loc->get_f());
273
274 // check all the residual values. This is kind of crappy test since it simply checks twice the target
275 // value and the target. Its this way because you add two entries across elements.
276
277 Teuchos::rcp_dynamic_cast<const Thyra::SpmdVectorBase<double>>(f_vec->getVectorBlock(0))->getLocalData(Teuchos::ptrFromRef(data));
278 Teuchos::rcp_dynamic_cast<const Thyra::SpmdVectorBase<double>>(dd_vec->getVectorBlock(0))->getLocalData(Teuchos::ptrFromRef(dd_data));
279 TEST_EQUALITY(static_cast<size_t>(data.size()), b_loc->getMapForBlock(0)->getLocalNumElements());
280 TEST_EQUALITY(data.size(), dd_data.size());
281 dd_count = 0;
282 for (int i = 0; i < data.size(); i++)
283 {
284
285 double target = 123.0 + myRank;
286 if (dd_data[i] == 0.0)
287 {
288 TEST_EQUALITY(data[i], 0.0);
289 }
290 else
291 {
292 TEST_EQUALITY(data[i], target);
293 dd_count++;
294 }
295 }
296 TEST_EQUALITY(dd_count, 2 * workset.num_cells); // there are 2 nodes on the side and the sides are not shared
297
298 Teuchos::rcp_dynamic_cast<const Thyra::SpmdVectorBase<double>>(f_vec->getVectorBlock(1))->getLocalData(Teuchos::ptrFromRef(data));
299 Teuchos::rcp_dynamic_cast<const Thyra::SpmdVectorBase<double>>(dd_vec->getVectorBlock(1))->getLocalData(Teuchos::ptrFromRef(dd_data));
300 TEST_EQUALITY(static_cast<size_t>(data.size()), b_loc->getMapForBlock(1)->getLocalNumElements());
301 TEST_EQUALITY(data.size(), dd_data.size());
302 dd_count = 0;
303 for (int i = 0; i < data.size(); i++)
304 {
305
306 double target = 456.0 + myRank;
307 if (dd_data[i] == 0.0)
308 {
309 TEST_EQUALITY(data[i], 0.0);
310 }
311 else
312 {
313 TEST_EQUALITY(data[i], target);
314 dd_count++;
315 }
316 }
317 TEST_EQUALITY(dd_count, workset.num_cells); // there are 2 nodes on the side and the sides are not shared
318
319 Teuchos::rcp_dynamic_cast<const Thyra::SpmdVectorBase<double>>(f_vec->getVectorBlock(2))->getLocalData(Teuchos::ptrFromRef(data));
320 Teuchos::rcp_dynamic_cast<const Thyra::SpmdVectorBase<double>>(dd_vec->getVectorBlock(2))->getLocalData(Teuchos::ptrFromRef(dd_data));
321 TEST_EQUALITY(static_cast<size_t>(data.size()), b_loc->getMapForBlock(2)->getLocalNumElements());
322 TEST_EQUALITY(data.size(), dd_data.size());
323 dd_count = 0;
324 for (int i = 0; i < data.size(); i++)
325 {
326
327 double target = 789.0 + myRank;
328 if (dd_data[i] == 0.0)
329 {
330 TEST_EQUALITY(data[i], 0.0);
331 }
332 else
333 {
334 TEST_EQUALITY(data[i], target);
335 dd_count++;
336 }
337 }
338 TEST_EQUALITY(dd_count, 2 * workset.num_cells); // there are 2 nodes on the side and the sides are not shared
339 }
340
341 TEUCHOS_UNIT_TEST(block_assembly, scatter_dirichlet_jacobian)
342 {
343
344 #ifdef HAVE_MPI
345 Teuchos::RCP<Teuchos::MpiComm<int>> tComm = Teuchos::rcp(new Teuchos::MpiComm<int>(MPI_COMM_WORLD));
346 #else
347 NOPE_PANZER_DOESNT_SUPPORT_SERIAL
348 #endif
349
350 int myRank = tComm->getRank();
351
352 const std::size_t workset_size = 4;
353 const std::string fieldName1_q1 = "U";
354 const std::string fieldName2_q1 = "V";
355 const std::string fieldName_qedge1 = "B";
356
357 Teuchos::RCP<panzer_stk::STK_Interface> mesh = buildMesh(2, 2);
358
359 // build input physics block
360 Teuchos::RCP<panzer::PureBasis> basis_q1 = buildBasis(workset_size, "Q1");
361 Teuchos::RCP<panzer::PureBasis> basis_qedge1 = buildBasis(workset_size, "QEdge1");
362
363 Teuchos::RCP<Teuchos::ParameterList> ipb = Teuchos::parameterList();
364 testInitialization(ipb);
365
366 const int default_int_order = 1;
367 std::string eBlockID = "eblock-0_0";
368 Teuchos::RCP<user_app::MyFactory> eqset_factory = Teuchos::rcp(new user_app::MyFactory);
369 panzer::CellData cellData(workset_size, mesh->getCellTopology("eblock-0_0"));
370 Teuchos::RCP<panzer::GlobalData> gd = panzer::createGlobalData();
371 Teuchos::RCP<panzer::PhysicsBlock> physicsBlock =
372 Teuchos::rcp(new PhysicsBlock(ipb, eBlockID, default_int_order, cellData, eqset_factory, gd, false));
373
374 Teuchos::RCP<std::vector<panzer::Workset>> work_sets = panzer_stk::buildWorksets(*mesh, physicsBlock->elementBlockID(),
375 physicsBlock->getWorksetNeeds());
376 TEST_EQUALITY(work_sets->size(), 1);
377
378 // build connection manager and field manager
379 const Teuchos::RCP<panzer::ConnManager> conn_manager = Teuchos::rcp(new panzer_stk::STKConnManager(mesh));
380 RCP<panzer::BlockedDOFManager> dofManager = Teuchos::rcp(new panzer::BlockedDOFManager(conn_manager, MPI_COMM_WORLD));
381
382 dofManager->addField(fieldName1_q1, Teuchos::rcp(new panzer::Intrepid2FieldPattern(basis_q1->getIntrepid2Basis())));
383 dofManager->addField(fieldName2_q1, Teuchos::rcp(new panzer::Intrepid2FieldPattern(basis_q1->getIntrepid2Basis())));
384 dofManager->addField(fieldName_qedge1, Teuchos::rcp(new panzer::Intrepid2FieldPattern(basis_qedge1->getIntrepid2Basis())));
385
386 std::vector<std::vector<std::string>> fieldOrder(3);
387 fieldOrder[0].push_back(fieldName1_q1);
388 fieldOrder[1].push_back(fieldName_qedge1);
389 fieldOrder[2].push_back(fieldName2_q1);
390 dofManager->setFieldOrder(fieldOrder);
391
392 // dofManager->setOrientationsRequired(true);
393 dofManager->buildGlobalUnknowns();
394
395 // setup linear object factory
396 /////////////////////////////////////////////////////////////
397
398 Teuchos::RCP<TpetraBlockedLinObjFactoryType> bt_lof = Teuchos::rcp(new TpetraBlockedLinObjFactoryType(tComm.getConst(), dofManager));
399 Teuchos::RCP<LinearObjFactory<panzer::Traits>> lof = bt_lof;
400 Teuchos::RCP<LinearObjContainer> dd_loc = bt_lof->buildGhostedLinearObjContainer();
401 Teuchos::RCP<LinearObjContainer> loc = bt_lof->buildGhostedLinearObjContainer();
402 bt_lof->initializeGhostedContainer(LinearObjContainer::F, *dd_loc);
403 dd_loc->initialize();
404
405 bt_lof->initializeGhostedContainer(LinearObjContainer::X | LinearObjContainer::F | LinearObjContainer::Mat, *loc);
406 loc->initialize();
407
408 Teuchos::RCP<TpetraBlockedLinObjContainerType> b_dd_loc = Teuchos::rcp_dynamic_cast<TpetraBlockedLinObjContainerType>(dd_loc);
409 Teuchos::RCP<TpetraBlockedLinObjContainerType> b_loc = Teuchos::rcp_dynamic_cast<TpetraBlockedLinObjContainerType>(loc);
410 Teuchos::RCP<Thyra::ProductVectorBase<double>> p_vec = Teuchos::rcp_dynamic_cast<Thyra::ProductVectorBase<double>>(b_loc->get_x());
411 Thyra::assign(p_vec->getNonconstVectorBlock(0).ptr(), 123.0 + myRank);
412 Thyra::assign(p_vec->getNonconstVectorBlock(1).ptr(), 456.0 + myRank);
413 Thyra::assign(p_vec->getNonconstVectorBlock(2).ptr(), 789.0 + myRank);
414
415 auto blk_A = Teuchos::rcp_dynamic_cast<Thyra::BlockedLinearOpBase<double>>(b_loc->get_A());
416 double values[] = {123.0 + myRank, 456.0 + myRank, 789.0 + myRank};
417
418 for (int i = 0; i < 3; i++)
419 for (int j = 0; j < 3; j++)
420 {
421 auto thyraOp = Teuchos::rcp_dynamic_cast<Thyra_TpetraLinearOp>(blk_A->getNonconstBlock(i, j), false);
422 auto tpetraCrsMatrix = Teuchos::rcp_dynamic_cast<Tpetra_CrsMatrix>(thyraOp->getTpetraOperator(), true);
423 tpetraCrsMatrix->setAllToScalar(values[i] * values[j]);
424 }
425
426 // setup field manager, add evaluator under test
427 /////////////////////////////////////////////////////////////
428
429 PHX::FieldManager<panzer::Traits> fm;
430
431 std::string resName = "";
432 Teuchos::RCP<std::map<std::string, std::string>> names_map =
433 Teuchos::rcp(new std::map<std::string, std::string>);
434 names_map->insert(std::make_pair(fieldName1_q1, resName + fieldName1_q1));
435 names_map->insert(std::make_pair(fieldName2_q1, resName + fieldName2_q1));
436 names_map->insert(std::make_pair(fieldName_qedge1, resName + fieldName_qedge1));
437
438 // evaluators under test
439 {
440 using Teuchos::RCP;
441 using Teuchos::rcp;
442 RCP<std::vector<std::string>> names = rcp(new std::vector<std::string>);
443 names->push_back(resName + fieldName1_q1);
444 names->push_back(resName + fieldName2_q1);
445
446 Teuchos::ParameterList pl;
447 pl.set("Scatter Name", "ScatterQ1");
448 pl.set("Basis", basis_q1);
449 pl.set("Dependent Names", names);
450 pl.set("Dependent Map", names_map);
451 pl.set("Side Subcell Dimension", 1);
452 pl.set("Local Side ID", 2);
453 pl.set("Check Apply BC", false);
454
455 Teuchos::RCP<PHX::Evaluator<panzer::Traits>> evaluator = lof->buildScatterDirichlet<panzer::Traits::Jacobian>(pl);
456
457 TEST_EQUALITY(evaluator->evaluatedFields().size(), 1);
458
459 fm.registerEvaluator<panzer::Traits::Jacobian>(evaluator);
460 fm.requireField<panzer::Traits::Jacobian>(*evaluator->evaluatedFields()[0]);
461 }
462 {
463 using Teuchos::RCP;
464 using Teuchos::rcp;
465 RCP<std::vector<std::string>> names = rcp(new std::vector<std::string>);
466 names->push_back(resName + fieldName_qedge1);
467
468 Teuchos::ParameterList pl;
469 pl.set("Scatter Name", "ScatterQEdge1");
470 pl.set("Basis", basis_qedge1);
471 pl.set("Dependent Names", names);
472 pl.set("Dependent Map", names_map);
473 pl.set("Side Subcell Dimension", 1);
474 pl.set("Local Side ID", 2);
475 pl.set("Check Apply BC", false);
476
477 Teuchos::RCP<PHX::Evaluator<panzer::Traits>> evaluator = lof->buildScatterDirichlet<panzer::Traits::Jacobian>(pl);
478
479 TEST_EQUALITY(evaluator->evaluatedFields().size(), 1);
480
481 fm.registerEvaluator<panzer::Traits::Jacobian>(evaluator);
482 fm.requireField<panzer::Traits::Jacobian>(*evaluator->evaluatedFields()[0]);
483 }
484
485 // support evaluators
486 {
487 using Teuchos::RCP;
488 using Teuchos::rcp;
489 RCP<std::vector<std::string>> names = rcp(new std::vector<std::string>);
490 names->push_back(fieldName1_q1);
491 names->push_back(fieldName2_q1);
492
493 Teuchos::ParameterList pl;
494 pl.set("Basis", basis_q1);
495 pl.set("DOF Names", names);
496 pl.set("Indexer Names", names);
497
498 Teuchos::RCP<PHX::Evaluator<panzer::Traits>> evaluator = lof->buildGather<panzer::Traits::Jacobian>(pl);
499
500 fm.registerEvaluator<panzer::Traits::Jacobian>(evaluator);
501 }
502 {
503 using Teuchos::RCP;
504 using Teuchos::rcp;
505 RCP<std::vector<std::string>> names = rcp(new std::vector<std::string>);
506 names->push_back(fieldName_qedge1);
507
508 Teuchos::ParameterList pl;
509 pl.set("Basis", basis_qedge1);
510 pl.set("DOF Names", names);
511 pl.set("Indexer Names", names);
512
513 Teuchos::RCP<PHX::Evaluator<panzer::Traits>> evaluator = lof->buildGather<panzer::Traits::Jacobian>(pl);
514
515 fm.registerEvaluator<panzer::Traits::Jacobian>(evaluator);
516 }
517
518 std::vector<PHX::index_size_type> derivative_dimensions;
519 derivative_dimensions.push_back(12);
520 fm.setKokkosExtendedDataTypeDimensions<panzer::Traits::Jacobian>(derivative_dimensions);
521
522 panzer::Traits::SD sd;
523 sd.worksets_ = work_sets;
524
525 fm.postRegistrationSetup(sd);
526
527 // panzer::Traits::PED ped;
528 // ped.dirichletData.ghostedCounter = dd_loc;
529 // fm.preEvaluate<panzer::Traits::Jacobian>(ped);
530 panzer::Traits::PED ped;
531 ped.gedc->addDataObject("Dirichlet Counter", dd_loc);
532 ped.gedc->addDataObject("Solution Gather Container", loc);
533 ped.gedc->addDataObject("Residual Scatter Container", loc);
534 fm.preEvaluate<panzer::Traits::Jacobian>(ped);
535
536 // run tests
537 /////////////////////////////////////////////////////////////
538
539 panzer::Workset &workset = (*work_sets)[0];
540 workset.alpha = 0.0;
541 workset.beta = 2.0; // derivatives multiplied by 2
542 workset.time = 0.0;
543 workset.evaluate_transient_terms = false;
544
545 fm.evaluateFields<panzer::Traits::Jacobian>(workset);
546
547 // test Residual fields
548 panzer::index_t dd_count(0);
549 Teuchos::ArrayRCP<const double> data, dd_data;
550 Teuchos::RCP<const Thyra::ProductVectorBase<double>> f_vec = Teuchos::rcp_dynamic_cast<Thyra::ProductVectorBase<double>>(b_loc->get_f());
551 Teuchos::RCP<const Thyra::ProductVectorBase<double>> dd_vec = Teuchos::rcp_dynamic_cast<Thyra::ProductVectorBase<double>>(b_dd_loc->get_f());
552
553 // check all the residual values. This is kind of crappy test since it simply checks twice the target
554 // value and the target. Its this way because you add two entries across elements.
555
556 Teuchos::rcp_dynamic_cast<const Thyra::SpmdVectorBase<double>>(f_vec->getVectorBlock(0))->getLocalData(Teuchos::ptrFromRef(data));
557 Teuchos::rcp_dynamic_cast<const Thyra::SpmdVectorBase<double>>(dd_vec->getVectorBlock(0))->getLocalData(Teuchos::ptrFromRef(dd_data));
558 TEST_EQUALITY(static_cast<size_t>(data.size()), b_loc->getMapForBlock(0)->getLocalNumElements());
559 TEST_EQUALITY(data.size(), dd_data.size());
560 dd_count = 0;
561 for (int i = 0; i < data.size(); i++)
562 {
563
564 double target = 123.0 + myRank;
565 if (dd_data[i] == 0.0)
566 {
567 TEST_EQUALITY(data[i], 0.0);
568 }
569 else
570 {
571 TEST_EQUALITY(data[i], target);
572 dd_count++;
573 }
574 }
575 TEST_EQUALITY(dd_count, 2 * workset.num_cells); // there are 2 nodes on the side and the sides are not shared
576
577 Teuchos::rcp_dynamic_cast<const Thyra::SpmdVectorBase<double>>(f_vec->getVectorBlock(1))->getLocalData(Teuchos::ptrFromRef(data));
578 Teuchos::rcp_dynamic_cast<const Thyra::SpmdVectorBase<double>>(dd_vec->getVectorBlock(1))->getLocalData(Teuchos::ptrFromRef(dd_data));
579 TEST_EQUALITY(static_cast<size_t>(data.size()), b_loc->getMapForBlock(1)->getLocalNumElements());
580 TEST_EQUALITY(data.size(), dd_data.size());
581 dd_count = 0;
582 for (int i = 0; i < data.size(); i++)
583 {
584
585 double target = 456.0 + myRank;
586 if (dd_data[i] == 0.0)
587 {
588 TEST_EQUALITY(data[i], 0.0);
589 }
590 else
591 {
592 TEST_EQUALITY(data[i], target);
593 dd_count++;
594 }
595 }
596 TEST_EQUALITY(dd_count, workset.num_cells); // there are 2 nodes on the side and the sides are not shared
597
598 Teuchos::rcp_dynamic_cast<const Thyra::SpmdVectorBase<double>>(f_vec->getVectorBlock(2))->getLocalData(Teuchos::ptrFromRef(data));
599 Teuchos::rcp_dynamic_cast<const Thyra::SpmdVectorBase<double>>(dd_vec->getVectorBlock(2))->getLocalData(Teuchos::ptrFromRef(dd_data));
600 TEST_EQUALITY(static_cast<size_t>(data.size()), b_loc->getMapForBlock(2)->getLocalNumElements());
601 TEST_EQUALITY(data.size(), dd_data.size());
602 dd_count = 0;
603 for (int i = 0; i < data.size(); i++)
604 {
605
606 double target = 789.0 + myRank;
607 if (dd_data[i] == 0.0)
608 {
609 TEST_EQUALITY(data[i], 0.0);
610 }
611 else
612 {
613 TEST_EQUALITY(data[i], target);
614 dd_count++;
615 }
616 }
617 TEST_EQUALITY(dd_count, 2 * workset.num_cells); // there are 2 nodes on the side and the sides are not shared
618 }
619
620 TEUCHOS_UNIT_TEST(block_assembly, scatter_dirichlet_tangent)
621 {
622
623 #ifdef HAVE_MPI
624 Teuchos::RCP<Teuchos::MpiComm<int>> tComm = Teuchos::rcp(new Teuchos::MpiComm<int>(MPI_COMM_WORLD));
625 #else
626 NOPE_PANZER_DOESNT_SUPPORT_SERIAL
627 #endif
628
629 int myRank = tComm->getRank();
630
631 const std::size_t workset_size = 4;
632 const std::string fieldName1_q1 = "U";
633 const std::string fieldName2_q1 = "V";
634 const std::string fieldName_qedge1 = "B";
635 const std::size_t numParams = 2;
636
637 Teuchos::RCP<panzer_stk::STK_Interface> mesh = buildMesh(2, 2);
638
639 // build input physics block
640 Teuchos::RCP<panzer::PureBasis> basis_q1 = buildBasis(workset_size, "Q1");
641 Teuchos::RCP<panzer::PureBasis> basis_qedge1 = buildBasis(workset_size, "QEdge1");
642
643 Teuchos::RCP<Teuchos::ParameterList> ipb = Teuchos::parameterList();
644 testInitialization(ipb);
645
646 const int default_int_order = 1;
647 std::string eBlockID = "eblock-0_0";
648 Teuchos::RCP<user_app::MyFactory> eqset_factory = Teuchos::rcp(new user_app::MyFactory);
649 panzer::CellData cellData(workset_size, mesh->getCellTopology("eblock-0_0"));
650 Teuchos::RCP<panzer::GlobalData> gd = panzer::createGlobalData();
651 Teuchos::RCP<panzer::PhysicsBlock> physicsBlock =
652 Teuchos::rcp(new PhysicsBlock(ipb, eBlockID, default_int_order, cellData, eqset_factory, gd, false));
653
654 Teuchos::RCP<std::vector<panzer::Workset>> work_sets = panzer_stk::buildWorksets(*mesh, physicsBlock->elementBlockID(),
655 physicsBlock->getWorksetNeeds());
656 TEST_EQUALITY(work_sets->size(), 1);
657
658 std::vector<bool> scatter_IC_vec = {false,true};
659
660 for (const bool scatter_IC : scatter_IC_vec) {
661 // build connection manager and field manager
662 const Teuchos::RCP<panzer::ConnManager> conn_manager = Teuchos::rcp(new panzer_stk::STKConnManager(mesh));
663 RCP<panzer::BlockedDOFManager> dofManager = Teuchos::rcp(new panzer::BlockedDOFManager(conn_manager, MPI_COMM_WORLD));
664
665 dofManager->addField(fieldName1_q1, Teuchos::rcp(new panzer::Intrepid2FieldPattern(basis_q1->getIntrepid2Basis())));
666 dofManager->addField(fieldName2_q1, Teuchos::rcp(new panzer::Intrepid2FieldPattern(basis_q1->getIntrepid2Basis())));
667 dofManager->addField(fieldName_qedge1, Teuchos::rcp(new panzer::Intrepid2FieldPattern(basis_qedge1->getIntrepid2Basis())));
668
669 std::vector<std::vector<std::string>> fieldOrder(3);
670 fieldOrder[0].push_back(fieldName1_q1);
671 fieldOrder[1].push_back(fieldName_qedge1);
672 fieldOrder[2].push_back(fieldName2_q1);
673 dofManager->setFieldOrder(fieldOrder);
674
675 // dofManager->setOrientationsRequired(true);
676 dofManager->buildGlobalUnknowns();
677
678 // setup linear object factory
679 /////////////////////////////////////////////////////////////
680
681 Teuchos::RCP<TpetraBlockedLinObjFactoryType> bt_lof = Teuchos::rcp(new TpetraBlockedLinObjFactoryType(tComm.getConst(), dofManager));
682 Teuchos::RCP<LinearObjFactory<panzer::Traits>> lof = bt_lof;
683 Teuchos::RCP<LinearObjContainer> dd_loc = bt_lof->buildGhostedLinearObjContainer();
684 Teuchos::RCP<LinearObjContainer> loc = bt_lof->buildGhostedLinearObjContainer();
685 bt_lof->initializeGhostedContainer(LinearObjContainer::F, *dd_loc);
686 dd_loc->initialize();
687
688 bt_lof->initializeGhostedContainer(LinearObjContainer::X | LinearObjContainer::F, *loc);
689 loc->initialize();
690
691 Teuchos::RCP<TpetraBlockedLinObjContainerType> b_dd_loc = Teuchos::rcp_dynamic_cast<TpetraBlockedLinObjContainerType>(dd_loc);
692 Teuchos::RCP<TpetraBlockedLinObjContainerType> b_loc = Teuchos::rcp_dynamic_cast<TpetraBlockedLinObjContainerType>(loc);
693 Teuchos::RCP<Thyra::ProductVectorBase<double>> p_vec = Teuchos::rcp_dynamic_cast<Thyra::ProductVectorBase<double>>(b_loc->get_x());
694 Thyra::assign(p_vec->getNonconstVectorBlock(0).ptr(), 123.0 + myRank);
695 Thyra::assign(p_vec->getNonconstVectorBlock(1).ptr(), 456.0 + myRank);
696 Thyra::assign(p_vec->getNonconstVectorBlock(2).ptr(), 789.0 + myRank);
697
698 std::vector<Teuchos::RCP<GlobalEvaluationData>> tangentContainers;
699
700 using LOCPair = panzer::LOCPair_GlobalEvaluationData;
701 using Teuchos::rcp_dynamic_cast;
702
703 // generate tangent data
704 for (std::size_t i=0;i<numParams; ++i){
705 auto locPair = Teuchos::rcp(new LOCPair(bt_lof, panzer::LinearObjContainer::X));
706
707 auto global_bt_loc = rcp_dynamic_cast<TpetraBlockedLinObjContainerType>(locPair->getGlobalLOC());
708 Teuchos::RCP<Thyra::ProductVectorBase<double>> global_p_vec = Teuchos::rcp_dynamic_cast<Thyra::ProductVectorBase<double>>(global_bt_loc->get_x());
709 Thyra::assign(global_p_vec->getNonconstVectorBlock(0).ptr(), 0.123 + myRank + i);
710 Thyra::assign(global_p_vec->getNonconstVectorBlock(1).ptr(), 0.456 + myRank + i);
711 Thyra::assign(global_p_vec->getNonconstVectorBlock(2).ptr(), 0.789 + myRank + i);
712
713 auto ghosted_bt_loc = rcp_dynamic_cast<TpetraBlockedLinObjContainerType>(locPair->getGhostedLOC());
714 Teuchos::RCP<Thyra::ProductVectorBase<double>> ghosted_p_vec = Teuchos::rcp_dynamic_cast<Thyra::ProductVectorBase<double>>(ghosted_bt_loc->get_x());
715 Thyra::assign(ghosted_p_vec->getNonconstVectorBlock(0).ptr(), 0.123 + myRank + i);
716 Thyra::assign(ghosted_p_vec->getNonconstVectorBlock(1).ptr(), 0.456 + myRank + i);
717 Thyra::assign(ghosted_p_vec->getNonconstVectorBlock(2).ptr(), 0.789 + myRank + i);
718
719 tangentContainers.push_back(locPair);
720 }
721
722 // setup field manager, add evaluator under test
723 /////////////////////////////////////////////////////////////
724
725 auto fm = Teuchos::rcp(new PHX::FieldManager<panzer::Traits>);
726
727 std::vector<PHX::index_size_type> derivative_dimensions;
728 derivative_dimensions.push_back(numParams);
729 fm->setKokkosExtendedDataTypeDimensions<panzer::Traits::Tangent>(derivative_dimensions);
730
731 std::string resName = "";
732 Teuchos::RCP<std::map<std::string, std::string>> names_map =
733 Teuchos::rcp(new std::map<std::string, std::string>);
734 names_map->insert(std::make_pair(fieldName1_q1, resName + fieldName1_q1));
735 names_map->insert(std::make_pair(fieldName2_q1, resName + fieldName2_q1));
736 names_map->insert(std::make_pair(fieldName_qedge1, resName + fieldName_qedge1));
737
738 // evaluators under test
739 {
740 using Teuchos::RCP;
741 using Teuchos::rcp;
742 RCP<std::vector<std::string>> names = rcp(new std::vector<std::string>);
743 names->push_back(resName + fieldName1_q1);
744 names->push_back(resName + fieldName2_q1);
745
746 Teuchos::ParameterList pl;
747 pl.set("Scatter Name", "ScatterQ1");
748 if (scatter_IC) {
749 pl.set("Basis", basis_q1.getConst());
750 } else {
751 pl.set("Basis", basis_q1);
752 }
753 pl.set("Dependent Names", names);
754 pl.set("Dependent Map", names_map);
755 pl.set("Side Subcell Dimension", 1);
756 pl.set("Local Side ID", 2);
757 pl.set("Check Apply BC", false);
758 pl.set("Scatter Initial Condition", scatter_IC);
759
760 Teuchos::RCP<PHX::Evaluator<panzer::Traits>> evaluator = lof->buildScatterDirichlet<panzer::Traits::Tangent>(pl);
761
762 TEST_EQUALITY(evaluator->evaluatedFields().size(), 1);
763
764 fm->registerEvaluator<panzer::Traits::Tangent>(evaluator);
765 fm->requireField<panzer::Traits::Tangent>(*evaluator->evaluatedFields()[0]);
766 }
767 {
768 using Teuchos::RCP;
769 using Teuchos::rcp;
770 RCP<std::vector<std::string>> names = rcp(new std::vector<std::string>);
771 names->push_back(resName + fieldName_qedge1);
772
773 Teuchos::ParameterList pl;
774 pl.set("Scatter Name", "ScatterQEdge1");
775 if (scatter_IC) {
776 pl.set("Basis", basis_qedge1.getConst());
777 } else {
778 pl.set("Basis", basis_qedge1);
779 }
780 pl.set("Dependent Names", names);
781 pl.set("Dependent Map", names_map);
782 pl.set("Side Subcell Dimension", 1);
783 pl.set("Local Side ID", 2);
784 pl.set("Check Apply BC", false);
785 pl.set("Scatter Initial Condition", scatter_IC);
786
787 Teuchos::RCP<PHX::Evaluator<panzer::Traits>> evaluator = lof->buildScatterDirichlet<panzer::Traits::Tangent>(pl);
788
789 TEST_EQUALITY(evaluator->evaluatedFields().size(), 1);
790
791 fm->registerEvaluator<panzer::Traits::Tangent>(evaluator);
792 fm->requireField<panzer::Traits::Tangent>(*evaluator->evaluatedFields()[0]);
793 }
794
795 // support evaluators
796 {
797 using Teuchos::RCP;
798 using Teuchos::rcp;
799 RCP<std::vector<std::string>> names = rcp(new std::vector<std::string>);
800 names->push_back(fieldName1_q1);
801 names->push_back(fieldName2_q1);
802
803 Teuchos::ParameterList pl;
804 pl.set("Basis", basis_q1);
805 pl.set("DOF Names", names);
806 pl.set("Indexer Names", names);
807 Teuchos::RCP<std::vector<std::vector<std::string>>> tangent_names =
808 Teuchos::rcp(new std::vector<std::vector<std::string>>(2));
809 for (std::size_t i = 0; i < numParams; ++i)
810 {
811 std::stringstream ss1, ss2;
812 ss1 << fieldName1_q1 << " Tangent " << i;
813 ss2 << fieldName2_q1 << " Tangent " << i;
814 (*tangent_names)[0].push_back(ss1.str());
815 (*tangent_names)[1].push_back(ss2.str());
816 }
817 pl.set("Tangent Names", tangent_names);
818
819 Teuchos::RCP<PHX::Evaluator<panzer::Traits>> evaluator = lof->buildGather<panzer::Traits::Tangent>(pl);
820
821 fm->registerEvaluator<panzer::Traits::Tangent>(evaluator);
822 }
823 for (std::size_t i = 0; i < numParams; ++i) {
824 using Teuchos::RCP;
825 using Teuchos::rcp;
826 RCP<std::vector<std::string>> names = rcp(new std::vector<std::string>);
827 RCP<std::vector<std::string>> tangent_names = rcp(new std::vector<std::string>);
828 names->push_back(fieldName1_q1);
829 names->push_back(fieldName2_q1);
830 {
831 std::stringstream ss1, ss2;
832 ss1 << fieldName1_q1 << " Tangent " << i;
833 ss2 << fieldName2_q1 << " Tangent " << i;
834 tangent_names->push_back(ss1.str());
835 tangent_names->push_back(ss2.str());
836 }
837
838 Teuchos::ParameterList pl;
839 pl.set("Basis", basis_q1);
840 pl.set("DOF Names", tangent_names);
841 pl.set("Indexer Names", names);
842
843 std::stringstream ss;
844 ss << "Tangent Container " << i;
845 pl.set("Global Data Key", ss.str());
846
847 Teuchos::RCP<PHX::Evaluator<panzer::Traits>> evaluator =
848 lof->buildGatherTangent<panzer::Traits::Tangent>(pl);
849
850 fm->registerEvaluator<panzer::Traits::Tangent>(evaluator);
851 }
852 {
853 using Teuchos::RCP;
854 using Teuchos::rcp;
855 RCP<std::vector<std::string>> names = rcp(new std::vector<std::string>);
856 names->push_back(fieldName_qedge1);
857
858 Teuchos::ParameterList pl;
859 pl.set("Basis", basis_qedge1);
860 pl.set("DOF Names", names);
861 pl.set("Indexer Names", names);
862 Teuchos::RCP<std::vector<std::vector<std::string>>> tangent_names =
863 Teuchos::rcp(new std::vector<std::vector<std::string>>(1));
864 for (std::size_t i = 0; i < numParams; ++i)
865 {
866 std::stringstream ss;
867 ss << fieldName_qedge1 << " Tangent " << i;
868 (*tangent_names)[0].push_back(ss.str());
869 }
870 pl.set("Tangent Names", tangent_names);
871
872 Teuchos::RCP<PHX::Evaluator<panzer::Traits>> evaluator = lof->buildGather<panzer::Traits::Tangent>(pl);
873
874 fm->registerEvaluator<panzer::Traits::Tangent>(evaluator);
875 }
876 for (std::size_t i = 0; i < numParams; ++i) {
877 using Teuchos::RCP;
878 using Teuchos::rcp;
879 RCP<std::vector<std::string>> names = rcp(new std::vector<std::string>);
880 RCP<std::vector<std::string>> tangent_names = rcp(new std::vector<std::string>);
881 names->push_back(fieldName_qedge1);
882 {
883 std::stringstream ss;
884 ss << fieldName_qedge1 << " Tangent " << i;
885 tangent_names->push_back(ss.str());
886 }
887
888 Teuchos::ParameterList pl;
889 pl.set("Basis", basis_qedge1);
890 pl.set("DOF Names", tangent_names);
891 pl.set("Indexer Names", names);
892
893 std::stringstream ss;
894 ss << "Tangent Container " << i;
895 pl.set("Global Data Key", ss.str());
896
897 Teuchos::RCP<PHX::Evaluator<panzer::Traits>> evaluator =
898 lof->buildGatherTangent<panzer::Traits::Tangent>(pl);
899
900 fm->registerEvaluator<panzer::Traits::Tangent>(evaluator);
901 }
902
903 panzer::Traits::SD sd;
904 sd.worksets_ = work_sets;
905
906 fm->postRegistrationSetup(sd);
907
908 panzer::Traits::PED ped;
909 ped.gedc->addDataObject("Dirichlet Counter", dd_loc);
910 ped.gedc->addDataObject("Solution Gather Container", loc);
911 ped.gedc->addDataObject("Residual Scatter Container", loc);
912 for (size_t i=0; i<numParams; ++i) {
913 std::stringstream ss;
914 ss << "Tangent Container " << i;
915 ped.gedc->addDataObject(ss.str(), tangentContainers[i]);
916 }
917 std::vector<std::string> params;
918 std::vector<Teuchos::RCP<LOCPair>> paramContainers;
919 for (std::size_t i = 0; i<numParams; ++i) {
920 std::stringstream ss;
921 ss << "param" << i;
922 params.push_back(ss.str());
923 auto paramContainer = Teuchos::rcp(new LOCPair(bt_lof, panzer::LinearObjContainer::X | panzer::LinearObjContainer::F));
924 ped.gedc->addDataObject(ss.str(),paramContainer->getGhostedLOC());
925 paramContainers.push_back(paramContainer);
926 }
927 Teuchos::RCP<panzer::GlobalEvaluationData> activeParams =
928 Teuchos::rcp(new panzer::ParameterList_GlobalEvaluationData(params));
929 ped.gedc->addDataObject("PARAMETER_NAMES",activeParams);
930
931 fm->preEvaluate<panzer::Traits::Tangent>(ped);
932
933 // run tests
934 /////////////////////////////////////////////////////////////
935
936 panzer::Workset &workset = (*work_sets)[0];
937 workset.alpha = 0.0;
938 workset.beta = 2.0; // derivatives multiplied by 2
939 workset.time = 0.0;
940 workset.evaluate_transient_terms = false;
941
942 fm->evaluateFields<panzer::Traits::Tangent>(workset);
943
944 fm = Teuchos::null;
945
946 // test Residual fields
947 panzer::index_t dd_count(0);
948 Teuchos::ArrayRCP<const double> data, dd_data;
949 Teuchos::RCP<const Thyra::ProductVectorBase<double>> x_vec = Teuchos::rcp_dynamic_cast<Thyra::ProductVectorBase<double>>(b_loc->get_x());
950 Teuchos::RCP<const Thyra::ProductVectorBase<double>> f_vec = Teuchos::rcp_dynamic_cast<Thyra::ProductVectorBase<double>>(b_loc->get_f());
951 Teuchos::RCP<const Thyra::ProductVectorBase<double>> dd_vec = Teuchos::rcp_dynamic_cast<Thyra::ProductVectorBase<double>>(b_dd_loc->get_f());
952
953 // check all the residual values.
954
955 if (scatter_IC) {
956 Teuchos::rcp_dynamic_cast<const Thyra::SpmdVectorBase<double>>(x_vec->getVectorBlock(0))->getLocalData(Teuchos::ptrFromRef(data));
957 } else {
958 Teuchos::rcp_dynamic_cast<const Thyra::SpmdVectorBase<double>>(f_vec->getVectorBlock(0))->getLocalData(Teuchos::ptrFromRef(data));
959 }
960 Teuchos::rcp_dynamic_cast<const Thyra::SpmdVectorBase<double>>(dd_vec->getVectorBlock(0))->getLocalData(Teuchos::ptrFromRef(dd_data));
961 TEST_EQUALITY(static_cast<size_t>(data.size()), b_loc->getMapForBlock(0)->getLocalNumElements());
962 TEST_EQUALITY(data.size(), dd_data.size());
963 dd_count = 0;
964 for (int i = 0; i < data.size(); i++)
965 {
966
967 double target = 123.0 + myRank;
968 if (dd_data[i] == 0.0)
969 {
970 TEST_EQUALITY(data[i], 0.0);
971 }
972 else
973 {
974 TEST_EQUALITY(data[i], target);
975 dd_count++;
976 }
977 }
978 if (scatter_IC) {
979 TEST_EQUALITY(dd_count, data.size()); // filled everywhere
980 } else {
981 TEST_EQUALITY(dd_count, 2 * workset.num_cells); // there are 2 nodes on the side and the sides are not shared
982 }
983
984 if (scatter_IC) {
985 Teuchos::rcp_dynamic_cast<const Thyra::SpmdVectorBase<double>>(x_vec->getVectorBlock(1))->getLocalData(Teuchos::ptrFromRef(data));
986 } else {
987 Teuchos::rcp_dynamic_cast<const Thyra::SpmdVectorBase<double>>(f_vec->getVectorBlock(1))->getLocalData(Teuchos::ptrFromRef(data));
988 }
989 Teuchos::rcp_dynamic_cast<const Thyra::SpmdVectorBase<double>>(dd_vec->getVectorBlock(1))->getLocalData(Teuchos::ptrFromRef(dd_data));
990 TEST_EQUALITY(static_cast<size_t>(data.size()), b_loc->getMapForBlock(1)->getLocalNumElements());
991 TEST_EQUALITY(data.size(), dd_data.size());
992 dd_count = 0;
993 for (int i = 0; i < data.size(); i++)
994 {
995
996 double target = 456.0 + myRank;
997 if (dd_data[i] == 0.0)
998 {
999 TEST_EQUALITY(data[i], 0.0);
1000 }
1001 else
1002 {
1003 TEST_EQUALITY(data[i], target);
1004 dd_count++;
1005 }
1006 }
1007 if (scatter_IC) {
1008 TEST_EQUALITY(dd_count, data.size()); // filled everywhere
1009 } else {
1010 TEST_EQUALITY(dd_count, workset.num_cells); // there are 1 edge on the side and the sides are not shared
1011 }
1012
1013 if (scatter_IC) {
1014 Teuchos::rcp_dynamic_cast<const Thyra::SpmdVectorBase<double>>(x_vec->getVectorBlock(2))->getLocalData(Teuchos::ptrFromRef(data));
1015 } else {
1016 Teuchos::rcp_dynamic_cast<const Thyra::SpmdVectorBase<double>>(f_vec->getVectorBlock(2))->getLocalData(Teuchos::ptrFromRef(data));
1017 }
1018 Teuchos::rcp_dynamic_cast<const Thyra::SpmdVectorBase<double>>(dd_vec->getVectorBlock(2))->getLocalData(Teuchos::ptrFromRef(dd_data));
1019 TEST_EQUALITY(static_cast<size_t>(data.size()), b_loc->getMapForBlock(2)->getLocalNumElements());
1020 TEST_EQUALITY(data.size(), dd_data.size());
1021 dd_count = 0;
1022 for (int i = 0; i < data.size(); i++)
1023 {
1024
1025 double target = 789.0 + myRank;
1026 if (dd_data[i] == 0.0)
1027 {
1028 TEST_EQUALITY(data[i], 0.0);
1029 }
1030 else
1031 {
1032 TEST_EQUALITY(data[i], target);
1033 dd_count++;
1034 }
1035 }
1036 if (scatter_IC) {
1037 TEST_EQUALITY(dd_count, data.size()); // filled everywhere
1038 } else {
1039 TEST_EQUALITY(dd_count, 2 * workset.num_cells); // there are 2 nodes on the side and the sides are not shared
1040 }
1041
1042 // now test tangents
1043 for (std::size_t i=0; i<numParams; ++i) {
1044 Teuchos::RCP<const Thyra::ProductVectorBase<double>> param_f_vec =
1045 Teuchos::rcp_dynamic_cast<Thyra::ProductVectorBase<double>>(
1046 Teuchos::rcp_dynamic_cast<TpetraBlockedLinObjContainerType>(paramContainers[i]->getGhostedLOC())->get_f());
1047
1048 Teuchos::rcp_dynamic_cast<const Thyra::SpmdVectorBase<double>>(param_f_vec->getVectorBlock(0))->getLocalData(Teuchos::ptrFromRef(data));
1049 Teuchos::rcp_dynamic_cast<const Thyra::SpmdVectorBase<double>>(dd_vec->getVectorBlock(0))->getLocalData(Teuchos::ptrFromRef(dd_data));
1050 TEST_EQUALITY(static_cast<size_t>(data.size()), b_loc->getMapForBlock(0)->getLocalNumElements());
1051 for (size_type j = 0; j < data.size(); j++)
1052 {
1053 double target = .123 + myRank + i;
1054 if (dd_data[j] == 0.0)
1055 {
1056 TEST_EQUALITY(data[j],0.0);
1057 }
1058 else
1059 {
1060 TEST_EQUALITY(data[j],target);
1061 }
1062 }
1063 Teuchos::rcp_dynamic_cast<const Thyra::SpmdVectorBase<double>>(param_f_vec->getVectorBlock(1))->getLocalData(Teuchos::ptrFromRef(data));
1064 Teuchos::rcp_dynamic_cast<const Thyra::SpmdVectorBase<double>>(dd_vec->getVectorBlock(1))->getLocalData(Teuchos::ptrFromRef(dd_data));
1065 TEST_EQUALITY(static_cast<size_t>(data.size()), b_loc->getMapForBlock(1)->getLocalNumElements());
1066 for (size_type j = 0; j < data.size(); j++)
1067 {
1068 double target = .456 + myRank + i;
1069 if (dd_data[j] == 0.0)
1070 {
1071 TEST_EQUALITY(data[j],0.0);
1072 }
1073 else
1074 {
1075 TEST_EQUALITY(data[j],target);
1076 }
1077 }
1078 Teuchos::rcp_dynamic_cast<const Thyra::SpmdVectorBase<double>>(param_f_vec->getVectorBlock(2))->getLocalData(Teuchos::ptrFromRef(data));
1079 Teuchos::rcp_dynamic_cast<const Thyra::SpmdVectorBase<double>>(dd_vec->getVectorBlock(2))->getLocalData(Teuchos::ptrFromRef(dd_data));
1080 TEST_EQUALITY(static_cast<size_t>(data.size()), b_loc->getMapForBlock(2)->getLocalNumElements());
1081 for (size_type j = 0; j < data.size(); j++)
1082 {
1083 double target = .789 + myRank + i;
1084 if (dd_data[j] == 0.0)
1085 {
1086 TEST_EQUALITY(data[j],0.0);
1087 }
1088 else
1089 {
1090 TEST_EQUALITY(data[j],target);
1091 }
1092 }
1093 }
1094 }
1095 }
1096 Teuchos::RCP<panzer::PureBasis> buildBasis(std::size_t worksetSize, const std::string &basisName)
1097 {
1098 Teuchos::RCP<shards::CellTopology> topo =
1099 Teuchos::rcp(new shards::CellTopology(shards::getCellTopologyData<shards::Quadrilateral<4>>()));
1100
1101 panzer::CellData cellData(worksetSize, topo);
1102 return Teuchos::rcp(new panzer::PureBasis(basisName, 1, cellData));
1103 }
1104
1105 Teuchos::RCP<panzer_stk::STK_Interface> buildMesh(int elemX, int elemY)
1106 {
1107 RCP<Teuchos::ParameterList> pl = rcp(new Teuchos::ParameterList);
1108 pl->set("X Blocks", 1);
1109 pl->set("Y Blocks", 1);
1110 pl->set("X Elements", elemX);
1111 pl->set("Y Elements", elemY);
1112
1113 panzer_stk::SquareQuadMeshFactory factory;
1114 factory.setParameterList(pl);
1115 RCP<panzer_stk::STK_Interface> mesh = factory.buildUncommitedMesh(MPI_COMM_WORLD);
1116 factory.completeMeshConstruction(*mesh, MPI_COMM_WORLD);
1117
1118 return mesh;
1119 }
1120
1121 void testInitialization(const Teuchos::RCP<Teuchos::ParameterList> &ipb)
1122 {
1123 // Physics block
1124 ipb->setName("test physics");
1125 {
1126 Teuchos::ParameterList &p = ipb->sublist("a");
1127 p.set("Type", "Energy");
1128 p.set("Prefix", "");
1129 p.set("Model ID", "solid");
1130 p.set("Basis Type", "HGrad");
1131 p.set("Basis Order", 1);
1132 p.set("Integration Order", 1);
1133 }
1134 {
1135 Teuchos::ParameterList &p = ipb->sublist("b");
1136 p.set("Type", "Energy");
1137 p.set("Prefix", "ION_");
1138 p.set("Model ID", "solid");
1139 p.set("Basis Type", "HCurl");
1140 p.set("Basis Order", 1);
1141 p.set("Integration Order", 1);
1142 }
1143 }
1144
1145 }