Debian Codegraph @

packages/panzer/adapters-stk/test/evaluator_tests/point_basis_values_evaluator.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_PureBasis.hpp"
24 #include "Panzer_BasisIRLayout.hpp"
25 #include "Panzer_Workset.hpp"
26 #include "Panzer_Workset_Utilities.hpp"
27 #include "Panzer_PointValues_Evaluator.hpp"
28 #include "Panzer_BasisValues_Evaluator.hpp"
29 #include "Panzer_DOF.hpp"
30 #include "Panzer_DOF_PointValues.hpp"
31 #include "Panzer_Constant.hpp"
32 #include "Panzer_IntegrationValues2.hpp"
33 #include "Panzer_BasisValues2.hpp"
34 #include "Panzer_DOFManager.hpp"
35 #include "Panzer_GlobalEvaluationDataContainer.hpp"
36
37 #include "Panzer_STK_Version.hpp"
38 #include "PanzerAdaptersSTK_config.hpp"
39 #include "Panzer_STK_Interface.hpp"
40 #include "Panzer_STK_SquareQuadMeshFactory.hpp"
41 #include "Panzer_STK_SetupUtilities.hpp"
42 #include "Panzer_STKConnManager.hpp"
43 #include "Panzer_STK_WorksetFactory.hpp"
44
45 #include "RandomFieldEvaluator.hpp"
46
47 #include "Teuchos_DefaultMpiComm.hpp"
48 #include "Teuchos_OpaqueWrapper.hpp"
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, int integration_order);
62 Teuchos::RCP<panzer_stk::STK_Interface> buildMesh(int elemX,int elemY);
63 Teuchos::RCP<panzer::IntegrationRule> buildIR(std::size_t worksetSize,int cubature_degree);
64
65 TEUCHOS_UNIT_TEST(point_values_evaluator, eval)
66 {
67
68 const std::size_t workset_size = 4;
69 const std::string fieldName_q1 = "U";
70 const std::string fieldName_qedge1 = "V";
71
72 Teuchos::RCP<panzer_stk::STK_Interface> mesh = buildMesh(2,2);
73
74 // build input physics block
75 Teuchos::RCP<panzer::PureBasis> basis_q1 = buildBasis(workset_size,"Q1");
76 panzer::CellData cell_data(workset_size, mesh->getCellTopology("eblock-0_0"));
77
78 const int integration_order = 1;
79 Teuchos::RCP<Teuchos::ParameterList> ipb = Teuchos::parameterList();
80 testInitialization(ipb,integration_order);
81
82 const int default_int_order = integration_order;
83 std::string eBlockID = "eblock-0_0";
84 Teuchos::RCP<user_app::MyFactory> eqset_factory = Teuchos::rcp(new user_app::MyFactory);
85 Teuchos::RCP<panzer::GlobalData> gd = panzer::createGlobalData();
86 Teuchos::RCP<panzer::PhysicsBlock> physicsBlock =
87 Teuchos::rcp(new PhysicsBlock(ipb,eBlockID,default_int_order,cell_data,eqset_factory,gd,false));
88
89 Teuchos::RCP<std::vector<panzer::Workset> > work_sets = panzer_stk::buildWorksets(*mesh,physicsBlock->elementBlockID(),
90 physicsBlock->getWorksetNeeds());
91 TEST_EQUALITY(work_sets->size(),1);
92
93 int num_points = 3;
94 RCP<const panzer::PointRule> point_rule = rcp(new panzer::PointRule("RandomPoints",num_points, cell_data));
95 RCP<const panzer::PointRule> point_rule_basis = rcp(new panzer::PointRule("BasisPoints",basis_q1->cardinality(), cell_data));
96
97 Teuchos::RCP<Kokkos::DynRankView<double,PHX::Device> > userArray
98 = Teuchos::rcp(new Kokkos::DynRankView<double,PHX::Device>("userArray",num_points,2));
99 Kokkos::DynRankView<double,PHX::Device>& point_coordinates = *userArray;
100 auto point_coordinates_h = Kokkos::create_mirror_view(point_coordinates);
101 point_coordinates_h(0,0) = 0.0; point_coordinates_h(0,1) = 0.0; // mid point
102 point_coordinates_h(1,0) = 0.5; point_coordinates_h(1,1) = 0.5; // mid point of upper left quadrant
103 point_coordinates_h(2,0) = -0.5; point_coordinates_h(2,1) = 0.0; // mid point of line from center to left side
104 Kokkos::deep_copy(point_coordinates, point_coordinates_h);
105
106 // setup field manager, add evaluator under test
107 /////////////////////////////////////////////////////////////
108
109 PHX::FieldManager<panzer::Traits> fm;
110
111 {
112 Teuchos::RCP<PHX::Evaluator<panzer::Traits> > evaluator
113 = Teuchos::rcp(new panzer::PointValues_Evaluator<panzer::Traits::Residual,panzer::Traits>(point_rule,*userArray));
114
115 TEST_EQUALITY(evaluator->evaluatedFields().size(),6);
116
117 fm.registerEvaluator<panzer::Traits::Residual>(evaluator);
118 auto required_fields = evaluator->evaluatedFields();
119 for (const auto& f : required_fields)
120 fm.requireField<panzer::Traits::Residual>(*f);
121 }
122
123 {
124 Teuchos::RCP<PHX::Evaluator<panzer::Traits> > evaluator
125 = Teuchos::rcp(new panzer::PointValues_Evaluator<panzer::Traits::Residual,panzer::Traits>(point_rule_basis,basis_q1));
126
127 TEST_EQUALITY(evaluator->evaluatedFields().size(),6);
128
129 fm.registerEvaluator<panzer::Traits::Residual>(evaluator);
130 auto required_fields = evaluator->evaluatedFields();
131 for (const auto& f : required_fields)
132 fm.requireField<panzer::Traits::Residual>(*f);
133 }
134
135 {
136 Teuchos::RCP<PHX::Evaluator<panzer::Traits> > evaluator
137 = Teuchos::rcp(new panzer::PointValues_Evaluator<panzer::Traits::Jacobian,panzer::Traits>(point_rule,*userArray));
138
139 TEST_EQUALITY(evaluator->evaluatedFields().size(),6);
140
141 fm.registerEvaluator<panzer::Traits::Jacobian>(evaluator);
142 fm.requireField<panzer::Traits::Jacobian>(*evaluator->evaluatedFields()[0]);
143 }
144
145 panzer::Traits::SD sd;
146 sd.worksets_ = work_sets;
147 // run tests
148 /////////////////////////////////////////////////////////////
149
150 panzer::Workset & workset = (*work_sets)[0];
151 workset.alpha = 0.0;
152 workset.beta = 0.0;
153 workset.time = 0.0;
154 workset.evaluate_transient_terms = false;
155
156 std::vector<PHX::index_size_type> derivative_dimensions;
157 derivative_dimensions.push_back(8);
158 fm.setKokkosExtendedDataTypeDimensions<panzer::Traits::Jacobian>(derivative_dimensions);
159
160 fm.postRegistrationSetup(sd);
161 fm.print(out);
162
163 fm.evaluateFields<panzer::Traits::Residual>(workset);
164 fm.evaluateFields<panzer::Traits::Jacobian>(workset);
165
166 PHX::MDField<panzer::Traits::Residual::ScalarT>
167 point_coords(point_rule->getName()+"_"+"point_coords",point_rule->dl_vector);
168 fm.getFieldData<panzer::Traits::Residual>(point_coords);
169
170 PHX::MDField<panzer::Traits::Residual::ScalarT>
171 point_coords_basis(point_rule_basis->getName()+"_"+"point_coords",point_rule_basis->dl_vector);
172 fm.getFieldData<panzer::Traits::Residual>(point_coords_basis);
173
174 PHX::MDField<panzer::Traits::Residual::ScalarT,Cell,IP>
175 point_coords_jac_det(point_rule_basis->getName()+"_"+"jac_det",point_rule_basis->dl_scalar);
176 fm.getFieldData<panzer::Traits::Residual,panzer::Traits::Residual::ScalarT,Cell,IP>(point_coords_jac_det);
177
178 PHX::MDField<panzer::Traits::Residual::ScalarT,Cell,IP,Dim,Dim>
179 point_coords_jac(point_rule_basis->getName()+"_"+"jac",point_rule_basis->dl_tensor);
180 fm.getFieldData<panzer::Traits::Residual,panzer::Traits::Residual::ScalarT,Cell,IP,Dim,Dim>(point_coords_jac);
181
182 PHX::MDField<panzer::Traits::Residual::ScalarT,Cell,IP,Dim,Dim>
183 point_coords_jac_inv(point_rule_basis->getName()+"_"+"jac_inv",point_rule_basis->dl_tensor);
184 fm.getFieldData<panzer::Traits::Residual,panzer::Traits::Residual::ScalarT,Cell,IP,Dim,Dim>(point_coords_jac_inv);
185
186 auto point_coords_h = Kokkos::create_mirror_view(point_coords.get_view());
187 Kokkos::deep_copy(point_coords_h, point_coords.get_view());
188 auto point_coords_basis_h = Kokkos::create_mirror_view(point_coords_basis.get_view());
189 Kokkos::deep_copy(point_coords_basis_h, point_coords_basis.get_view());
190 auto point_coords_jac_det_h = Kokkos::create_mirror_view(point_coords_jac_det.get_view());
191 Kokkos::deep_copy(point_coords_jac_det_h, point_coords_jac_det.get_view());
192 auto point_coords_jac_h = Kokkos::create_mirror_view(point_coords_jac.get_view());
193 Kokkos::deep_copy(point_coords_jac_h, point_coords_jac.get_view());
194 auto point_coords_jac_inv_h = Kokkos::create_mirror_view(point_coords_jac_inv.get_view());
195 Kokkos::deep_copy(point_coords_jac_inv_h, point_coords_jac_inv.get_view());
196 auto cell_node_coordinates_h = Kokkos::create_mirror_view(workset.cell_node_coordinates.get_view());
197 Kokkos::deep_copy(cell_node_coordinates_h, workset.cell_node_coordinates.get_view());
198 auto basis_coordinates_ref_h = Kokkos::create_mirror_view(workset.bases[1]->basis_coordinates_ref.get_view());
199 Kokkos::deep_copy(basis_coordinates_ref_h, workset.bases[1]->basis_coordinates_ref.get_view());
200 for(int c=0;c<basis_q1->numCells();c++) {
201 double dx = 0.5;
202 double dy = 0.5;
203 for(int p=0;p<num_points;p++) {
204 double x = dx*(point_coordinates_h(p,0)+1.0)/2.0 + cell_node_coordinates_h(c,0,0);
205 double y = dy*(point_coordinates_h(p,1)+1.0)/2.0 + cell_node_coordinates_h(c,0,1);
206 TEST_FLOATING_EQUALITY(point_coords_h(c,p,0),x,1e-10);
207 TEST_FLOATING_EQUALITY(point_coords_h(c,p,1),y,1e-10);
208 }
209
210 for(int p=0;p<basis_q1->cardinality();p++) {
211 double x = dx*(basis_coordinates_ref_h(p,0)+1.0)/2.0 + cell_node_coordinates_h(c,0,0);
212 double y = dy*(basis_coordinates_ref_h(p,1)+1.0)/2.0 + cell_node_coordinates_h(c,0,1);
213 TEST_FLOATING_EQUALITY(point_coords_basis_h(c,p,0),x,1e-10);
214 TEST_FLOATING_EQUALITY(point_coords_basis_h(c,p,1),y,1e-10);
215 }
216
217 for(int p=0;p<num_points;p++)
218 TEST_FLOATING_EQUALITY(point_coords_jac_det_h(c,p),dx*dy/4.0,1e-10);
219
220 for(int p=0;p<num_points;p++) {
221 TEST_FLOATING_EQUALITY(point_coords_jac_h(c,p,0,0),dx/2.0,1e-10);
222 TEST_FLOATING_EQUALITY(point_coords_jac_h(c,p,0,1),0.0,1e-10);
223 TEST_FLOATING_EQUALITY(point_coords_jac_h(c,p,1,0),0.0,1e-10);
224 TEST_FLOATING_EQUALITY(point_coords_jac_h(c,p,1,1),dy/2.0,1e-10);
225 }
226
227 for(int p=0;p<num_points;p++) {
228 TEST_FLOATING_EQUALITY(point_coords_jac_inv_h(c,p,0,0),1.0/(dx/2.0),1e-10);
229 TEST_FLOATING_EQUALITY(point_coords_jac_inv_h(c,p,0,1),0.0,1e-10);
230 TEST_FLOATING_EQUALITY(point_coords_jac_inv_h(c,p,1,0),0.0,1e-10);
231 TEST_FLOATING_EQUALITY(point_coords_jac_inv_h(c,p,1,1),1.0/(dy/2.0),1e-10);
232 }
233 }
234 }
235
236 TEUCHOS_UNIT_TEST(basis_values_evaluator, eval)
237 {
238
239 const std::size_t workset_size = 4;
240 const std::string fieldName_q1 = "U";
241 const std::string fieldName_qedge1 = "V";
242
243 Teuchos::RCP<panzer_stk::STK_Interface> mesh = buildMesh(2,2);
244
245 // build input physics block
246 Teuchos::RCP<panzer::PureBasis> basis_q1 = buildBasis(workset_size,"Q1");
247 panzer::CellData cell_data(basis_q1->numCells(), basis_q1->getCellTopology());
248
249 int integration_order = 4;
250 Teuchos::RCP<Teuchos::ParameterList> ipb = Teuchos::parameterList();
251 testInitialization(ipb,integration_order);
252
253 const int default_int_order = integration_order;
254 std::string eBlockID = "eblock-0_0";
255 Teuchos::RCP<user_app::MyFactory> eqset_factory = Teuchos::rcp(new user_app::MyFactory);
256 panzer::CellData cellData(workset_size,mesh->getCellTopology("eblock-0_0"));
257 Teuchos::RCP<panzer::GlobalData> gd = panzer::createGlobalData();
258 Teuchos::RCP<panzer::PhysicsBlock> physicsBlock =
259 Teuchos::rcp(new PhysicsBlock(ipb,eBlockID,default_int_order,cellData,eqset_factory,gd,false));
260
261 Teuchos::RCP<std::vector<panzer::Workset> > work_sets = panzer_stk::buildWorksets(*mesh,physicsBlock->elementBlockID(),
262 physicsBlock->getWorksetNeeds());
263 panzer::Workset & workset = (*work_sets)[0];
264 TEST_EQUALITY(work_sets->size(),1);
265
266 Teuchos::RCP<panzer::IntegrationRule> point_rule = buildIR(workset_size,integration_order);
267 panzer::IntegrationValues2<double> int_values("",true);
268 int_values.setupArrays(point_rule);
269 int_values.evaluateValues(workset.cell_node_coordinates);
270
271 // Teuchos::RCP<Kokkos::DynRankView<double,PHX::Device> > userArray = Teuchos::rcpFromRef(int_values.cub_points);
272 auto userArray = int_values.cub_points;
273
274 Teuchos::RCP<panzer::BasisIRLayout> layout = Teuchos::rcp(new panzer::BasisIRLayout(basis_q1,*point_rule));
275
276 // setup field manager, add evaluator under test
277 /////////////////////////////////////////////////////////////
278
279 PHX::FieldManager<panzer::Traits> fm;
280
281 Teuchos::RCP<const std::vector<Teuchos::RCP<PHX::FieldTag > > > evalJacFields;
282 {
283 Teuchos::RCP<PHX::Evaluator<panzer::Traits> > evaluator
284 = Teuchos::rcp(new panzer::PointValues_Evaluator<panzer::Traits::Jacobian,panzer::Traits>(point_rule,userArray));
285 fm.registerEvaluator<panzer::Traits::Jacobian>(evaluator);
286 }
287 {
288 Teuchos::RCP<PHX::Evaluator<panzer::Traits> > evaluator
289 = Teuchos::rcp(new panzer::BasisValues_Evaluator<panzer::Traits::Jacobian,panzer::Traits>(point_rule,basis_q1));
290
291 TEST_EQUALITY(evaluator->evaluatedFields().size(),4);
292 evalJacFields = Teuchos::rcpFromRef(evaluator->evaluatedFields());
293
294 fm.registerEvaluator<panzer::Traits::Jacobian>(evaluator);
295 fm.requireField<panzer::Traits::Jacobian>(*evaluator->evaluatedFields()[0]);
296 }
297
298 std::vector<PHX::index_size_type> derivative_dimensions;
299 derivative_dimensions.push_back(8);
300 fm.setKokkosExtendedDataTypeDimensions<panzer::Traits::Jacobian>(derivative_dimensions);
301
302 panzer::Traits::SD sd;
303 fm.postRegistrationSetup(sd);
304 fm.print(out);
305
306 // run tests
307 /////////////////////////////////////////////////////////////
308
309 workset.alpha = 0.0;
310 workset.beta = 0.0;
311 workset.time = 0.0;
312 workset.evaluate_transient_terms = false;
313
314 fm.evaluateFields<panzer::Traits::Jacobian>(workset);
315
316 PHX::MDField<panzer::Traits::Residual::ScalarT,panzer::Cell,panzer::BASIS,panzer::IP>
317 basis(basis_q1->name()+"_"+point_rule->getName()+"_"+"basis",layout->basis);
318 fm.getFieldData<panzer::Traits::Jacobian>(basis);
319 out << basis << std::endl;
320
321 WorksetDetailsAccessor wda;
322 std::size_t basisIndex = panzer::getBasisIndex(layout->name(), workset, wda);
323 Teuchos::RCP<panzer::BasisValues2<double> > bases = workset.bases[basisIndex];
324 TEST_ASSERT(bases!=Teuchos::null);
325 // TEST_EQUALITY(bases->basis.size(),basis.size());
326 auto basis_h = Kokkos::create_mirror_view(basis.get_view());
327 Kokkos::deep_copy(basis_h, basis.get_view());
328 auto basis_scalar_h = Kokkos::create_mirror_view(bases->basis_scalar.get_static_view());
329 Kokkos::deep_copy(basis_scalar_h, bases->basis_scalar.get_static_view());
330 for(int i=0;i<4;i++) {
331 for(int j=0;j<4;j++) {
332 for(unsigned int k=0;k<bases->basis_scalar.extent(2);k++) {
333 TEST_FLOATING_EQUALITY(basis_scalar_h(i,j,k),basis_h(i,j,k),1e-10);
334 }
335 }
336 }
337 }
338
339 TEUCHOS_UNIT_TEST(basis_values_evaluator, eval_vector)
340 {
341 typedef Intrepid2::Basis<PHX::Device::execution_space,double,double> IntrepidBasis;
342
343 const std::size_t workset_size = 4;
344 const std::string fieldName = "U";
345
346 Teuchos::RCP<panzer_stk::STK_Interface> mesh = buildMesh(2,2);
347
348 // build input physics block
349 Teuchos::RCP<panzer::PureBasis> basis_edge = buildBasis(workset_size,"HCurl");
350 panzer::CellData cell_data(basis_edge->numCells(), basis_edge->getCellTopology());
351
352 int integration_order = 4;
353 Teuchos::RCP<Teuchos::ParameterList> ipb = Teuchos::parameterList();
354 testInitialization(ipb,integration_order);
355
356 std::string eBlockID = "eblock-0_0";
357 Teuchos::RCP<user_app::MyFactory> eqset_factory = Teuchos::rcp(new user_app::MyFactory);
358 panzer::CellData cellData(workset_size,mesh->getCellTopology("eblock-0_0"));
359 Teuchos::RCP<panzer::GlobalData> gd = panzer::createGlobalData();
360 Teuchos::RCP<panzer::PhysicsBlock> physicsBlock =
361 Teuchos::rcp(new PhysicsBlock(ipb,eBlockID,integration_order,cellData,eqset_factory,gd,false));
362
363 std::map<std::string,WorksetNeeds> needs;
364 needs[physicsBlock->elementBlockID()] = physicsBlock->getWorksetNeeds();
365
366 // build DOF Manager (with a single HDiv basis)
367 /////////////////////////////////////////////////////////////
368
369 // build the connection manager
370 const RCP<panzer::ConnManager>
371 conn_manager = rcp(new panzer_stk::STKConnManager(mesh));
372
373 RCP<panzer::DOFManager> dof_manager
374 = rcp(new panzer::DOFManager(conn_manager,MPI_COMM_WORLD));
375
376 // build an intrepid basis and a related field pattern for seeding the DOFManager
377 {
378 RCP<IntrepidBasis> hgrad_intrepid_basis;
379 hgrad_intrepid_basis
380 = panzer::createIntrepid2Basis<PHX::Device::execution_space,double,double>("HGrad",1,
381 *mesh->getCellTopology(physicsBlock->elementBlockID()));
382 RCP<panzer::Intrepid2FieldPattern> hgrad_field_pattern = rcp(new panzer::Intrepid2FieldPattern(hgrad_intrepid_basis));
383
384 dof_manager->addField(physicsBlock->elementBlockID(), fieldName, hgrad_field_pattern);
385 }
386 dof_manager->buildGlobalUnknowns();
387
388 /////////////////////////////////////////////////////////////
389
390 RCP<panzer_stk::WorksetFactory> wkstFactory
391 = rcp(new panzer_stk::WorksetFactory(mesh)); // build STK workset factory
392 RCP<panzer::WorksetContainer> wkstContainer // attach it to a workset container (uses lazy evaluation)
393 = rcp(new panzer::WorksetContainer(wkstFactory,needs));
394 wkstContainer->setGlobalIndexer(dof_manager);
395 wkstContainer->setWorksetSize(workset_size);
396
397 Teuchos::RCP<std::vector<panzer::Workset> > work_sets = wkstContainer->getWorksets(blockDescriptor(physicsBlock->elementBlockID()));
398 panzer::Workset & workset = (*work_sets)[0];
399 TEST_EQUALITY(work_sets->size(),1);
400
401 Teuchos::RCP<panzer::IntegrationRule> point_rule = buildIR(workset_size,integration_order);
402 panzer::IntegrationValues2<double> int_values("",true);
403 int_values.setupArrays(point_rule);
404 int_values.evaluateValues(workset.cell_node_coordinates);
405
406 // Teuchos::RCP<Kokkos::DynRankView<double,PHX::Device> > userArray = Teuchos::rcpFromRef(int_values.cub_points);
407 auto userArray = int_values.cub_points;
408
409 Teuchos::RCP<panzer::BasisIRLayout> layout = Teuchos::rcp(new panzer::BasisIRLayout(basis_edge,*point_rule));
410
411 // setup field manager, add evaluator under test
412 /////////////////////////////////////////////////////////////
413
414 PHX::FieldManager<panzer::Traits> fm;
415
416 Teuchos::RCP<const std::vector<Teuchos::RCP<PHX::FieldTag > > > evalJacFields;
417 {
418 Teuchos::ParameterList input;
419 input.set("Name", "HCurl:1 Orientation");
420 input.set("Value", 1.0);
421 input.set("Data Layout", basis_edge->functional);
422 Teuchos::RCP< PHX::Evaluator<panzer::Traits> > evaluator
423 = rcp(new panzer::Constant<panzer::Traits::Jacobian,panzer::Traits>(input));
424 fm.registerEvaluator<panzer::Traits::Jacobian>(evaluator);
425 }
426 {
427 Teuchos::RCP<PHX::Evaluator<panzer::Traits> > evaluator
428 = Teuchos::rcp(new panzer::PointValues_Evaluator<panzer::Traits::Jacobian,panzer::Traits>(point_rule,userArray));
429 fm.registerEvaluator<panzer::Traits::Jacobian>(evaluator);
430 }
431 {
432 Teuchos::RCP<PHX::Evaluator<panzer::Traits> > evaluator
433 = Teuchos::rcp(new panzer::BasisValues_Evaluator<panzer::Traits::Jacobian,panzer::Traits>(point_rule,basis_edge));
434
435 TEST_EQUALITY(evaluator->evaluatedFields().size(),4);
436 evalJacFields = Teuchos::rcpFromRef(evaluator->evaluatedFields());
437
438 fm.registerEvaluator<panzer::Traits::Jacobian>(evaluator);
439 fm.requireField<panzer::Traits::Jacobian>(*evaluator->evaluatedFields()[0]);
440 out << "REQUIRED FIELD = \"";
441 evaluator->evaluatedFields()[0]->print(out);
442 out << "\"" << std::endl;
443 }
444
445 std::vector<PHX::index_size_type> derivative_dimensions;
446 derivative_dimensions.push_back(4);
447 fm.setKokkosExtendedDataTypeDimensions<panzer::Traits::Jacobian>(derivative_dimensions);
448
449 panzer::Traits::SD sd;
450 sd.orientations_ = wkstContainer->getOrientations();
451 fm.postRegistrationSetup(sd);
452 fm.print(out);
453
454 // run tests
455 /////////////////////////////////////////////////////////////
456
457 workset.alpha = 0.0;
458 workset.beta = 0.0;
459 workset.time = 0.0;
460 workset.evaluate_transient_terms = false;
461
462 fm.evaluateFields<panzer::Traits::Jacobian>(workset);
463
464 // NOTE: basis values are always double, not Fad.
465 PHX::MDField<panzer::Traits::Residual::ScalarT,Cell,BASIS,IP,Dim>
466 basis(basis_edge->name()+"_"+point_rule->getName()+"_basis",layout->basis_grad);
467 PHX::MDField<panzer::Traits::Residual::ScalarT,Cell,BASIS,IP>
468 curl_basis(basis_edge->name()+"_"+point_rule->getName()+"_curl_basis",layout->basis);
469 PHX::MDField<panzer::Traits::Residual::ScalarT,Cell,IP,Dim,Dim>
470 jac_inv("CubaturePoints (Degree=4,volume)_jac_inv",point_rule->dl_tensor);
471
472 fm.getFieldData<panzer::Traits::Jacobian,panzer::Traits::Residual::ScalarT,Cell,BASIS,IP,Dim>(basis);
473 fm.getFieldData<panzer::Traits::Jacobian,panzer::Traits::Residual::ScalarT,Cell,BASIS,IP>(curl_basis);
474 fm.getFieldData<panzer::Traits::Jacobian,panzer::Traits::Residual::ScalarT,Cell,IP,Dim,Dim>(jac_inv);
475
476 WorksetDetailsAccessor wda;
477 std::size_t basisIndex = panzer::getBasisIndex(layout->name(), workset, wda);
478 Teuchos::RCP<panzer::BasisValues2<double> > bases = workset.bases[basisIndex];
479 TEST_ASSERT(bases!=Teuchos::null);
480 TEST_EQUALITY(bases->basis_vector.size(),basis.size());
481 TEST_EQUALITY(bases->curl_basis_scalar.size(),curl_basis.size());
482
483 auto basis_h = Kokkos::create_mirror_view(basis.get_view());
484 Kokkos::deep_copy(basis_h, basis.get_view());
485 auto basis_vector_h = Kokkos::create_mirror_view(bases->basis_vector.get_static_view());
486 Kokkos::deep_copy(basis_vector_h,bases->basis_vector.get_static_view());
487 for(int i=0;i<4;i++) {
488 for(int j=0;j<4;j++) {
489 for(unsigned int k=0;k<bases->curl_basis_scalar.extent(2);k++) {
490 for(unsigned int d=0;d<bases->basis_vector.extent(3);d++) {
491 TEST_FLOATING_EQUALITY(basis_vector_h(i,j,k,d),basis_h(i,j,k,d),1e-10);
492 }
493 }
494 }
495 }
496
497 auto curl_basis_h = Kokkos::create_mirror_view(curl_basis.get_view());
498 Kokkos::deep_copy(curl_basis_h, curl_basis.get_view());
499 auto curl_basis_scalar_h = Kokkos::create_mirror_view(bases->curl_basis_scalar.get_static_view());
500 Kokkos::deep_copy(curl_basis_scalar_h,bases->curl_basis_scalar.get_static_view());
501 for(int i=0;i<4;i++) {
502 for(int j=0;j<4;j++) {
503 for(unsigned int k=0;k<bases->curl_basis_scalar.extent(2);k++) {
504 TEST_FLOATING_EQUALITY(curl_basis_scalar_h(i,j,k),curl_basis_h(i,j,k),1e-10);
505 }
506 }
507 }
508 }
509
510 TEUCHOS_UNIT_TEST(dof_point_values_evaluator, eval)
511 {
512 typedef Intrepid2::Basis<PHX::Device::execution_space,double,double> IntrepidBasis;
513
514 const std::size_t workset_size = 4;
515 const std::string fieldName_q1 = "U";
516 const std::string fieldName_qedge1 = "V";
517
518 Teuchos::RCP<panzer_stk::STK_Interface> mesh = buildMesh(2,2);
519
520 // build input physics block
521 Teuchos::RCP<panzer::PureBasis> basis_q1 = buildBasis(workset_size,"Q1");
522 panzer::CellData cell_data(basis_q1->numCells(), basis_q1->getCellTopology());
523
524 int integration_order = 4;
525 Teuchos::RCP<Teuchos::ParameterList> ipb = Teuchos::parameterList();
526 testInitialization(ipb,integration_order);
527
528 const int default_int_order = integration_order;
529 std::string eBlockID = "eblock-0_0";
530 Teuchos::RCP<user_app::MyFactory> eqset_factory = Teuchos::rcp(new user_app::MyFactory);
531 panzer::CellData cellData(workset_size,mesh->getCellTopology("eblock-0_0"));
532 Teuchos::RCP<panzer::GlobalData> gd = panzer::createGlobalData();
533 Teuchos::RCP<panzer::PhysicsBlock> physicsBlock =
534 Teuchos::rcp(new PhysicsBlock(ipb,eBlockID,default_int_order,cellData,eqset_factory,gd,false));
535
536 std::map<std::string,WorksetNeeds> needs;
537 needs[physicsBlock->elementBlockID()] = physicsBlock->getWorksetNeeds();
538
539 // build DOF Manager (with a single HDiv basis)
540 /////////////////////////////////////////////////////////////
541
542 // build the connection manager
543 const RCP<panzer::ConnManager>
544 conn_manager = rcp(new panzer_stk::STKConnManager(mesh));
545
546 RCP<panzer::DOFManager> dof_manager
547 = rcp(new panzer::DOFManager(conn_manager,MPI_COMM_WORLD));
548
549 // build an intrepid basis and a related field pattern for seeding the DOFManager
550 {
551 RCP<IntrepidBasis> hgrad_intrepid_basis, hcurl_intrepid_basis;
552 hgrad_intrepid_basis
553 = panzer::createIntrepid2Basis<PHX::Device::execution_space,double,double>("HGrad",1,
554 *mesh->getCellTopology(physicsBlock->elementBlockID()));
555 hcurl_intrepid_basis
556 = panzer::createIntrepid2Basis<PHX::Device::execution_space,double,double>("HCurl",1,
557 *mesh->getCellTopology(physicsBlock->elementBlockID()));
558 RCP<panzer::Intrepid2FieldPattern> hgrad_field_pattern = rcp(new panzer::Intrepid2FieldPattern(hgrad_intrepid_basis));
559 RCP<panzer::Intrepid2FieldPattern> hcurl_field_pattern = rcp(new panzer::Intrepid2FieldPattern(hcurl_intrepid_basis));
560
561 dof_manager->addField(physicsBlock->elementBlockID(), fieldName_q1, hgrad_field_pattern);
562 dof_manager->addField(physicsBlock->elementBlockID(), fieldName_qedge1, hcurl_field_pattern);
563 }
564 dof_manager->buildGlobalUnknowns();
565
566 /////////////////////////////////////////////////////////////
567
568 RCP<panzer_stk::WorksetFactory> wkstFactory
569 = rcp(new panzer_stk::WorksetFactory(mesh)); // build STK workset factory
570 RCP<panzer::WorksetContainer> wkstContainer // attach it to a workset container (uses lazy evaluation)
571 = rcp(new panzer::WorksetContainer(wkstFactory,needs));
572 wkstContainer->setGlobalIndexer(dof_manager);
573 wkstContainer->setWorksetSize(workset_size);
574
575 // Teuchos::RCP<std::vector<panzer::Workset> > work_sets = panzer_stk::buildWorksets(*mesh,physicsBlock->elementBlockID(),
576 // physicsBlock->getWorksetNeeds());
577 Teuchos::RCP<std::vector<panzer::Workset> > work_sets = wkstContainer->getWorksets(blockDescriptor(physicsBlock->elementBlockID()));
578 panzer::Workset & workset = (*work_sets)[0];
579
580 TEST_EQUALITY(work_sets->size(),1);
581
582 Teuchos::RCP<panzer::IntegrationRule> point_rule = buildIR(workset_size,integration_order);
583 panzer::IntegrationValues2<double> int_values("",true);
584 int_values.setupArrays(point_rule);
585 int_values.evaluateValues(workset.cell_node_coordinates);
586
587 // Teuchos::RCP<Kokkos::DynRankView<double,PHX::Device> > userArray = Teuchos::rcpFromRef(int_values.cub_points);
588 auto userArray = int_values.cub_points;
589
590 Teuchos::RCP<panzer::BasisIRLayout> layout = Teuchos::rcp(new panzer::BasisIRLayout(basis_q1,*point_rule));
591
592 // setup field manager, add evaluator under test
593 /////////////////////////////////////////////////////////////
594
595 PHX::FieldManager<panzer::Traits> fm;
596 {
597 Teuchos::RCP<PHX::Evaluator<panzer::Traits> > evaluator
598 = Teuchos::rcp(new RandomFieldEvaluator<panzer::Traits::Jacobian,panzer::Traits>("TEMPERATURE",basis_q1->functional));
599 fm.registerEvaluator<panzer::Traits::Jacobian>(evaluator);
600 }
601 {
602 Teuchos::RCP<PHX::Evaluator<panzer::Traits> > evaluator
603 = Teuchos::rcp(new panzer::PointValues_Evaluator<panzer::Traits::Jacobian,panzer::Traits>(point_rule,userArray));
604 fm.registerEvaluator<panzer::Traits::Jacobian>(evaluator);
605 }
606 {
607 Teuchos::RCP<PHX::Evaluator<panzer::Traits> > evaluator
608 = Teuchos::rcp(new panzer::BasisValues_Evaluator<panzer::Traits::Jacobian,panzer::Traits>(point_rule,basis_q1));
609 fm.registerEvaluator<panzer::Traits::Jacobian>(evaluator);
610 }
611 {
612 Teuchos::ParameterList p;
613 p.set("Name","TEMPERATURE");
614 p.set("Basis",layout);
615 p.set("IR",point_rule);
616 Teuchos::RCP<PHX::Evaluator<panzer::Traits> > evaluator
617 = Teuchos::rcp(new panzer::DOF<panzer::Traits::Jacobian,panzer::Traits>(p));
618 fm.registerEvaluator<panzer::Traits::Jacobian>(evaluator);
619 fm.requireField<panzer::Traits::Jacobian>(*evaluator->evaluatedFields()[0]); // require DOF
620 }
621 {
622 Teuchos::ParameterList p;
623 p.set("Name","TEMPERATURE");
624 p.set("Basis",layout->getBasis().getConst());
625 p.set("Point Rule",Teuchos::rcp_static_cast<panzer::PointRule>(point_rule).getConst());
626 Teuchos::RCP<PHX::Evaluator<panzer::Traits> > evaluator
627 = Teuchos::rcp(new panzer::DOF_PointValues<panzer::Traits::Jacobian,panzer::Traits>(p));
628
629 fm.registerEvaluator<panzer::Traits::Jacobian>(evaluator);
630 fm.requireField<panzer::Traits::Jacobian>(*evaluator->evaluatedFields()[0]); // require DOF_PointValues
631 }
632
633 std::vector<PHX::index_size_type> derivative_dimensions;
634 derivative_dimensions.push_back(8);
635 fm.setKokkosExtendedDataTypeDimensions<panzer::Traits::Jacobian>(derivative_dimensions);
636
637 panzer::Traits::SD sd;
638 sd.orientations_ = wkstContainer->getOrientations();
639 sd.worksets_ = work_sets;
640 fm.postRegistrationSetup(sd);
641 fm.print(out);
642
643 // run tests
644 /////////////////////////////////////////////////////////////
645
646 workset.alpha = 0.0;
647 workset.beta = 0.0;
648 workset.time = 0.0;
649 workset.evaluate_transient_terms = false;
650
651 panzer::Traits::PED ped;
652 fm.preEvaluate<panzer::Traits::Jacobian>(ped);
653 fm.evaluateFields<panzer::Traits::Jacobian>(workset);
654 fm.postEvaluate<panzer::Traits::Jacobian>(NULL);
655
656 PHX::MDField<panzer::Traits::Jacobian::ScalarT> ref_field("TEMPERATURE",point_rule->dl_scalar);
657 PHX::MDField<panzer::Traits::Jacobian::ScalarT> fut_field("TEMPERATURE_"+point_rule->getName(),point_rule->dl_scalar); // "field under test"
658 fm.getFieldData<panzer::Traits::Jacobian>(ref_field);
659 fm.getFieldData<panzer::Traits::Jacobian>(fut_field);
660
661 TEST_EQUALITY(ref_field.size(),fut_field.size());
662 // for(int i=0;i<ref_field.size();i++) {
663 // TEST_FLOATING_EQUALITY(fut_field[i].val(),ref_field[i].val(),1e-10);
664 // }
665 auto fut_field_h = Kokkos::create_mirror_view(fut_field.get_view());
666 Kokkos::deep_copy(fut_field_h, fut_field.get_view());
667 auto ref_field_h = Kokkos::create_mirror_view(ref_field.get_view());
668 Kokkos::deep_copy(ref_field_h, ref_field.get_view());
669 for(int i=0;i<4;i++) {
670 for(int j=0;j<4;j++) {
671 TEST_FLOATING_EQUALITY(fut_field_h(i,j).val(),ref_field_h(i,j).val(),1e-10);
672 }
673 }
674 }
675
676 Teuchos::RCP<panzer::PureBasis> buildBasis(std::size_t worksetSize,const std::string & basisName)
677 {
678 Teuchos::RCP<shards::CellTopology> topo =
679 Teuchos::rcp(new shards::CellTopology(shards::getCellTopologyData< shards::Quadrilateral<4> >()));
680
681 panzer::CellData cellData(worksetSize,topo);
682 return Teuchos::rcp(new panzer::PureBasis(basisName,1,cellData));
683 }
684
685 Teuchos::RCP<panzer::IntegrationRule> buildIR(std::size_t workset_size,int cubature_degree)
686 {
687 Teuchos::RCP<shards::CellTopology> topo =
688 Teuchos::rcp(new shards::CellTopology(shards::getCellTopologyData< shards::Quadrilateral<4> >()));
689
690 const panzer::CellData cell_data(workset_size, topo);
691
692 return Teuchos::rcp(new panzer::IntegrationRule(cubature_degree, cell_data));
693 }
694
695 Teuchos::RCP<panzer_stk::STK_Interface> buildMesh(int elemX,int elemY)
696 {
697 RCP<Teuchos::ParameterList> pl = rcp(new Teuchos::ParameterList);
698 pl->set("X Blocks",1);
699 pl->set("Y Blocks",1);
700 pl->set("X Elements",elemX);
701 pl->set("Y Elements",elemY);
702
703 panzer_stk::SquareQuadMeshFactory factory;
704 factory.setParameterList(pl);
705 RCP<panzer_stk::STK_Interface> mesh = factory.buildUncommitedMesh(MPI_COMM_WORLD);
706 factory.completeMeshConstruction(*mesh,MPI_COMM_WORLD);
707
708 return mesh;
709 }
710
711 void testInitialization(const Teuchos::RCP<Teuchos::ParameterList>& ipb, int integration_order)
712 {
713 // Physics block
714 ipb->setName("test physics");
715 {
716 Teuchos::ParameterList& p = ipb->sublist("a");
717 p.set("Type","Energy");
718 p.set("Prefix","");
719 p.set("Model ID","solid");
720 p.set("Basis Type","HGrad");
721 p.set("Basis Order",1);
722 p.set("Integration Order",integration_order);
723 }
724 {
725 Teuchos::ParameterList& p = ipb->sublist("b");
726 p.set("Type","Energy");
727 p.set("Prefix","ION_");
728 p.set("Model ID","solid");
729 p.set("Basis Type","HCurl");
730 p.set("Basis Order",1);
731 p.set("Integration Order",integration_order);
732 }
733
734 }
735
736 }