Debian Codegraph @

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