Debian Codegraph @

packages/panzer/adapters-stk/test/evaluator_tests/epetra_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_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 #include "Thyra_get_Epetra_Operator.hpp"
47
48 #include "Epetra_CrsMatrix.h"
49
50 #include "user_app_EquationSetFactory.hpp"
51
52 #include <cstdio> // for get char
53 #include <vector>
54 #include <string>
55
56 #include "Panzer_Evaluator_WithBaseImpl.hpp"
57
58 namespace panzer {
59
60 Teuchos::RCP<panzer::PureBasis> buildBasis(std::size_t worksetSize,const std::string & basisName);
61 void testInitialization(const Teuchos::RCP<Teuchos::ParameterList>& ipb);
62 Teuchos::RCP<panzer_stk::STK_Interface> buildMesh(int elemX,int elemY);
63
64 TEUCHOS_UNIT_TEST(block_assembly, scatter_dirichlet_residual)
65 {
66
67 #ifdef HAVE_MPI
68 Teuchos::RCP<Teuchos::MpiComm<int> > tComm = Teuchos::rcp(new Teuchos::MpiComm<int>(MPI_COMM_WORLD));
69 #else
70 NOPE_PANZER_DOESNT_SUPPORT_SERIAL
71 #endif
72
73 int myRank = tComm->getRank();
74
75 const std::size_t workset_size = 4;
76 const std::string fieldName1_q1 = "U";
77 const std::string fieldName2_q1 = "V";
78 const std::string fieldName_qedge1 = "B";
79
80 Teuchos::RCP<panzer_stk::STK_Interface> mesh = buildMesh(2,2);
81
82 // build input physics block
83 Teuchos::RCP<panzer::PureBasis> basis_q1 = buildBasis(workset_size,"Q1");
84 Teuchos::RCP<panzer::PureBasis> basis_qedge1 = buildBasis(workset_size,"QEdge1");
85
86 Teuchos::RCP<Teuchos::ParameterList> ipb = Teuchos::parameterList();
87 testInitialization(ipb);
88
89 const int default_int_order = 1;
90 std::string eBlockID = "eblock-0_0";
91 Teuchos::RCP<user_app::MyFactory> eqset_factory = Teuchos::rcp(new user_app::MyFactory);
92 panzer::CellData cellData(workset_size,mesh->getCellTopology("eblock-0_0"));
93 Teuchos::RCP<panzer::GlobalData> gd = panzer::createGlobalData();
94 Teuchos::RCP<panzer::PhysicsBlock> physicsBlock =
95 Teuchos::rcp(new PhysicsBlock(ipb,eBlockID,default_int_order,cellData,eqset_factory,gd,false));
96
97 Teuchos::RCP<std::vector<panzer::Workset> > work_sets = panzer_stk::buildWorksets(*mesh,physicsBlock->elementBlockID(),
98 physicsBlock->getWorksetNeeds());
99 TEST_EQUALITY(work_sets->size(),1);
100
101 // build connection manager and field manager
102 const Teuchos::RCP<panzer::ConnManager> conn_manager = Teuchos::rcp(new panzer_stk::STKConnManager(mesh));
103 RCP<panzer::BlockedDOFManager> dofManager = Teuchos::rcp(new panzer::BlockedDOFManager(conn_manager,MPI_COMM_WORLD));
104
105 dofManager->addField(fieldName1_q1,Teuchos::rcp(new panzer::Intrepid2FieldPattern(basis_q1->getIntrepid2Basis())));
106 dofManager->addField(fieldName2_q1,Teuchos::rcp(new panzer::Intrepid2FieldPattern(basis_q1->getIntrepid2Basis())));
107 dofManager->addField(fieldName_qedge1,Teuchos::rcp(new panzer::Intrepid2FieldPattern(basis_qedge1->getIntrepid2Basis())));
108
109 std::vector<std::vector<std::string> > fieldOrder(3);
110 fieldOrder[0].push_back(fieldName1_q1);
111 fieldOrder[1].push_back(fieldName_qedge1);
112 fieldOrder[2].push_back(fieldName2_q1);
113 dofManager->setFieldOrder(fieldOrder);
114
115 // dofManager->setOrientationsRequired(true);
116 dofManager->buildGlobalUnknowns();
117
118 // setup linear object factory
119 /////////////////////////////////////////////////////////////
120
121 Teuchos::RCP<BlockedEpetraLinearObjFactory<panzer::Traits,int> > be_lof
122 = Teuchos::rcp(new BlockedEpetraLinearObjFactory<panzer::Traits,int>(tComm.getConst(),dofManager));
123 Teuchos::RCP<LinearObjFactory<panzer::Traits> > lof = be_lof;
124 Teuchos::RCP<LinearObjContainer> dd_loc = be_lof->buildGhostedLinearObjContainer();
125 Teuchos::RCP<LinearObjContainer> loc = be_lof->buildGhostedLinearObjContainer();
126 be_lof->initializeGhostedContainer(LinearObjContainer::F,*dd_loc);
127 dd_loc->initialize();
128
129 be_lof->initializeGhostedContainer(LinearObjContainer::X | LinearObjContainer::F,*loc);
130 loc->initialize();
131
132 Teuchos::RCP<BlockedEpetraLinearObjContainer> b_dd_loc = Teuchos::rcp_dynamic_cast<BlockedEpetraLinearObjContainer>(dd_loc);
133 Teuchos::RCP<BlockedEpetraLinearObjContainer> b_loc = Teuchos::rcp_dynamic_cast<BlockedEpetraLinearObjContainer>(loc);
134 Teuchos::RCP<Thyra::ProductVectorBase<double> > p_vec = Teuchos::rcp_dynamic_cast<Thyra::ProductVectorBase<double> >(b_loc->get_x());
135 Thyra::assign(p_vec->getNonconstVectorBlock(0).ptr(),123.0+myRank);
136 Thyra::assign(p_vec->getNonconstVectorBlock(1).ptr(),456.0+myRank);
137 Thyra::assign(p_vec->getNonconstVectorBlock(2).ptr(),789.0+myRank);
138
139 // setup field manager, add evaluator under test
140 /////////////////////////////////////////////////////////////
141
142 PHX::FieldManager<panzer::Traits> fm;
143
144 std::string resName = "";
145 Teuchos::RCP<std::map<std::string,std::string> > names_map =
146 Teuchos::rcp(new std::map<std::string,std::string>);
147 names_map->insert(std::make_pair(fieldName1_q1,resName+fieldName1_q1));
148 names_map->insert(std::make_pair(fieldName2_q1,resName+fieldName2_q1));
149 names_map->insert(std::make_pair(fieldName_qedge1,resName+fieldName_qedge1));
150
151 // evaluators under test
152 {
153 using Teuchos::RCP;
154 using Teuchos::rcp;
155 RCP<std::vector<std::string> > names = rcp(new std::vector<std::string>);
156 names->push_back(resName+fieldName1_q1);
157 names->push_back(resName+fieldName2_q1);
158
159 Teuchos::ParameterList pl;
160 pl.set("Scatter Name", "ScatterQ1");
161 pl.set("Basis", basis_q1);
162 pl.set("Dependent Names", names);
163 pl.set("Dependent Map", names_map);
164 pl.set("Side Subcell Dimension", 1);
165 pl.set("Local Side ID", 2);
166 pl.set("Check Apply BC", false);
167
168 Teuchos::RCP<PHX::Evaluator<panzer::Traits> > evaluator = lof->buildScatterDirichlet<panzer::Traits::Residual>(pl);
169
170 TEST_EQUALITY(evaluator->evaluatedFields().size(),1);
171
172 fm.registerEvaluator<panzer::Traits::Residual>(evaluator);
173 fm.requireField<panzer::Traits::Residual>(*evaluator->evaluatedFields()[0]);
174 }
175 {
176 using Teuchos::RCP;
177 using Teuchos::rcp;
178 RCP<std::vector<std::string> > names = rcp(new std::vector<std::string>);
179 names->push_back(resName+fieldName_qedge1);
180
181 Teuchos::ParameterList pl;
182 pl.set("Scatter Name", "ScatterQEdge1");
183 pl.set("Basis", basis_qedge1);
184 pl.set("Dependent Names", names);
185 pl.set("Dependent Map", names_map);
186 pl.set("Side Subcell Dimension", 1);
187 pl.set("Local Side ID", 2);
188 pl.set("Check Apply BC", false);
189
190 Teuchos::RCP<PHX::Evaluator<panzer::Traits> > evaluator = lof->buildScatterDirichlet<panzer::Traits::Residual>(pl);
191
192 TEST_EQUALITY(evaluator->evaluatedFields().size(),1);
193
194 fm.registerEvaluator<panzer::Traits::Residual>(evaluator);
195 fm.requireField<panzer::Traits::Residual>(*evaluator->evaluatedFields()[0]);
196 }
197
198 // support evaluators
199 {
200 using Teuchos::RCP;
201 using Teuchos::rcp;
202 RCP<std::vector<std::string> > names = rcp(new std::vector<std::string>);
203 names->push_back(fieldName1_q1);
204 names->push_back(fieldName2_q1);
205
206 Teuchos::ParameterList pl;
207 pl.set("Basis", basis_q1);
208 pl.set("DOF Names",names);
209 pl.set("Indexer Names",names);
210
211 Teuchos::RCP<PHX::Evaluator<panzer::Traits> > evaluator = lof->buildGather<panzer::Traits::Residual>(pl);
212
213 fm.registerEvaluator<panzer::Traits::Residual>(evaluator);
214 }
215 {
216 using Teuchos::RCP;
217 using Teuchos::rcp;
218 RCP<std::vector<std::string> > names = rcp(new std::vector<std::string>);
219 names->push_back(fieldName_qedge1);
220
221 Teuchos::ParameterList pl;
222 pl.set("Basis", basis_qedge1);
223 pl.set("DOF Names",names);
224 pl.set("Indexer Names",names);
225
226 Teuchos::RCP<PHX::Evaluator<panzer::Traits> > evaluator = lof->buildGather<panzer::Traits::Residual>(pl);
227
228 fm.registerEvaluator<panzer::Traits::Residual>(evaluator);
229 }
230
231 std::vector<PHX::index_size_type> derivative_dimensions;
232 derivative_dimensions.push_back(12);
233 fm.setKokkosExtendedDataTypeDimensions<panzer::Traits::Jacobian>(derivative_dimensions);
234
235 panzer::Traits::SD sd;
236 fm.postRegistrationSetup(sd);
237
238 // panzer::Traits::PED ped;
239 // ped.dirichletData.ghostedCounter = dd_loc;
240 // fm.preEvaluate<panzer::Traits::Residual>(ped);
241 panzer::Traits::PED ped;
242 ped.gedc->addDataObject("Dirichlet Counter",dd_loc);
243 ped.gedc->addDataObject("Solution Gather Container",loc);
244 ped.gedc->addDataObject("Residual Scatter Container",loc);
245 fm.preEvaluate<panzer::Traits::Residual>(ped);
246
247
248 // run tests
249 /////////////////////////////////////////////////////////////
250
251 panzer::Workset & workset = (*work_sets)[0];
252 workset.alpha = 0.0;
253 workset.beta = 2.0; // derivatives multiplied by 2
254 workset.time = 0.0;
255 workset.evaluate_transient_terms = false;
256
257 fm.evaluateFields<panzer::Traits::Residual>(workset);
258
259 // test Residual fields
260 panzer::index_t dd_count(0);
261 Teuchos::ArrayRCP<const double> data, dd_data;
262 Teuchos::RCP<const Thyra::ProductVectorBase<double> > f_vec = Teuchos::rcp_dynamic_cast<Thyra::ProductVectorBase<double> >(b_loc->get_f());
263 Teuchos::RCP<const Thyra::ProductVectorBase<double> > dd_vec = Teuchos::rcp_dynamic_cast<Thyra::ProductVectorBase<double> >(b_dd_loc->get_f());
264
265 // check all the residual values. This is kind of crappy test since it simply checks twice the target
266 // value and the target. Its this way because you add two entries across elements.
267
268 Teuchos::rcp_dynamic_cast<const Thyra::SpmdVectorBase<double> >(f_vec->getVectorBlock(0))->getLocalData(Teuchos::ptrFromRef(data));
269 Teuchos::rcp_dynamic_cast<const Thyra::SpmdVectorBase<double> >(dd_vec->getVectorBlock(0))->getLocalData(Teuchos::ptrFromRef(dd_data));
270 TEST_EQUALITY(data.size(),b_loc->getMapForBlock(0)->NumMyElements());
271 TEST_EQUALITY(data.size(),dd_data.size());
272 dd_count = 0;
273 for(int i=0;i<data.size();i++) {
274
275 double target = 123.0+myRank;
276 if(dd_data[i]==0.0)
277 { TEST_EQUALITY(data[i],0.0); }
278 else
279 { TEST_EQUALITY(data[i],target); dd_count++; }
280 }
281 TEST_EQUALITY(dd_count,2*workset.num_cells); // there are 2 nodes on the side and the sides are not shared
282
283 Teuchos::rcp_dynamic_cast<const Thyra::SpmdVectorBase<double> >(f_vec->getVectorBlock(1))->getLocalData(Teuchos::ptrFromRef(data));
284 Teuchos::rcp_dynamic_cast<const Thyra::SpmdVectorBase<double> >(dd_vec->getVectorBlock(1))->getLocalData(Teuchos::ptrFromRef(dd_data));
285 TEST_EQUALITY(data.size(),b_loc->getMapForBlock(1)->NumMyElements());
286 TEST_EQUALITY(data.size(),dd_data.size());
287 dd_count = 0;
288 for(int i=0;i<data.size();i++) {
289
290 double target = 456.0+myRank;
291 if(dd_data[i]==0.0)
292 { TEST_EQUALITY(data[i],0.0); }
293 else
294 { TEST_EQUALITY(data[i],target); dd_count++; }
295 }
296 TEST_EQUALITY(dd_count,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(2))->getLocalData(Teuchos::ptrFromRef(data));
299 Teuchos::rcp_dynamic_cast<const Thyra::SpmdVectorBase<double> >(dd_vec->getVectorBlock(2))->getLocalData(Teuchos::ptrFromRef(dd_data));
300 TEST_EQUALITY(data.size(),b_loc->getMapForBlock(2)->NumMyElements());
301 TEST_EQUALITY(data.size(),dd_data.size());
302 dd_count = 0;
303 for(int i=0;i<data.size();i++) {
304
305 double target = 789.0+myRank;
306 if(dd_data[i]==0.0)
307 { TEST_EQUALITY(data[i],0.0); }
308 else
309 { TEST_EQUALITY(data[i],target); dd_count++; }
310 }
311 TEST_EQUALITY(dd_count,2*workset.num_cells); // there are 2 nodes on the side and the sides are not shared
312
313 }
314
315 TEUCHOS_UNIT_TEST(block_assembly, scatter_dirichlet_jacobian)
316 {
317
318 #ifdef HAVE_MPI
319 Teuchos::RCP<Teuchos::MpiComm<int> > tComm = Teuchos::rcp(new Teuchos::MpiComm<int>(MPI_COMM_WORLD));
320 #else
321 NOPE_PANZER_DOESNT_SUPPORT_SERIAL
322 #endif
323
324 int myRank = tComm->getRank();
325
326 const std::size_t workset_size = 4;
327 const std::string fieldName1_q1 = "U";
328 const std::string fieldName2_q1 = "V";
329 const std::string fieldName_qedge1 = "B";
330
331 Teuchos::RCP<panzer_stk::STK_Interface> mesh = buildMesh(2,2);
332
333 // build input physics block
334 Teuchos::RCP<panzer::PureBasis> basis_q1 = buildBasis(workset_size,"Q1");
335 Teuchos::RCP<panzer::PureBasis> basis_qedge1 = buildBasis(workset_size,"QEdge1");
336
337 Teuchos::RCP<Teuchos::ParameterList> ipb = Teuchos::parameterList();
338 testInitialization(ipb);
339
340 const int default_int_order = 1;
341 std::string eBlockID = "eblock-0_0";
342 Teuchos::RCP<user_app::MyFactory> eqset_factory = Teuchos::rcp(new user_app::MyFactory);
343 panzer::CellData cellData(workset_size,mesh->getCellTopology("eblock-0_0"));
344 Teuchos::RCP<panzer::GlobalData> gd = panzer::createGlobalData();
345 Teuchos::RCP<panzer::PhysicsBlock> physicsBlock =
346 Teuchos::rcp(new PhysicsBlock(ipb,eBlockID,default_int_order,cellData,eqset_factory,gd,false));
347
348 Teuchos::RCP<std::vector<panzer::Workset> > work_sets = panzer_stk::buildWorksets(*mesh,physicsBlock->elementBlockID(),
349 physicsBlock->getWorksetNeeds());
350 TEST_EQUALITY(work_sets->size(),1);
351
352 // build connection manager and field manager
353 const Teuchos::RCP<panzer::ConnManager> conn_manager = Teuchos::rcp(new panzer_stk::STKConnManager(mesh));
354 RCP<panzer::BlockedDOFManager> dofManager = Teuchos::rcp(new panzer::BlockedDOFManager(conn_manager,MPI_COMM_WORLD));
355
356 dofManager->addField(fieldName1_q1,Teuchos::rcp(new panzer::Intrepid2FieldPattern(basis_q1->getIntrepid2Basis())));
357 dofManager->addField(fieldName2_q1,Teuchos::rcp(new panzer::Intrepid2FieldPattern(basis_q1->getIntrepid2Basis())));
358 dofManager->addField(fieldName_qedge1,Teuchos::rcp(new panzer::Intrepid2FieldPattern(basis_qedge1->getIntrepid2Basis())));
359
360 std::vector<std::vector<std::string> > fieldOrder(3);
361 fieldOrder[0].push_back(fieldName1_q1);
362 fieldOrder[1].push_back(fieldName_qedge1);
363 fieldOrder[2].push_back(fieldName2_q1);
364 dofManager->setFieldOrder(fieldOrder);
365
366 // dofManager->setOrientationsRequired(true);
367 dofManager->buildGlobalUnknowns();
368
369 // setup linear object factory
370 /////////////////////////////////////////////////////////////
371
372 Teuchos::RCP<BlockedEpetraLinearObjFactory<panzer::Traits,int> > be_lof
373 = Teuchos::rcp(new BlockedEpetraLinearObjFactory<panzer::Traits,int>(tComm.getConst(),dofManager));
374 Teuchos::RCP<LinearObjFactory<panzer::Traits> > lof = be_lof;
375 Teuchos::RCP<LinearObjContainer> dd_loc = be_lof->buildGhostedLinearObjContainer();
376 Teuchos::RCP<LinearObjContainer> loc = be_lof->buildGhostedLinearObjContainer();
377 be_lof->initializeGhostedContainer(LinearObjContainer::F,*dd_loc);
378 dd_loc->initialize();
379
380 be_lof->initializeGhostedContainer(LinearObjContainer::X | LinearObjContainer::F | LinearObjContainer::Mat,*loc);
381 loc->initialize();
382
383 Teuchos::RCP<BlockedEpetraLinearObjContainer> b_dd_loc = Teuchos::rcp_dynamic_cast<BlockedEpetraLinearObjContainer>(dd_loc);
384 Teuchos::RCP<BlockedEpetraLinearObjContainer> b_loc = Teuchos::rcp_dynamic_cast<BlockedEpetraLinearObjContainer>(loc);
385 Teuchos::RCP<Thyra::ProductVectorBase<double> > p_vec = Teuchos::rcp_dynamic_cast<Thyra::ProductVectorBase<double> >(b_loc->get_x());
386 Thyra::assign(p_vec->getNonconstVectorBlock(0).ptr(),123.0+myRank);
387 Thyra::assign(p_vec->getNonconstVectorBlock(1).ptr(),456.0+myRank);
388 Thyra::assign(p_vec->getNonconstVectorBlock(2).ptr(),789.0+myRank);
389
390 Teuchos::RCP<Thyra::BlockedLinearOpBase<double> > blk_A
391 = Teuchos::rcp_dynamic_cast<Thyra::BlockedLinearOpBase<double> >(b_loc->get_A());
392 double values[] = {123.0+myRank,456.0+myRank,789.0+myRank};
393 for(int i=0;i<3;i++)
394 for(int j=0;j<3;j++)
395 Teuchos::rcp_dynamic_cast<Epetra_CrsMatrix>(Thyra::get_Epetra_Operator(*blk_A->getNonconstBlock(i,j)))->PutScalar(values[i]*values[j]);
396
397 // setup field manager, add evaluator under test
398 /////////////////////////////////////////////////////////////
399
400 PHX::FieldManager<panzer::Traits> fm;
401
402 std::string resName = "";
403 Teuchos::RCP<std::map<std::string,std::string> > names_map =
404 Teuchos::rcp(new std::map<std::string,std::string>);
405 names_map->insert(std::make_pair(fieldName1_q1,resName+fieldName1_q1));
406 names_map->insert(std::make_pair(fieldName2_q1,resName+fieldName2_q1));
407 names_map->insert(std::make_pair(fieldName_qedge1,resName+fieldName_qedge1));
408
409 // evaluators under test
410 {
411 using Teuchos::RCP;
412 using Teuchos::rcp;
413 RCP<std::vector<std::string> > names = rcp(new std::vector<std::string>);
414 names->push_back(resName+fieldName1_q1);
415 names->push_back(resName+fieldName2_q1);
416
417 Teuchos::ParameterList pl;
418 pl.set("Scatter Name", "ScatterQ1");
419 pl.set("Basis", basis_q1);
420 pl.set("Dependent Names", names);
421 pl.set("Dependent Map", names_map);
422 pl.set("Side Subcell Dimension", 1);
423 pl.set("Local Side ID", 2);
424 pl.set("Check Apply BC", false);
425
426 Teuchos::RCP<PHX::Evaluator<panzer::Traits> > evaluator = lof->buildScatterDirichlet<panzer::Traits::Jacobian>(pl);
427
428 TEST_EQUALITY(evaluator->evaluatedFields().size(),1);
429
430 fm.registerEvaluator<panzer::Traits::Jacobian>(evaluator);
431 fm.requireField<panzer::Traits::Jacobian>(*evaluator->evaluatedFields()[0]);
432 }
433 {
434 using Teuchos::RCP;
435 using Teuchos::rcp;
436 RCP<std::vector<std::string> > names = rcp(new std::vector<std::string>);
437 names->push_back(resName+fieldName_qedge1);
438
439 Teuchos::ParameterList pl;
440 pl.set("Scatter Name", "ScatterQEdge1");
441 pl.set("Basis", basis_qedge1);
442 pl.set("Dependent Names", names);
443 pl.set("Dependent Map", names_map);
444 pl.set("Side Subcell Dimension", 1);
445 pl.set("Local Side ID", 2);
446 pl.set("Check Apply BC", false);
447
448 Teuchos::RCP<PHX::Evaluator<panzer::Traits> > evaluator = lof->buildScatterDirichlet<panzer::Traits::Jacobian>(pl);
449
450 TEST_EQUALITY(evaluator->evaluatedFields().size(),1);
451
452 fm.registerEvaluator<panzer::Traits::Jacobian>(evaluator);
453 fm.requireField<panzer::Traits::Jacobian>(*evaluator->evaluatedFields()[0]);
454 }
455
456 // support evaluators
457 {
458 using Teuchos::RCP;
459 using Teuchos::rcp;
460 RCP<std::vector<std::string> > names = rcp(new std::vector<std::string>);
461 names->push_back(fieldName1_q1);
462 names->push_back(fieldName2_q1);
463
464 Teuchos::ParameterList pl;
465 pl.set("Basis", basis_q1);
466 pl.set("DOF Names",names);
467 pl.set("Indexer Names",names);
468
469 Teuchos::RCP<PHX::Evaluator<panzer::Traits> > evaluator = lof->buildGather<panzer::Traits::Jacobian>(pl);
470
471 fm.registerEvaluator<panzer::Traits::Jacobian>(evaluator);
472 }
473 {
474 using Teuchos::RCP;
475 using Teuchos::rcp;
476 RCP<std::vector<std::string> > names = rcp(new std::vector<std::string>);
477 names->push_back(fieldName_qedge1);
478
479 Teuchos::ParameterList pl;
480 pl.set("Basis", basis_qedge1);
481 pl.set("DOF Names",names);
482 pl.set("Indexer Names",names);
483
484 Teuchos::RCP<PHX::Evaluator<panzer::Traits> > evaluator = lof->buildGather<panzer::Traits::Jacobian>(pl);
485
486 fm.registerEvaluator<panzer::Traits::Jacobian>(evaluator);
487 }
488
489 std::vector<PHX::index_size_type> derivative_dimensions;
490 derivative_dimensions.push_back(12);
491 fm.setKokkosExtendedDataTypeDimensions<panzer::Traits::Jacobian>(derivative_dimensions);
492
493 panzer::Traits::SD sd;
494 fm.postRegistrationSetup(sd);
495
496 // panzer::Traits::PED ped;
497 // ped.dirichletData.ghostedCounter = dd_loc;
498 // fm.preEvaluate<panzer::Traits::Jacobian>(ped);
499 panzer::Traits::PED ped;
500 ped.gedc->addDataObject("Dirichlet Counter",dd_loc);
501 ped.gedc->addDataObject("Solution Gather Container",loc);
502 ped.gedc->addDataObject("Residual Scatter Container",loc);
503 fm.preEvaluate<panzer::Traits::Jacobian>(ped);
504
505 // run tests
506 /////////////////////////////////////////////////////////////
507
508 panzer::Workset & workset = (*work_sets)[0];
509 workset.alpha = 0.0;
510 workset.beta = 2.0; // derivatives multiplied by 2
511 workset.time = 0.0;
512 workset.evaluate_transient_terms = false;
513
514 fm.evaluateFields<panzer::Traits::Jacobian>(workset);
515
516 // test Residual fields
517 panzer::index_t dd_count(0);
518 Teuchos::ArrayRCP<const double> data, dd_data;
519 Teuchos::RCP<const Thyra::ProductVectorBase<double> > f_vec = Teuchos::rcp_dynamic_cast<Thyra::ProductVectorBase<double> >(b_loc->get_f());
520 Teuchos::RCP<const Thyra::ProductVectorBase<double> > dd_vec = Teuchos::rcp_dynamic_cast<Thyra::ProductVectorBase<double> >(b_dd_loc->get_f());
521
522 // check all the residual values. This is kind of crappy test since it simply checks twice the target
523 // value and the target. Its this way because you add two entries across elements.
524
525 Teuchos::rcp_dynamic_cast<const Thyra::SpmdVectorBase<double> >(f_vec->getVectorBlock(0))->getLocalData(Teuchos::ptrFromRef(data));
526 Teuchos::rcp_dynamic_cast<const Thyra::SpmdVectorBase<double> >(dd_vec->getVectorBlock(0))->getLocalData(Teuchos::ptrFromRef(dd_data));
527 TEST_EQUALITY(data.size(),b_loc->getMapForBlock(0)->NumMyElements());
528 TEST_EQUALITY(data.size(),dd_data.size());
529 dd_count = 0;
530 for(int i=0;i<data.size();i++) {
531
532 double target = 123.0+myRank;
533 if(dd_data[i]==0.0)
534 { TEST_EQUALITY(data[i],0.0); }
535 else
536 { TEST_EQUALITY(data[i],target); dd_count++; }
537 }
538 TEST_EQUALITY(dd_count,2*workset.num_cells); // there are 2 nodes on the side and the sides are not shared
539
540 Teuchos::rcp_dynamic_cast<const Thyra::SpmdVectorBase<double> >(f_vec->getVectorBlock(1))->getLocalData(Teuchos::ptrFromRef(data));
541 Teuchos::rcp_dynamic_cast<const Thyra::SpmdVectorBase<double> >(dd_vec->getVectorBlock(1))->getLocalData(Teuchos::ptrFromRef(dd_data));
542 TEST_EQUALITY(data.size(),b_loc->getMapForBlock(1)->NumMyElements());
543 TEST_EQUALITY(data.size(),dd_data.size());
544 dd_count = 0;
545 for(int i=0;i<data.size();i++) {
546
547 double target = 456.0+myRank;
548 if(dd_data[i]==0.0)
549 { TEST_EQUALITY(data[i],0.0); }
550 else
551 { TEST_EQUALITY(data[i],target); dd_count++; }
552 }
553 TEST_EQUALITY(dd_count,workset.num_cells); // there are 2 nodes on the side and the sides are not shared
554
555 Teuchos::rcp_dynamic_cast<const Thyra::SpmdVectorBase<double> >(f_vec->getVectorBlock(2))->getLocalData(Teuchos::ptrFromRef(data));
556 Teuchos::rcp_dynamic_cast<const Thyra::SpmdVectorBase<double> >(dd_vec->getVectorBlock(2))->getLocalData(Teuchos::ptrFromRef(dd_data));
557 TEST_EQUALITY(data.size(),b_loc->getMapForBlock(2)->NumMyElements());
558 TEST_EQUALITY(data.size(),dd_data.size());
559 dd_count = 0;
560 for(int i=0;i<data.size();i++) {
561
562 double target = 789.0+myRank;
563 if(dd_data[i]==0.0)
564 { TEST_EQUALITY(data[i],0.0); }
565 else
566 { TEST_EQUALITY(data[i],target); dd_count++; }
567 }
568 TEST_EQUALITY(dd_count,2*workset.num_cells); // there are 2 nodes on the side and the sides are not shared
569
570 }
571
572 Teuchos::RCP<panzer::PureBasis> buildBasis(std::size_t worksetSize,const std::string & basisName)
573 {
574 Teuchos::RCP<shards::CellTopology> topo =
575 Teuchos::rcp(new shards::CellTopology(shards::getCellTopologyData< shards::Quadrilateral<4> >()));
576
577 panzer::CellData cellData(worksetSize,topo);
578 return Teuchos::rcp(new panzer::PureBasis(basisName,1,cellData));
579 }
580
581 Teuchos::RCP<panzer_stk::STK_Interface> buildMesh(int elemX,int elemY)
582 {
583 RCP<Teuchos::ParameterList> pl = rcp(new Teuchos::ParameterList);
584 pl->set("X Blocks",1);
585 pl->set("Y Blocks",1);
586 pl->set("X Elements",elemX);
587 pl->set("Y Elements",elemY);
588
589 panzer_stk::SquareQuadMeshFactory factory;
590 factory.setParameterList(pl);
591 RCP<panzer_stk::STK_Interface> mesh = factory.buildUncommitedMesh(MPI_COMM_WORLD);
592 factory.completeMeshConstruction(*mesh,MPI_COMM_WORLD);
593
594 return mesh;
595 }
596
597 void testInitialization(const Teuchos::RCP<Teuchos::ParameterList>& ipb)
598 {
599 // Physics block
600 ipb->setName("test physics");
601 {
602 Teuchos::ParameterList& p = ipb->sublist("a");
603 p.set("Type","Energy");
604 p.set("Prefix","");
605 p.set("Model ID","solid");
606 p.set("Basis Type","HGrad");
607 p.set("Basis Order",1);
608 p.set("Integration Order",1);
609 }
610 {
611 Teuchos::ParameterList& p = ipb->sublist("b");
612 p.set("Type","Energy");
613 p.set("Prefix","ION_");
614 p.set("Model ID","solid");
615 p.set("Basis Type","HCurl");
616 p.set("Basis Order",1);
617 p.set("Integration Order",1);
618 }
619
620 }
621
622 }