Debian Codegraph @

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

raw
1 // @HEADER
2 // *****************************************************************************
3 // Panzer: A partial differential equation assembly
4 // engine for strongly coupled complex multiphysics systems
5 //
6 // Copyright 2011 NTESS and the Panzer contributors.
7 // SPDX-License-Identifier: BSD-3-Clause
8 // *****************************************************************************
9 // @HEADER
10
11 #include <Teuchos_ConfigDefs.hpp>
12 #include <Teuchos_UnitTestHarness.hpp>
13 #include <Teuchos_RCP.hpp>
14 #include <Teuchos_TimeMonitor.hpp>
15
16 using Teuchos::RCP;
17 using Teuchos::rcp;
18
19 #include "Teuchos_DefaultComm.hpp"
20 #include "Teuchos_GlobalMPISession.hpp"
21
22 #include "Panzer_FieldManagerBuilder.hpp"
23 #include "Panzer_BlockedDOFManager.hpp"
24 #include "Panzer_BlockedEpetraLinearObjFactory.hpp"
25 #include "Panzer_PureBasis.hpp"
26 #include "Panzer_BasisIRLayout.hpp"
27 #include "Panzer_Workset.hpp"
28 #include "Panzer_GatherOrientation.hpp"
29 #include "Panzer_ScatterResidual_BlockedEpetra.hpp"
30 #include "Panzer_GatherSolution_BlockedEpetra.hpp"
31 #include "Panzer_GlobalEvaluationDataContainer.hpp"
32
33 #include "Panzer_STK_Version.hpp"
34 #include "PanzerAdaptersSTK_config.hpp"
35 #include "Panzer_STK_Interface.hpp"
36 #include "Panzer_STK_SquareQuadMeshFactory.hpp"
37 #include "Panzer_STK_SetupUtilities.hpp"
38 #include "Panzer_STKConnManager.hpp"
39
40 #include "Teuchos_DefaultMpiComm.hpp"
41 #include "Teuchos_OpaqueWrapper.hpp"
42
43 #include "Thyra_VectorStdOps.hpp"
44 #include "Thyra_ProductVectorBase.hpp"
45 #include "Thyra_SpmdVectorBase.hpp"
46
47 #include "user_app_EquationSetFactory.hpp"
48
49 #include <cstdio> // for get char
50 #include <vector>
51 #include <string>
52
53 #include "Panzer_Evaluator_WithBaseImpl.hpp"
54
55 namespace panzer {
56 typedef Teuchos::ArrayRCP<const double>::size_type size_type;
57
58 Teuchos::RCP<panzer::PureBasis> buildBasis(std::size_t worksetSize,const std::string & basisName);
59 void testInitialization(const Teuchos::RCP<Teuchos::ParameterList>& ipb);
60 Teuchos::RCP<panzer_stk::STK_Interface> buildMesh(int elemX,int elemY);
61
62 TEUCHOS_UNIT_TEST(block_assembly, scatter_solution_residual)
63 {
64
65 #ifdef HAVE_MPI
66 Teuchos::RCP<Teuchos::MpiComm<int> > tComm = Teuchos::rcp(new Teuchos::MpiComm<int>(MPI_COMM_WORLD));
67 #else
68 NOPE_PANZER_DOESNT_SUPPORT_SERIAL
69 #endif
70
71 int myRank = tComm->getRank();
72
73 const std::size_t workset_size = 4;
74 const std::string fieldName1_q1 = "U";
75 const std::string fieldName2_q1 = "V";
76 const std::string fieldName_qedge1 = "B";
77
78 Teuchos::RCP<panzer_stk::STK_Interface> mesh = buildMesh(2,2);
79
80 // build input physics block
81 Teuchos::RCP<panzer::PureBasis> basis_q1 = buildBasis(workset_size,"Q1");
82 Teuchos::RCP<panzer::PureBasis> basis_qedge1 = buildBasis(workset_size,"QEdge1");
83
84 Teuchos::RCP<Teuchos::ParameterList> ipb = Teuchos::parameterList();
85 testInitialization(ipb);
86
87 const int default_int_order = 1;
88 std::string eBlockID = "eblock-0_0";
89 Teuchos::RCP<user_app::MyFactory> eqset_factory = Teuchos::rcp(new user_app::MyFactory);
90 panzer::CellData cellData(workset_size,mesh->getCellTopology("eblock-0_0"));
91 Teuchos::RCP<panzer::GlobalData> gd = panzer::createGlobalData();
92 Teuchos::RCP<panzer::PhysicsBlock> physicsBlock =
93 Teuchos::rcp(new PhysicsBlock(ipb,eBlockID,default_int_order,cellData,eqset_factory,gd,false));
94
95 Teuchos::RCP<std::vector<panzer::Workset> > work_sets = panzer_stk::buildWorksets(*mesh,physicsBlock->elementBlockID(),
96 physicsBlock->getWorksetNeeds());
97 TEST_EQUALITY(work_sets->size(),1);
98
99 // build connection manager and field manager
100 const Teuchos::RCP<panzer::ConnManager> conn_manager = Teuchos::rcp(new panzer_stk::STKConnManager(mesh));
101 RCP<panzer::BlockedDOFManager> dofManager = Teuchos::rcp(new panzer::BlockedDOFManager(conn_manager,MPI_COMM_WORLD));
102
103 dofManager->addField(fieldName1_q1,Teuchos::rcp(new panzer::Intrepid2FieldPattern(basis_q1->getIntrepid2Basis())));
104 dofManager->addField(fieldName2_q1,Teuchos::rcp(new panzer::Intrepid2FieldPattern(basis_q1->getIntrepid2Basis())));
105 dofManager->addField(fieldName_qedge1,Teuchos::rcp(new panzer::Intrepid2FieldPattern(basis_qedge1->getIntrepid2Basis())));
106
107 std::vector<std::vector<std::string> > fieldOrder(3);
108 fieldOrder[0].push_back(fieldName1_q1);
109 fieldOrder[1].push_back(fieldName_qedge1);
110 fieldOrder[2].push_back(fieldName2_q1);
111 dofManager->setFieldOrder(fieldOrder);
112
113 // dofManager->setOrientationsRequired(true);
114 dofManager->buildGlobalUnknowns();
115
116 // setup linear object factory
117 /////////////////////////////////////////////////////////////
118
119 Teuchos::RCP<BlockedEpetraLinearObjFactory<panzer::Traits,int> > be_lof
120 = Teuchos::rcp(new BlockedEpetraLinearObjFactory<panzer::Traits,int>(tComm.getConst(),dofManager));
121 Teuchos::RCP<LinearObjFactory<panzer::Traits> > lof = be_lof;
122 Teuchos::RCP<LinearObjContainer> loc = be_lof->buildGhostedLinearObjContainer();
123 be_lof->initializeGhostedContainer(LinearObjContainer::X | LinearObjContainer::F,*loc);
124 loc->initialize();
125
126 Teuchos::RCP<BlockedEpetraLinearObjContainer> b_loc
127 = Teuchos::rcp_dynamic_cast<BlockedEpetraLinearObjContainer>(loc);
128 Teuchos::RCP<Thyra::ProductVectorBase<double> > p_vec = Teuchos::rcp_dynamic_cast<Thyra::ProductVectorBase<double> >(b_loc->get_x());
129 Thyra::assign(p_vec->getNonconstVectorBlock(0).ptr(),123.0+myRank);
130 Thyra::assign(p_vec->getNonconstVectorBlock(1).ptr(),456.0+myRank);
131 Thyra::assign(p_vec->getNonconstVectorBlock(2).ptr(),789.0+myRank);
132
133 // setup field manager, add evaluator under test
134 /////////////////////////////////////////////////////////////
135
136 PHX::FieldManager<panzer::Traits> fm;
137
138 std::string resName = "";
139 Teuchos::RCP<std::map<std::string,std::string> > names_map =
140 Teuchos::rcp(new std::map<std::string,std::string>);
141 names_map->insert(std::make_pair(fieldName1_q1,resName+fieldName1_q1));
142 names_map->insert(std::make_pair(fieldName2_q1,resName+fieldName2_q1));
143 names_map->insert(std::make_pair(fieldName_qedge1,resName+fieldName_qedge1));
144
145 // evaluators under test
146 {
147 using Teuchos::RCP;
148 using Teuchos::rcp;
149 RCP<std::vector<std::string> > names = rcp(new std::vector<std::string>);
150 names->push_back(resName+fieldName1_q1);
151 names->push_back(resName+fieldName2_q1);
152
153 Teuchos::ParameterList pl;
154 pl.set("Scatter Name", "ScatterQ1");
155 pl.set("Basis", basis_q1.getConst());
156 pl.set("Dependent Names", names);
157 pl.set("Dependent Map", names_map);
158
159 Teuchos::RCP<PHX::Evaluator<panzer::Traits> > evaluator = lof->buildScatter<panzer::Traits::Residual>(pl);
160
161 TEST_EQUALITY(evaluator->evaluatedFields().size(),1);
162
163 fm.registerEvaluator<panzer::Traits::Residual>(evaluator);
164 fm.requireField<panzer::Traits::Residual>(*evaluator->evaluatedFields()[0]);
165 }
166 {
167 using Teuchos::RCP;
168 using Teuchos::rcp;
169 RCP<std::vector<std::string> > names = rcp(new std::vector<std::string>);
170 names->push_back(resName+fieldName_qedge1);
171
172 Teuchos::ParameterList pl;
173 pl.set("Scatter Name", "ScatterQEdge1");
174 pl.set("Basis", basis_qedge1.getConst());
175 pl.set("Dependent Names", names);
176 pl.set("Dependent Map", names_map);
177
178 Teuchos::RCP<PHX::Evaluator<panzer::Traits> > evaluator = lof->buildScatter<panzer::Traits::Residual>(pl);
179
180 TEST_EQUALITY(evaluator->evaluatedFields().size(),1);
181
182 fm.registerEvaluator<panzer::Traits::Residual>(evaluator);
183 fm.requireField<panzer::Traits::Residual>(*evaluator->evaluatedFields()[0]);
184 }
185
186 // support evaluators
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(fieldName1_q1);
192 names->push_back(fieldName2_q1);
193
194 Teuchos::ParameterList pl;
195 pl.set("Basis", basis_q1);
196 pl.set("DOF Names",names);
197 pl.set("Indexer Names",names);
198
199 Teuchos::RCP<PHX::Evaluator<panzer::Traits> > evaluator = lof->buildGather<panzer::Traits::Residual>(pl);
200
201 fm.registerEvaluator<panzer::Traits::Residual>(evaluator);
202 }
203 {
204 using Teuchos::RCP;
205 using Teuchos::rcp;
206 RCP<std::vector<std::string> > names = rcp(new std::vector<std::string>);
207 names->push_back(fieldName_qedge1);
208
209 Teuchos::ParameterList pl;
210 pl.set("Basis", basis_qedge1);
211 pl.set("DOF Names",names);
212 pl.set("Indexer Names",names);
213
214 Teuchos::RCP<PHX::Evaluator<panzer::Traits> > evaluator = lof->buildGather<panzer::Traits::Residual>(pl);
215
216 fm.registerEvaluator<panzer::Traits::Residual>(evaluator);
217 }
218
219 std::vector<PHX::index_size_type> derivative_dimensions;
220 derivative_dimensions.push_back(12);
221 fm.setKokkosExtendedDataTypeDimensions<panzer::Traits::Jacobian>(derivative_dimensions);
222
223 panzer::Traits::SD sd;
224 fm.postRegistrationSetup(sd);
225
226 panzer::Traits::PED ped;
227 ped.gedc->addDataObject("Solution Gather Container",loc);
228 ped.gedc->addDataObject("Residual Scatter Container",loc);
229 fm.preEvaluate<panzer::Traits::Residual>(ped);
230
231 // run tests
232 /////////////////////////////////////////////////////////////
233
234 panzer::Workset & workset = (*work_sets)[0];
235 workset.alpha = 0.0;
236 workset.beta = 2.0; // derivatives multiplied by 2
237 workset.time = 0.0;
238 workset.evaluate_transient_terms = false;
239
240 fm.evaluateFields<panzer::Traits::Residual>(workset);
241
242 // test Residual fields
243 Teuchos::ArrayRCP<const double> data;
244 Teuchos::RCP<const Thyra::ProductVectorBase<double> > f_vec = Teuchos::rcp_dynamic_cast<Thyra::ProductVectorBase<double> >(b_loc->get_f());
245
246 // check all the residual values. This is kind of crappy test since it simply checks twice the target
247 // value and the target. Its this way because you add two entries across elements.
248
249 Teuchos::rcp_dynamic_cast<const Thyra::SpmdVectorBase<double> >(f_vec->getVectorBlock(0))->getLocalData(Teuchos::ptrFromRef(data));
250 TEST_EQUALITY(data.size(),b_loc->getMapForBlock(0)->NumMyElements());
251 for(size_type i=0;i<data.size();i++) {
252 double target = 123.0+myRank;
253 TEST_ASSERT(data[i]==target || data[i]==2.0*target);
254 }
255
256 Teuchos::rcp_dynamic_cast<const Thyra::SpmdVectorBase<double> >(f_vec->getVectorBlock(1))->getLocalData(Teuchos::ptrFromRef(data));
257 TEST_EQUALITY(data.size(),b_loc->getMapForBlock(1)->NumMyElements());
258 for(size_type i=0;i<data.size();i++) {
259 double target = 456.0+myRank;
260 TEST_ASSERT(data[i]==target || data[i]==2.0*target);
261 }
262
263 Teuchos::rcp_dynamic_cast<const Thyra::SpmdVectorBase<double> >(f_vec->getVectorBlock(2))->getLocalData(Teuchos::ptrFromRef(data));
264 TEST_EQUALITY(data.size(),b_loc->getMapForBlock(2)->NumMyElements());
265 for(size_type i=0;i<data.size();i++) {
266 double target = 789.0+myRank;
267 TEST_ASSERT(data[i]==target || data[i]==2.0*target);
268 }
269 }
270
271 TEUCHOS_UNIT_TEST(block_assembly, scatter_solution_jacobian)
272 {
273
274 #ifdef HAVE_MPI
275 Teuchos::RCP<Teuchos::MpiComm<int> > tComm = Teuchos::rcp(new Teuchos::MpiComm<int>(MPI_COMM_WORLD));
276 #else
277 NOPE_PANZER_DOESNT_SUPPORT_SERIAL
278 #endif
279
280 int myRank = tComm->getRank();
281
282 const std::size_t workset_size = 4;
283 const std::string fieldName1_q1 = "U";
284 const std::string fieldName2_q1 = "V";
285 const std::string fieldName_qedge1 = "B";
286
287 Teuchos::RCP<panzer_stk::STK_Interface> mesh = buildMesh(2,2);
288
289 // build input physics block
290 Teuchos::RCP<panzer::PureBasis> basis_q1 = buildBasis(workset_size,"Q1");
291 Teuchos::RCP<panzer::PureBasis> basis_qedge1 = buildBasis(workset_size,"QEdge1");
292
293 Teuchos::RCP<Teuchos::ParameterList> ipb = Teuchos::parameterList();
294 testInitialization(ipb);
295
296 const int default_int_order = 1;
297 std::string eBlockID = "eblock-0_0";
298 Teuchos::RCP<user_app::MyFactory> eqset_factory = Teuchos::rcp(new user_app::MyFactory);
299 panzer::CellData cellData(workset_size,mesh->getCellTopology("eblock-0_0"));
300 Teuchos::RCP<panzer::GlobalData> gd = panzer::createGlobalData();
301 Teuchos::RCP<panzer::PhysicsBlock> physicsBlock =
302 Teuchos::rcp(new PhysicsBlock(ipb,eBlockID,default_int_order,cellData,eqset_factory,gd,false));
303
304 Teuchos::RCP<std::vector<panzer::Workset> > work_sets = panzer_stk::buildWorksets(*mesh,physicsBlock->elementBlockID(),
305 physicsBlock->getWorksetNeeds());
306 TEST_EQUALITY(work_sets->size(),1);
307
308 // build connection manager and field manager
309 const Teuchos::RCP<panzer::ConnManager> conn_manager = Teuchos::rcp(new panzer_stk::STKConnManager(mesh));
310 RCP<panzer::BlockedDOFManager> dofManager = Teuchos::rcp(new panzer::BlockedDOFManager(conn_manager,MPI_COMM_WORLD));
311
312 dofManager->addField(fieldName1_q1,Teuchos::rcp(new panzer::Intrepid2FieldPattern(basis_q1->getIntrepid2Basis())));
313 dofManager->addField(fieldName2_q1,Teuchos::rcp(new panzer::Intrepid2FieldPattern(basis_q1->getIntrepid2Basis())));
314 dofManager->addField(fieldName_qedge1,Teuchos::rcp(new panzer::Intrepid2FieldPattern(basis_qedge1->getIntrepid2Basis())));
315
316 std::vector<std::vector<std::string> > fieldOrder(3);
317 fieldOrder[0].push_back(fieldName1_q1);
318 fieldOrder[1].push_back(fieldName_qedge1);
319 fieldOrder[2].push_back(fieldName2_q1);
320 dofManager->setFieldOrder(fieldOrder);
321
322 // dofManager->setOrientationsRequired(true);
323 dofManager->buildGlobalUnknowns();
324
325 // setup linear object factory
326 /////////////////////////////////////////////////////////////
327
328 Teuchos::RCP<BlockedEpetraLinearObjFactory<panzer::Traits,int> > be_lof
329 = Teuchos::rcp(new BlockedEpetraLinearObjFactory<panzer::Traits,int>(tComm.getConst(),dofManager));
330 Teuchos::RCP<LinearObjFactory<panzer::Traits> > lof = be_lof;
331 Teuchos::RCP<LinearObjContainer> loc = be_lof->buildGhostedLinearObjContainer();
332 be_lof->initializeGhostedContainer(LinearObjContainer::X | LinearObjContainer::F | LinearObjContainer::Mat,*loc);
333 loc->initialize();
334
335 Teuchos::RCP<BlockedEpetraLinearObjContainer> b_loc
336 = Teuchos::rcp_dynamic_cast<BlockedEpetraLinearObjContainer>(loc);
337
338 Teuchos::RCP<Thyra::ProductVectorBase<double> > p_vec = Teuchos::rcp_dynamic_cast<Thyra::ProductVectorBase<double> >(b_loc->get_x());
339 Thyra::assign(p_vec->getNonconstVectorBlock(0).ptr(),123.0+myRank);
340 Thyra::assign(p_vec->getNonconstVectorBlock(1).ptr(),456.0+myRank);
341 Thyra::assign(p_vec->getNonconstVectorBlock(2).ptr(),789.0+myRank);
342
343 // setup field manager, add evaluator under test
344 /////////////////////////////////////////////////////////////
345
346 PHX::FieldManager<panzer::Traits> fm;
347
348 std::string resName = "";
349 Teuchos::RCP<std::map<std::string,std::string> > names_map =
350 Teuchos::rcp(new std::map<std::string,std::string>);
351 names_map->insert(std::make_pair(fieldName1_q1,resName+fieldName1_q1));
352 names_map->insert(std::make_pair(fieldName2_q1,resName+fieldName2_q1));
353 names_map->insert(std::make_pair(fieldName_qedge1,resName+fieldName_qedge1));
354
355 // evaluators under test
356 {
357 using Teuchos::RCP;
358 using Teuchos::rcp;
359 RCP<std::vector<std::string> > names = rcp(new std::vector<std::string>);
360 names->push_back(resName+fieldName1_q1);
361 names->push_back(resName+fieldName2_q1);
362
363 Teuchos::ParameterList pl;
364 pl.set("Scatter Name", "ScatterQ1");
365 pl.set("Basis", basis_q1.getConst());
366 pl.set("Dependent Names", names);
367 pl.set("Dependent Map", names_map);
368
369 Teuchos::RCP<PHX::Evaluator<panzer::Traits> > evaluator = lof->buildScatter<panzer::Traits::Jacobian>(pl);
370
371 TEST_EQUALITY(evaluator->evaluatedFields().size(),1);
372
373 fm.registerEvaluator<panzer::Traits::Jacobian>(evaluator);
374 fm.requireField<panzer::Traits::Jacobian>(*evaluator->evaluatedFields()[0]);
375 }
376 {
377 using Teuchos::RCP;
378 using Teuchos::rcp;
379 RCP<std::vector<std::string> > names = rcp(new std::vector<std::string>);
380 names->push_back(resName+fieldName_qedge1);
381
382 Teuchos::ParameterList pl;
383 pl.set("Scatter Name", "ScatterQEdge1");
384 pl.set("Basis", basis_qedge1.getConst());
385 pl.set("Dependent Names", names);
386 pl.set("Dependent Map", names_map);
387
388 Teuchos::RCP<PHX::Evaluator<panzer::Traits> > evaluator = lof->buildScatter<panzer::Traits::Jacobian>(pl);
389
390 TEST_EQUALITY(evaluator->evaluatedFields().size(),1);
391
392 fm.registerEvaluator<panzer::Traits::Jacobian>(evaluator);
393 fm.requireField<panzer::Traits::Jacobian>(*evaluator->evaluatedFields()[0]);
394 }
395
396 // support evaluators
397 {
398 using Teuchos::RCP;
399 using Teuchos::rcp;
400 RCP<std::vector<std::string> > names = rcp(new std::vector<std::string>);
401 names->push_back(fieldName1_q1);
402 names->push_back(fieldName2_q1);
403
404 Teuchos::ParameterList pl;
405 pl.set("Basis", basis_q1);
406 pl.set("DOF Names",names);
407 pl.set("Indexer Names",names);
408
409 Teuchos::RCP<PHX::Evaluator<panzer::Traits> > evaluator = lof->buildGather<panzer::Traits::Jacobian>(pl);
410
411 fm.registerEvaluator<panzer::Traits::Jacobian>(evaluator);
412 }
413 {
414 using Teuchos::RCP;
415 using Teuchos::rcp;
416 RCP<std::vector<std::string> > names = rcp(new std::vector<std::string>);
417 names->push_back(fieldName_qedge1);
418
419 Teuchos::ParameterList pl;
420 pl.set("Basis", basis_qedge1);
421 pl.set("DOF Names",names);
422 pl.set("Indexer Names",names);
423
424 Teuchos::RCP<PHX::Evaluator<panzer::Traits> > evaluator = lof->buildGather<panzer::Traits::Jacobian>(pl);
425
426 fm.registerEvaluator<panzer::Traits::Jacobian>(evaluator);
427 }
428
429 std::vector<PHX::index_size_type> derivative_dimensions;
430 derivative_dimensions.push_back(12);
431 fm.setKokkosExtendedDataTypeDimensions<panzer::Traits::Jacobian>(derivative_dimensions);
432
433 panzer::Traits::SD sd;
434 fm.postRegistrationSetup(sd);
435
436 panzer::Traits::PED ped;
437 ped.gedc->addDataObject("Solution Gather Container",loc);
438 ped.gedc->addDataObject("Residual Scatter Container",loc);
439 fm.preEvaluate<panzer::Traits::Jacobian>(ped);
440
441 // run tests
442 /////////////////////////////////////////////////////////////
443
444 panzer::Workset & workset = (*work_sets)[0];
445 workset.alpha = 0.0;
446 workset.beta = 2.0; // derivatives multiplied by 2
447 workset.time = 0.0;
448 workset.evaluate_transient_terms = false;
449
450 fm.evaluateFields<panzer::Traits::Jacobian>(workset);
451
452 // test Jacobian fields
453 Teuchos::ArrayRCP<const double> data;
454 Teuchos::RCP<const Thyra::ProductVectorBase<double> > f_vec = Teuchos::rcp_dynamic_cast<Thyra::ProductVectorBase<double> >(b_loc->get_f());
455
456 // check all the residual values. This is kind of crappy test since it simply checks twice the target
457 // value and the target. Its this way because you add two entries across elements.
458
459 Teuchos::rcp_dynamic_cast<const Thyra::SpmdVectorBase<double> >(f_vec->getVectorBlock(0))->getLocalData(Teuchos::ptrFromRef(data));
460 TEST_EQUALITY(data.size(),b_loc->getMapForBlock(0)->NumMyElements());
461 out << std::endl;
462 for(size_type i=0;i<data.size();i++) {
463 double target = 123.0+myRank;
464 TEST_ASSERT(data[i]==target || data[i]==2.0*target);
465 out << data[i] << std::endl;
466 }
467
468 Teuchos::rcp_dynamic_cast<const Thyra::SpmdVectorBase<double> >(f_vec->getVectorBlock(1))->getLocalData(Teuchos::ptrFromRef(data));
469 TEST_EQUALITY(data.size(),b_loc->getMapForBlock(1)->NumMyElements());
470 out << std::endl;
471 for(size_type i=0;i<data.size();i++) {
472 double target = 456.0+myRank;
473 TEST_ASSERT(data[i]==target || data[i]==2.0*target);
474 out << data[i] << std::endl;
475 }
476
477 Teuchos::rcp_dynamic_cast<const Thyra::SpmdVectorBase<double> >(f_vec->getVectorBlock(2))->getLocalData(Teuchos::ptrFromRef(data));
478 TEST_EQUALITY(data.size(),b_loc->getMapForBlock(2)->NumMyElements());
479 out << std::endl;
480 for(size_type i=0;i<data.size();i++) {
481 double target = 789.0+myRank;
482 TEST_ASSERT(data[i]==target || data[i]==2.0*target);
483 out << data[i] << std::endl;
484 }
485 }
486
487 Teuchos::RCP<panzer::PureBasis> buildBasis(std::size_t worksetSize,const std::string & basisName)
488 {
489 Teuchos::RCP<shards::CellTopology> topo =
490 Teuchos::rcp(new shards::CellTopology(shards::getCellTopologyData< shards::Quadrilateral<4> >()));
491
492 panzer::CellData cellData(worksetSize,topo);
493 return Teuchos::rcp(new panzer::PureBasis(basisName,1,cellData));
494 }
495
496 Teuchos::RCP<panzer_stk::STK_Interface> buildMesh(int elemX,int elemY)
497 {
498 RCP<Teuchos::ParameterList> pl = rcp(new Teuchos::ParameterList);
499 pl->set("X Blocks",1);
500 pl->set("Y Blocks",1);
501 pl->set("X Elements",elemX);
502 pl->set("Y Elements",elemY);
503
504 panzer_stk::SquareQuadMeshFactory factory;
505 factory.setParameterList(pl);
506 RCP<panzer_stk::STK_Interface> mesh = factory.buildUncommitedMesh(MPI_COMM_WORLD);
507 factory.completeMeshConstruction(*mesh,MPI_COMM_WORLD);
508
509 return mesh;
510 }
511
512 void testInitialization(const Teuchos::RCP<Teuchos::ParameterList>& ipb)
513 {
514 // Physics block
515 ipb->setName("test physics");
516 {
517 Teuchos::ParameterList& p = ipb->sublist("a");
518 p.set("Type","Energy");
519 p.set("Prefix","");
520 p.set("Model ID","solid");
521 p.set("Basis Type","HGrad");
522 p.set("Basis Order",1);
523 p.set("Integration Order",1);
524 }
525 {
526 Teuchos::ParameterList& p = ipb->sublist("b");
527 p.set("Type","Energy");
528 p.set("Prefix","ION_");
529 p.set("Model ID","solid");
530 p.set("Basis Type","HCurl");
531 p.set("Basis Order",1);
532 p.set("Integration Order",1);
533 }
534
535 }
536
537 }