43 #include "PanzerDiscFE_config.hpp" 48 #include "Kokkos_ViewFactory.hpp" 50 #include "Intrepid2_Utils.hpp" 51 #include "Intrepid2_FunctionSpaceTools.hpp" 52 #include "Intrepid2_Orientation.hpp" 53 #include "Intrepid2_OrientationTools.hpp" 58 template <
typename Scalar>
60 evaluateValues(
const PHX::MDField<Scalar,IP,Dim,void,void,void,void,void,void> & cub_points,
61 const PHX::MDField<Scalar,Cell,IP,Dim,Dim,void,void,void,void> &
jac,
62 const PHX::MDField<Scalar,Cell,IP,void,void,void,void,void,void> & jac_det,
63 const PHX::MDField<Scalar,Cell,IP,Dim,Dim,void,void,void,void> & jac_inv)
65 PHX::MDField<Scalar,Cell,IP> weighted_measure;
66 PHX::MDField<Scalar,Cell,NODE,Dim> vertex_coordinates;
67 build_weighted =
false;
68 evaluateValues(cub_points,
jac,jac_det,jac_inv,weighted_measure,vertex_coordinates,
false);
71 template <
typename Scalar>
73 evaluateValues(
const PHX::MDField<Scalar,IP,Dim,void,void,void,void,void,void> & cub_points,
74 const PHX::MDField<Scalar,Cell,IP,Dim,Dim,void,void,void,void> &
jac,
75 const PHX::MDField<Scalar,Cell,IP,void,void,void,void,void,void> & jac_det,
76 const PHX::MDField<Scalar,Cell,IP,Dim,Dim,void,void,void,void> & jac_inv,
77 const PHX::MDField<Scalar,Cell,IP> & weighted_measure,
78 const PHX::MDField<Scalar,Cell,NODE,Dim> & vertex_coordinates,
79 bool use_vertex_coordinates)
83 int num_dim = basis_layout->dimension();
87 evaluateReferenceValues(cub_points,compute_derivatives,use_vertex_coordinates);
92 Intrepid2::FunctionSpaceTools<PHX::Device::execution_space>::
93 HGRADtransformVALUE(basis_scalar.get_view(),
94 basis_ref_scalar.get_view());
97 Intrepid2::FunctionSpaceTools<PHX::Device::execution_space>::
98 multiplyMeasure(weighted_basis_scalar.get_view(),
99 weighted_measure.get_view(),
100 basis_scalar.get_view());
104 Intrepid2::FunctionSpaceTools<PHX::Device::execution_space>::
105 HCURLtransformVALUE(basis_vector.get_view(),
107 basis_ref_vector.get_view());
110 Intrepid2::FunctionSpaceTools<PHX::Device::execution_space>::
111 multiplyMeasure(weighted_basis_vector.get_view(),
112 weighted_measure.get_view(),
113 basis_vector.get_view());
118 Intrepid2::FunctionSpaceTools<PHX::Device::execution_space>::
119 HDIVtransformVALUE(basis_vector.get_view(),
122 basis_ref_vector.get_view());
125 Intrepid2::FunctionSpaceTools<PHX::Device::execution_space>::
126 multiplyMeasure(weighted_basis_vector.get_view(),
127 weighted_measure.get_view(),
128 basis_vector.get_view());
131 else { TEUCHOS_ASSERT(
false); }
134 Intrepid2::FunctionSpaceTools<PHX::Device::execution_space>::
135 HGRADtransformGRAD(grad_basis.get_view(),
137 grad_basis_ref.get_view());
140 Intrepid2::FunctionSpaceTools<PHX::Device::execution_space>::
141 multiplyMeasure(weighted_grad_basis.get_view(),
142 weighted_measure.get_view(),
143 grad_basis.get_view());
147 Intrepid2::FunctionSpaceTools<PHX::Device::execution_space>::
148 HDIVtransformDIV(curl_basis_scalar.get_view(),
152 curl_basis_ref_scalar.get_view());
155 Intrepid2::FunctionSpaceTools<PHX::Device::execution_space>::
156 multiplyMeasure(weighted_curl_basis_scalar.get_view(),
157 weighted_measure.get_view(),
158 curl_basis_scalar.get_view());
162 Intrepid2::FunctionSpaceTools<PHX::Device::execution_space>::
163 HCURLtransformCURL(curl_basis_vector.get_view(),
166 curl_basis_ref_vector.get_view());
169 Intrepid2::FunctionSpaceTools<PHX::Device::execution_space>::
170 multiplyMeasure(weighted_curl_basis_vector.get_view(),
171 weighted_measure.get_view(),
172 curl_basis_vector.get_view());
176 Intrepid2::FunctionSpaceTools<PHX::Device::execution_space>::
177 HDIVtransformDIV(div_basis.get_view(),
179 div_basis_ref.get_view());
182 Intrepid2::FunctionSpaceTools<PHX::Device::execution_space>::
183 multiplyMeasure(weighted_div_basis.get_view(),
184 weighted_measure.get_view(),
185 div_basis.get_view());
191 if(use_vertex_coordinates) {
205 Intrepid2::CellTools<PHX::Device::execution_space> cell_tools;
206 cell_tools.mapToPhysicalFrame(basis_coordinates.get_view(),
207 basis_coordinates_ref.get_view(),
208 vertex_coordinates.get_view(),
209 intrepid_basis->getBaseCellTopology());
219 template <
typename Scalar>
227 using coordsScalarType =
typename Intrepid2::Basis<PHX::Device::execution_space,Scalar,Scalar>::scalarType;
228 auto dyn_basis_coordinates_ref = af.
buildArray<coordsScalarType,BASIS,Dim>(
"basis_coordinates_ref",
229 basis_coordinates_ref.extent(0),
230 basis_coordinates_ref.extent(1));
231 intrepid_basis->getDofCoords(dyn_basis_coordinates_ref.get_view());
234 for (
int i = 0; i < basis_coordinates_ref.extent_int(0); ++i)
235 for (
int j = 0; j < basis_coordinates_ref.extent_int(1); ++j)
236 basis_coordinates_ref(i,j) = dyn_basis_coordinates_ref(i,j);
238 Intrepid2::CellTools<PHX::Device::execution_space> cell_tools;
239 cell_tools.mapToPhysicalFrame(basis_coordinates.get_view(),
240 basis_coordinates_ref.get_view(),
241 vertex_coordinates.get_view(),
242 intrepid_basis->getBaseCellTopology());
249 template <
typename Scalar>
251 evaluateValues(
const PHX::MDField<Scalar,Cell,IP,Dim,void,void,void,void,void> & cub_points,
252 const PHX::MDField<Scalar,Cell,IP,Dim,Dim,void,void,void,void> &
jac,
253 const PHX::MDField<Scalar,Cell,IP,void,void,void,void,void,void> & jac_det,
254 const PHX::MDField<Scalar,Cell,IP,Dim,Dim,void,void,void,void> & jac_inv,
255 const PHX::MDField<Scalar,Cell,IP> & weighted_measure,
256 const PHX::MDField<Scalar,Cell,NODE,Dim> & vertex_coordinates,
257 bool use_vertex_coordinates)
263 evaluateValues_Const(cub_points,jac_inv,weighted_measure);
265 evaluateValues_HGrad(cub_points,jac_inv,weighted_measure);
267 evaluateValues_HCurl(cub_points,
jac,jac_det,jac_inv,weighted_measure);
269 evaluateValues_HDiv(cub_points,
jac,jac_det,weighted_measure);
271 TEUCHOS_TEST_FOR_EXCEPT_MSG(
true,
"panzer::BasisValues2::evaluateValues : Element space not recognized.");
274 if(use_vertex_coordinates) {
275 TEUCHOS_TEST_FOR_EXCEPT_MSG(elmtspace ==
PureBasis::CONST,
"panzer::BasisValues2::evaluateValues : Const basis cannot have basis coordinates.");
276 evaluateBasisCoordinates(vertex_coordinates);
281 template <
typename Scalar>
284 const PHX::MDField<Scalar,Cell,IP,Dim,Dim,void,void,void,void> & jac_inv,
285 const PHX::MDField<Scalar,Cell,IP> & weighted_measure)
290 typedef Intrepid2::FunctionSpaceTools<PHX::Device::execution_space> fst;
295 const int num_points = basis_layout->numPoints();
297 const int num_dim = basis_layout->dimension();
298 const int num_cells = basis_layout->numCells();
300 auto cell_basis_scalar = af.
buildStaticArray<Scalar,Cell,BASIS,IP>(
"cell_basis_scalar",1,num_basis,num_points);
301 auto cell_cub_points = af.
buildStaticArray<Scalar,IP,Dim>(
"cell_cub_points",num_points,num_dim);
302 auto cell_grad_basis = af.
buildStaticArray<Scalar,Cell,BASIS,IP,Dim>(
"cell_grad_basis",1,num_basis,num_points,num_dim);
303 auto cell_jac_inv = af.
buildStaticArray<Scalar,Cell,IP,Dim,Dim>(
"cell_jac_inv",1,num_points,num_dim,num_dim);
305 auto cell_basis_ref_scalar = af.
buildStaticArray<Scalar,BASIS,IP>(
"cell_basis_ref_scalar",num_basis,num_points);
306 auto cell_grad_basis_ref = af.
buildStaticArray<Scalar,BASIS,IP,Dim>(
"cell_grad_basis_ref",num_basis,num_points,num_dim);
308 for(
int cell=0;cell<num_cells;++cell){
313 for(
int p=0;p<num_points;++p)
314 for(
int d=0;d<num_dim;++d)
315 for(
int d2=0;d2<num_dim;++d2)
316 cell_jac_inv(0,p,d,d2)=jac_inv(cell,p,d,d2);
317 for(
int p=0;p<num_points;++p)
318 for(
int d=0;d<num_dim;++d)
319 cell_cub_points(p,d)=cub_points(cell,p,d);
324 intrepid_basis->getValues(cell_basis_ref_scalar.get_view(),cell_cub_points.get_view(),Intrepid2::OPERATOR_VALUE);
326 if(compute_derivatives){
327 Kokkos::deep_copy(cell_grad_basis_ref.get_view(),0.0);
333 fst::HGRADtransformVALUE(cell_basis_scalar.get_view(),cell_basis_ref_scalar.get_view());
334 for(
int b=0;b<num_basis;++b)
335 for(
int p=0;p<num_points;++p)
336 basis_scalar(cell,b,p)=cell_basis_scalar(0,b,p);
338 if(compute_derivatives){
339 fst::HGRADtransformGRAD(cell_grad_basis.get_view(),cell_jac_inv.get_view(),cell_grad_basis_ref.get_view());
340 for(
int b=0;b<num_basis;++b)
341 for(
int p=0;p<num_points;++p)
342 for(
int d=0;d<num_dim;++d)
343 grad_basis(cell,b,p,d)=cell_grad_basis(0,b,p,d);
350 fst::multiplyMeasure(weighted_basis_scalar.get_view(),weighted_measure.get_view(),basis_scalar.get_view());
351 if(compute_derivatives){
352 fst::multiplyMeasure(weighted_grad_basis.get_view(),weighted_measure.get_view(),grad_basis.get_view());
359 template <
typename Scalar>
362 const PHX::MDField<Scalar,Cell,IP,Dim,Dim,void,void,void,void> & jac_inv,
363 const PHX::MDField<Scalar,Cell,IP> & weighted_measure)
368 typedef Intrepid2::FunctionSpaceTools<PHX::Device::execution_space> fst;
373 const int num_points = basis_layout->numPoints();
375 const int num_dim = basis_layout->dimension();
376 const int num_cells = cub_points.extent(0);
378 auto cell_basis_scalar = af.
buildStaticArray<Scalar,Cell,BASIS,IP>(
"cell_basis_scalar",1,num_basis,num_points);
379 auto cell_cub_points = af.
buildStaticArray<Scalar,IP,Dim>(
"cell_cub_points",num_points,num_dim);
380 auto cell_grad_basis = af.
buildStaticArray<Scalar,Cell,BASIS,IP,Dim>(
"cell_grad_basis",1,num_basis,num_points,num_dim);
381 auto cell_jac_inv = af.
buildStaticArray<Scalar,Cell,IP,Dim,Dim>(
"cell_jac_inv",1,num_points,num_dim,num_dim);
383 auto cell_basis_ref_scalar = af.
buildStaticArray<Scalar,BASIS,IP>(
"cell_basis_ref_scalar",num_basis,num_points);
384 auto cell_grad_basis_ref = af.
buildStaticArray<Scalar,BASIS,IP,Dim>(
"cell_grad_basis_ref",num_basis,num_points,num_dim);
386 for(
int cell=0;cell<num_cells;++cell){
391 for(
int p=0;p<num_points;++p)
392 for(
int d=0;d<num_dim;++d)
393 for(
int d2=0;d2<num_dim;++d2)
394 cell_jac_inv(0,p,d,d2)=jac_inv(cell,p,d,d2);
395 for(
int p=0;p<num_points;++p)
396 for(
int d=0;d<num_dim;++d)
397 cell_cub_points(p,d)=cub_points(cell,p,d);
402 intrepid_basis->getValues(cell_basis_ref_scalar.get_view(),cell_cub_points.get_view(),Intrepid2::OPERATOR_VALUE);
404 if(compute_derivatives){
405 intrepid_basis->getValues(cell_grad_basis_ref.get_view(),cell_cub_points.get_view(),Intrepid2::OPERATOR_GRAD);
411 fst::HGRADtransformVALUE(cell_basis_scalar.get_view(),cell_basis_ref_scalar.get_view());
412 for(
int b=0;b<num_basis;++b)
413 for(
int p=0;p<num_points;++p)
414 basis_scalar(cell,b,p)=cell_basis_scalar(0,b,p);
416 if(compute_derivatives){
417 fst::HGRADtransformGRAD(cell_grad_basis.get_view(),cell_jac_inv.get_view(),cell_grad_basis_ref.get_view());
418 for(
int b=0;b<num_basis;++b)
419 for(
int p=0;p<num_points;++p)
420 for(
int d=0;d<num_dim;++d)
421 grad_basis(cell,b,p,d)=cell_grad_basis(0,b,p,d);
427 fst::multiplyMeasure(weighted_basis_scalar.get_view(),weighted_measure.get_view(),basis_scalar.get_view());
428 if(compute_derivatives){
429 fst::multiplyMeasure(weighted_grad_basis.get_view(),weighted_measure.get_view(),grad_basis.get_view());
436 template <
typename Scalar>
439 const PHX::MDField<Scalar,Cell,IP,Dim,Dim,void,void,void,void> &
jac,
440 const PHX::MDField<Scalar,Cell,IP,void,void,void,void,void,void> & jac_det,
441 const PHX::MDField<Scalar,Cell,IP,Dim,Dim,void,void,void,void> & jac_inv,
442 const PHX::MDField<Scalar,Cell,IP> & weighted_measure)
448 typedef Intrepid2::FunctionSpaceTools<PHX::Device::execution_space> fst;
453 const int num_points = basis_layout->numPoints();
455 const int num_dim = basis_layout->dimension();
456 const int num_cells = basis_layout->numCells();
458 auto cell_cub_points = af.
buildStaticArray<Scalar,IP,Dim>(
"cell_cub_points",num_points,num_dim);
459 auto cell_jac = af.
buildStaticArray<Scalar,Cell,IP,Dim,Dim>(
"cell_jac",1,num_points,num_dim,num_dim);
460 auto cell_jac_inv = af.
buildStaticArray<Scalar,Cell,IP,Dim,Dim>(
"cell_jac_inv",1,num_points,num_dim,num_dim);
461 auto cell_jac_det = af.
buildStaticArray<Scalar,Cell,IP>(
"cell_jac_det",1,num_points);
463 auto cell_basis_vector = af.
buildStaticArray<Scalar,Cell,BASIS,IP,Dim>(
"cell_basis_vector",1,num_basis,num_points,num_dim);
464 auto cell_curl_basis_scalar = af.
buildStaticArray<Scalar,Cell,BASIS,IP>(
"cell_curl_basis_scalar",1,num_basis,num_points);
465 auto cell_curl_basis_vector = af.
buildStaticArray<Scalar,Cell,BASIS,IP,Dim>(
"cell_curl_basis_vector",1,num_basis,num_points,num_dim);
467 auto cell_curl_basis_ref = af.
buildArray<Scalar,BASIS,IP,Dim>(
"cell_curl_basis_ref",num_basis,num_points,num_dim);
468 auto cell_curl_basis_ref_scalar = af.
buildStaticArray<Scalar,BASIS,IP>(
"cell_curl_basis_ref_scalar",num_basis,num_points);
469 auto cell_basis_ref_vector = af.
buildArray<Scalar,BASIS,IP,Dim>(
"cell_basis_ref_vector",num_basis,num_points,num_dim);
471 for(
int cell=0;cell<num_cells;++cell){
476 for(
int p=0;p<num_points;++p)
477 for(
int d=0;d<num_dim;++d)
478 for(
int d2=0;d2<num_dim;++d2)
479 cell_jac(0,p,d,d2)=
jac(cell,p,d,d2);
480 for(
int p=0;p<num_points;++p)
481 for(
int d=0;d<num_dim;++d)
482 for(
int d2=0;d2<num_dim;++d2)
483 cell_jac_inv(0,p,d,d2)=jac_inv(cell,p,d,d2);
484 for(
int p=0;p<num_points;++p)
485 cell_jac_det(0,p)=jac_det(cell,p);
486 for(
int p=0;p<num_points;++p)
487 for(
int d=0;d<num_dim;++d)
488 cell_cub_points(p,d)=cub_points(cell,p,d);
493 intrepid_basis->getValues(cell_basis_ref_vector.get_view(),cell_cub_points.get_view(),Intrepid2::OPERATOR_VALUE);
495 if(compute_derivatives){
497 intrepid_basis->getValues(cell_curl_basis_ref_scalar.get_view(),cell_cub_points.get_view(),Intrepid2::OPERATOR_CURL);
498 }
else if(num_dim==3){
499 intrepid_basis->getValues(cell_curl_basis_ref.get_view(),cell_cub_points.get_view(),Intrepid2::OPERATOR_CURL);
506 fst::HCURLtransformVALUE(cell_basis_vector.get_view(),cell_jac_inv.get_view(),cell_basis_ref_vector.get_view());
507 for(
int b=0;b<num_basis;++b)
508 for(
int p=0;p<num_points;++p)
509 for(
int d=0;d<num_dim;++d)
510 basis_vector(cell,b,p,d)=cell_basis_vector(0,b,p,d);
512 if(compute_derivatives){
517 fst::HDIVtransformDIV(cell_curl_basis_scalar.get_view(),cell_jac_det.get_view(),cell_curl_basis_ref_scalar.get_view());
518 for(
int b=0;b<num_basis;++b)
519 for(
int p=0;p<num_points;++p)
520 curl_basis_scalar(cell,b,p)=cell_curl_basis_scalar(0,b,p);
521 }
else if(num_dim==3) {
522 fst::HCURLtransformCURL(cell_curl_basis_vector.get_view(),cell_jac.get_view(),cell_jac_det.get_view(),cell_curl_basis_ref.get_view());
523 for(
int b=0;b<num_basis;++b)
524 for(
int p=0;p<num_points;++p)
525 for(
int d=0;d<num_dim;++d)
526 curl_basis_vector(cell,b,p,d)=cell_curl_basis_vector(0,b,p,d);
528 TEUCHOS_TEST_FOR_EXCEPT_MSG(
true,
"panzer::BasisValues2::evaluateValues_HCurl : HCurl only setup for 2D and 3D.");
534 fst::multiplyMeasure(weighted_basis_vector.get_view(),weighted_measure.get_view(),basis_vector.get_view());
535 if(compute_derivatives){
537 fst::multiplyMeasure(weighted_curl_basis_scalar.get_view(),weighted_measure.get_view(),curl_basis_scalar.get_view());
538 }
else if(num_dim==3){
539 fst::multiplyMeasure(weighted_curl_basis_vector.get_view(),weighted_measure.get_view(),curl_basis_vector.get_view());
546 template <
typename Scalar>
549 const PHX::MDField<Scalar,Cell,IP,Dim,Dim,void,void,void,void> &
jac,
550 const PHX::MDField<Scalar,Cell,IP,void,void,void,void,void,void> & jac_det,
551 const PHX::MDField<Scalar,Cell,IP> & weighted_measure)
556 typedef Intrepid2::FunctionSpaceTools<PHX::Device::execution_space> fst;
561 const int num_points = basis_layout->numPoints();
563 const int num_dim = basis_layout->dimension();
564 const int num_cells = basis_layout->numCells();
566 auto cell_cub_points = af.
buildStaticArray<Scalar,IP,Dim>(
"cell_cub_points",num_points,num_dim);
567 auto cell_jac = af.
buildStaticArray<Scalar,Cell,IP,Dim,Dim>(
"cell_jac",1,num_points,num_dim,num_dim);
568 auto cell_jac_det = af.
buildStaticArray<Scalar,Cell,IP>(
"cell_jac_det",1,num_points);
570 auto cell_basis_vector = af.
buildStaticArray<Scalar,Cell,BASIS,IP,Dim>(
"cell_basis_vector",1,num_basis,num_points,num_dim);
571 auto cell_div_basis = af.
buildStaticArray<Scalar,Cell,BASIS,IP>(
"cell_div_basis",1,num_basis,num_points);
573 auto cell_basis_ref_vector = af.
buildArray<Scalar,BASIS,IP,Dim>(
"cell_basis_ref_vector",num_basis,num_points,num_dim);
574 auto cell_div_basis_ref = af.
buildStaticArray<Scalar,BASIS,IP>(
"cell_div_basis_ref",num_basis,num_points);
576 for(
int cell=0;cell<num_cells;++cell){
581 for(
int p=0;p<num_points;++p)
582 for(
int d=0;d<num_dim;++d)
583 for(
int d2=0;d2<num_dim;++d2)
584 cell_jac(0,p,d,d2)=
jac(cell,p,d,d2);
585 for(
int p=0;p<num_points;++p)
586 cell_jac_det(0,p)=jac_det(cell,p);
587 for(
int p=0;p<num_points;++p)
588 for(
int d=0;d<num_dim;++d)
589 cell_cub_points(p,d)=cub_points(cell,p,d);
593 intrepid_basis->getValues(cell_basis_ref_vector.get_view(),cell_cub_points.get_view(),Intrepid2::OPERATOR_VALUE);
595 if(compute_derivatives){
596 intrepid_basis->getValues(cell_div_basis_ref.get_view(),cell_cub_points.get_view(),Intrepid2::OPERATOR_DIV);
602 fst::HDIVtransformVALUE(cell_basis_vector.get_view(),cell_jac.get_view(),cell_jac_det.get_view(),cell_basis_ref_vector.get_view());
603 for(
int b=0;b<num_basis;++b)
604 for(
int p=0;p<num_points;++p)
605 for(
int d=0;d<num_dim;++d)
606 basis_vector(cell,b,p,d)=cell_basis_vector(0,b,p,d);
608 if(compute_derivatives){
609 fst::HDIVtransformDIV(cell_div_basis.get_view(),cell_jac_det.get_view(),cell_div_basis_ref.get_view());
610 for(
int b=0;b<num_basis;++b)
611 for(
int p=0;p<num_points;++p)
612 div_basis(cell,b,p)=cell_div_basis(0,b,p);
617 fst::multiplyMeasure(weighted_basis_vector.get_view(),weighted_measure.get_view(),basis_vector.get_view());
618 if(compute_derivatives){
619 fst::multiplyMeasure(weighted_div_basis.get_view(),weighted_measure.get_view(),div_basis.get_view());
667 template <
typename Scalar>
669 evaluateValuesCV(
const PHX::MDField<Scalar,Cell,IP,Dim,void,void,void,void,void> & cell_cub_points,
670 const PHX::MDField<Scalar,Cell,IP,Dim,Dim,void,void,void,void> &
jac,
671 const PHX::MDField<Scalar,Cell,IP,void,void,void,void,void,void> & jac_det,
672 const PHX::MDField<Scalar,Cell,IP,Dim,Dim,void,void,void,void> & jac_inv)
676 int num_ip = basis_layout->numPoints();
677 int num_card = basis_layout->cardinality();
678 int num_dim = basis_layout->dimension();
687 for (
size_type icell = 0; icell < num_cells; ++icell)
689 for (
int ip = 0; ip < num_ip; ++ip)
690 for (
int d = 0; d < num_dim; ++d)
691 dyn_cub_points(ip,d) = cell_cub_points(icell,ip,d);
694 ArrayDynamic dyn_basis_ref_scalar = af.
buildArray<Scalar,BASIS,IP>(
"dyn_basis_ref_scalar",num_card,num_ip);
696 intrepid_basis->getValues(dyn_basis_ref_scalar.get_view(),
697 dyn_cub_points.get_view(),
698 Intrepid2::OPERATOR_VALUE);
701 for (
int b = 0; b < num_card; ++b)
702 for (
int ip = 0; ip < num_ip; ++ip)
703 basis_scalar(icell,b,ip) = dyn_basis_ref_scalar(b,ip);
707 ArrayDynamic dyn_basis_ref_scalar = af.
buildArray<Scalar,BASIS,IP>(
"dyn_basis_ref_scalar",num_card,num_ip);
709 intrepid_basis->getValues(dyn_basis_ref_scalar.get_view(),
710 dyn_cub_points.get_view(),
711 Intrepid2::OPERATOR_VALUE);
714 for (
int b = 0; b < num_card; ++b)
715 for (
int ip = 0; ip < num_ip; ++ip)
716 basis_scalar(icell,b,ip) = dyn_basis_ref_scalar(b,ip);
718 if(compute_derivatives) {
721 ArrayDynamic dyn_grad_basis_ref = af.
buildArray<Scalar,BASIS,IP,Dim>(
"dyn_grad_basis_ref",num_card,num_ip,num_dim);
722 ArrayDynamic dyn_grad_basis = af.
buildArray<Scalar,Cell,BASIS,IP,Dim>(
"dyn_grad_basis",one_cell,num_card,num_ip,num_dim);
723 ArrayDynamic dyn_jac_inv = af.
buildArray<Scalar,Cell,IP,Dim,Dim>(
"dyn_jac_inv",one_cell,num_ip,num_dim,num_dim);
725 intrepid_basis->getValues(dyn_grad_basis_ref.get_view(),
726 dyn_cub_points.get_view(),
727 Intrepid2::OPERATOR_GRAD);
730 for (
int ip = 0; ip < num_ip; ++ip)
731 for (
int d1 = 0; d1 < num_dim; ++d1)
732 for (
int d2 = 0; d2 < num_dim; ++d2)
733 dyn_jac_inv(cellInd,ip,d1,d2) = jac_inv(icell,ip,d1,d2);
735 Intrepid2::FunctionSpaceTools<PHX::Device::execution_space>::HGRADtransformGRAD<Scalar>(dyn_grad_basis.get_view(),
736 dyn_jac_inv.get_view(),
737 dyn_grad_basis_ref.get_view());
739 for (
int b = 0; b < num_card; ++b)
740 for (
int ip = 0; ip < num_ip; ++ip)
741 for (
int d = 0; d < num_dim; ++d)
742 grad_basis(icell,b,ip,d) = dyn_grad_basis(0,b,ip,d);
747 ArrayDynamic dyn_basis_ref_vector = af.
buildArray<Scalar,BASIS,IP,Dim>(
"dyn_basis_ref_vector",num_card,num_ip,num_dim);
749 intrepid_basis->getValues(dyn_basis_ref_vector.get_view(),
750 dyn_cub_points.get_view(),
751 Intrepid2::OPERATOR_VALUE);
754 ArrayDynamic dyn_basis_vector = af.
buildArray<Scalar,Cell,BASIS,IP,Dim>(
"dyn_basis_vector",one_cell,num_card,num_ip,num_dim);
755 ArrayDynamic dyn_jac_inv = af.
buildArray<Scalar,Cell,IP,Dim,Dim>(
"dyn_jac_inv",one_cell,num_ip,num_dim,num_dim);
758 for (
int ip = 0; ip < num_ip; ++ip)
759 for (
int d1 = 0; d1 < num_dim; ++d1)
760 for (
int d2 = 0; d2 < num_dim; ++d2)
761 dyn_jac_inv(cellInd,ip,d1,d2) = jac_inv(icell,ip,d1,d2);
763 Intrepid2::FunctionSpaceTools<PHX::Device::execution_space>::HCURLtransformVALUE(dyn_basis_vector.get_view(),
764 dyn_jac_inv.get_view(),
765 dyn_basis_ref_vector.get_view());
767 for (
int b = 0; b < num_card; ++b)
768 for (
int ip = 0; ip < num_ip; ++ip)
769 for (
int d = 0; d < num_dim; ++d)
770 basis_vector(icell,b,ip,d) = dyn_basis_vector(0,b,ip,d);
772 if(compute_derivatives && num_dim ==2) {
775 ArrayDynamic dyn_curl_basis_ref_scalar = af.
buildArray<Scalar,BASIS,IP>(
"dyn_curl_basis_ref_scalar",num_card,num_ip);
776 ArrayDynamic dyn_curl_basis_scalar = af.
buildArray<Scalar,Cell,BASIS,IP>(
"dyn_curl_basis_scalar",one_cell,num_card,num_ip);
779 intrepid_basis->getValues(dyn_curl_basis_ref_scalar.get_view(),
780 dyn_cub_points.get_view(),
781 Intrepid2::OPERATOR_CURL);
784 for (
int ip = 0; ip < num_ip; ++ip)
785 dyn_jac_det(cellInd,ip) = jac_det(icell,ip);
787 Intrepid2::FunctionSpaceTools<PHX::Device::execution_space>::HDIVtransformDIV(dyn_curl_basis_scalar.get_view(),
788 dyn_jac_det.get_view(),
789 dyn_curl_basis_ref_scalar.get_view());
791 for (
int b = 0; b < num_card; ++b)
792 for (
int ip = 0; ip < num_ip; ++ip)
793 curl_basis_scalar(icell,b,ip) = dyn_curl_basis_scalar(0,b,ip);
796 if(compute_derivatives && num_dim ==3) {
799 ArrayDynamic dyn_curl_basis_ref = af.
buildArray<Scalar,BASIS,IP,Dim>(
"dyn_curl_basis_ref_vector",num_card,num_ip,num_dim);
800 ArrayDynamic dyn_curl_basis = af.
buildArray<Scalar,Cell,BASIS,IP,Dim>(
"dyn_curl_basis_vector",one_cell,num_card,num_ip,num_dim);
804 intrepid_basis->getValues(dyn_curl_basis_ref.get_view(),
805 dyn_cub_points.get_view(),
806 Intrepid2::OPERATOR_CURL);
809 for (
int ip = 0; ip < num_ip; ++ip)
811 dyn_jac_det(cellInd,ip) = jac_det(icell,ip);
812 for (
int d1 = 0; d1 < num_dim; ++d1)
813 for (
int d2 = 0; d2 < num_dim; ++d2)
814 dyn_jac(cellInd,ip,d1,d2) =
jac(icell,ip,d1,d2);
817 Intrepid2::FunctionSpaceTools<PHX::Device::execution_space>::HCURLtransformCURL(dyn_curl_basis.get_view(),
819 dyn_jac_det.get_view(),
820 dyn_curl_basis_ref.get_view());
822 for (
int b = 0; b < num_card; ++b)
823 for (
int ip = 0; ip < num_ip; ++ip)
824 for (
int d = 0; d < num_dim; ++d)
825 curl_basis_vector(icell,b,ip,d) = dyn_curl_basis(0,b,ip,d);
832 ArrayDynamic dyn_basis_ref_vector = af.
buildArray<Scalar,BASIS,IP,Dim>(
"dyn_basis_ref_vector",num_card,num_ip,num_dim);
834 intrepid_basis->getValues(dyn_basis_ref_vector.get_view(),
835 dyn_cub_points.get_view(),
836 Intrepid2::OPERATOR_VALUE);
839 ArrayDynamic dyn_basis_vector = af.
buildArray<Scalar,Cell,BASIS,IP,Dim>(
"dyn_basis_vector",one_cell,num_card,num_ip,num_dim);
844 for (
int ip = 0; ip < num_ip; ++ip)
846 dyn_jac_det(cellInd,ip) = jac_det(icell,ip);
847 for (
int d1 = 0; d1 < num_dim; ++d1)
848 for (
int d2 = 0; d2 < num_dim; ++d2)
849 dyn_jac(cellInd,ip,d1,d2) =
jac(icell,ip,d1,d2);
852 Intrepid2::FunctionSpaceTools<PHX::Device::execution_space>::HDIVtransformVALUE(dyn_basis_vector.get_view(),
854 dyn_jac_det.get_view(),
855 dyn_basis_ref_vector.get_view());
857 for (
int b = 0; b < num_card; ++b)
858 for (
int ip = 0; ip < num_ip; ++ip)
859 for (
int d = 0; d < num_dim; ++d)
860 basis_vector(icell,b,ip,d) = dyn_basis_vector(0,b,ip,d);
862 if(compute_derivatives) {
864 ArrayDynamic dyn_div_basis_ref = af.
buildArray<Scalar,BASIS,IP>(
"dyn_div_basis_ref_scalar",num_card,num_ip);
865 ArrayDynamic dyn_div_basis = af.
buildArray<Scalar,Cell,BASIS,IP>(
"dyn_div_basis_scalar",one_cell,num_card,num_ip);
867 intrepid_basis->getValues(dyn_div_basis_ref.get_view(),
868 dyn_cub_points.get_view(),
869 Intrepid2::OPERATOR_DIV);
871 Intrepid2::FunctionSpaceTools<PHX::Device::execution_space>::HDIVtransformDIV<Scalar>(dyn_div_basis.get_view(),
872 dyn_jac_det.get_view(),
873 dyn_div_basis_ref.get_view());
875 for (
int b = 0; b < num_card; ++b)
876 for (
int ip = 0; ip < num_ip; ++ip)
877 div_basis(icell,b,ip) = dyn_div_basis(0,b,ip);
882 else { TEUCHOS_ASSERT(
false); }
888 template <
typename Scalar>
894 int num_quad = basis_layout->numPoints();
895 int num_dim = basis_layout->dimension();
896 int num_card = basis_layout->cardinality();
900 for (
int ip = 0; ip < num_quad; ++ip)
901 for (
int d = 0; d < num_dim; ++d)
902 dyn_cub_points(ip,d) = cub_points(ip,d);
906 ArrayDynamic dyn_basis_ref_scalar = af.
buildArray<Scalar,BASIS,IP>(
"dyn_basis_ref_scalar",num_card,num_quad);
908 intrepid_basis->getValues(dyn_basis_ref_scalar.get_view(),
909 dyn_cub_points.get_view(),
910 Intrepid2::OPERATOR_VALUE);
912 for (
int b = 0; b < num_card; ++b)
913 for (
int ip = 0; ip < num_quad; ++ip)
914 basis_ref_scalar(b,ip) = dyn_basis_ref_scalar(b,ip);
917 ArrayDynamic dyn_basis_ref_vector = af.
buildArray<Scalar,BASIS,IP,Dim>(
"dyn_basis_ref_vector",num_card,num_quad,num_dim);
919 intrepid_basis->getValues(dyn_basis_ref_vector.get_view(),
920 dyn_cub_points.get_view(),
921 Intrepid2::OPERATOR_VALUE);
923 for (
int b = 0; b < num_card; ++b)
924 for (
int ip = 0; ip < num_quad; ++ip)
925 for (
int d = 0; d < num_dim; ++d)
926 basis_ref_vector(b,ip,d) = dyn_basis_ref_vector(b,ip,d);
928 else { TEUCHOS_ASSERT(
false); }
931 ArrayDynamic dyn_grad_basis_ref = af.
buildArray<Scalar,BASIS,IP,Dim>(
"dyn_basis_ref_vector",num_card,num_quad,num_dim);
933 intrepid_basis->getValues(dyn_grad_basis_ref.get_view(),
934 dyn_cub_points.get_view(),
935 Intrepid2::OPERATOR_GRAD);
937 for (
int b = 0; b < num_card; ++b)
938 for (
int ip = 0; ip < num_quad; ++ip)
939 for (
int d = 0; d < num_dim; ++d)
940 grad_basis_ref(b,ip,d) = dyn_grad_basis_ref(b,ip,d);
943 ArrayDynamic dyn_curl_basis_ref = af.
buildArray<Scalar,BASIS,IP>(
"dyn_curl_basis_ref_scalar",num_card,num_quad);
945 intrepid_basis->getValues(dyn_curl_basis_ref.get_view(),
946 dyn_cub_points.get_view(),
947 Intrepid2::OPERATOR_CURL);
949 for (
int b = 0; b < num_card; ++b)
950 for (
int ip = 0; ip < num_quad; ++ip)
951 curl_basis_ref_scalar(b,ip) = dyn_curl_basis_ref(b,ip);
954 ArrayDynamic dyn_curl_basis_ref = af.
buildArray<Scalar,BASIS,IP,Dim>(
"dyn_curl_basis_ref_vector",num_card,num_quad,num_dim);
956 intrepid_basis->getValues(dyn_curl_basis_ref.get_view(),
957 dyn_cub_points.get_view(),
958 Intrepid2::OPERATOR_CURL);
960 for (
int b = 0; b < num_card; ++b)
961 for (
int ip = 0; ip < num_quad; ++ip)
962 for (
int d = 0; d < num_dim; ++d)
963 curl_basis_ref_vector(b,ip,d) = dyn_curl_basis_ref(b,ip,d);
966 ArrayDynamic dyn_div_basis_ref = af.
buildArray<Scalar,BASIS,IP>(
"dyn_div_basis_ref_scalar",num_card,num_quad);
968 intrepid_basis->getValues(dyn_div_basis_ref.get_view(),
969 dyn_cub_points.get_view(),
970 Intrepid2::OPERATOR_DIV);
972 for (
int b = 0; b < num_card; ++b)
973 for (
int ip = 0; ip < num_quad; ++ip)
974 div_basis_ref(b,ip) = dyn_div_basis_ref(b,ip);
978 if(use_vertex_coordinates) {
983 using coordsScalarType =
typename Intrepid2::Basis<PHX::Device::execution_space,Scalar,Scalar>::scalarType;
984 auto dyn_basis_coordinates_ref = af.
buildArray<coordsScalarType,BASIS,Dim>(
"basis_coordinates_ref",
985 basis_coordinates_ref.extent(0),
986 basis_coordinates_ref.extent(1));
987 intrepid_basis->getDofCoords(dyn_basis_coordinates_ref.get_view());
990 for (
int i = 0; i < basis_coordinates_ref.extent_int(0); ++i)
991 for (
int j = 0; j < basis_coordinates_ref.extent_int(1); ++j)
992 basis_coordinates_ref(i,j) = dyn_basis_coordinates_ref(i,j);
996 references_evaluated =
true;
1000 template <
typename Scalar>
1004 if (!intrepid_basis->requireOrientation())
1007 typedef Intrepid2::OrientationTools<PHX::Device> ots;
1014 const int num_cell_basis_layout = basis_layout->numCells(), num_cell_orientation = orientations.size();
1015 const int num_cell = num_cell_basis_layout < num_cell_orientation ? num_cell_basis_layout : num_cell_orientation;
1016 const int num_dim = basis_layout->dimension();
1017 const Kokkos::pair<int,int> range_cell(0, num_cell);
1019 Kokkos::DynRankView<Intrepid2::Orientation,PHX::Device>
1020 drv_orts((Intrepid2::Orientation*)orientations.data(), num_cell);
1028 auto drv_basis_scalar = Kokkos::subview(basis_scalar.get_view(), range_cell, Kokkos::ALL(), Kokkos::ALL());
1030 "drv_basis_scalar_tmp",
1031 drv_basis_scalar.extent(0),
1032 drv_basis_scalar.extent(1),
1033 drv_basis_scalar.extent(2));
1034 Kokkos::deep_copy(drv_basis_scalar_tmp, drv_basis_scalar);
1035 ots::modifyBasisByOrientation(drv_basis_scalar,
1036 drv_basis_scalar_tmp,
1040 if(build_weighted) {
1041 auto drv_basis_scalar = Kokkos::subview(weighted_basis_scalar.get_view(), range_cell, Kokkos::ALL(), Kokkos::ALL());
1043 "drv_basis_scalar_tmp",
1044 drv_basis_scalar.extent(0),
1045 drv_basis_scalar.extent(1),
1046 drv_basis_scalar.extent(2));
1047 Kokkos::deep_copy(drv_basis_scalar_tmp, drv_basis_scalar);
1048 ots::modifyBasisByOrientation(drv_basis_scalar,
1049 drv_basis_scalar_tmp,
1056 if (compute_derivatives) {
1058 auto drv_grad_basis = Kokkos::subview(grad_basis.get_view(), range_cell, Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL());
1060 "drv_grad_basis_tmp",
1061 drv_grad_basis.extent(0),
1062 drv_grad_basis.extent(1),
1063 drv_grad_basis.extent(2),
1064 drv_grad_basis.extent(3));
1065 Kokkos::deep_copy(drv_grad_basis_tmp, drv_grad_basis);
1066 ots::modifyBasisByOrientation(drv_grad_basis,
1071 if(build_weighted) {
1072 auto drv_grad_basis = Kokkos::subview(weighted_grad_basis.get_view(), range_cell, Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL());
1074 "drv_grad_basis_tmp",
1075 drv_grad_basis.extent(0),
1076 drv_grad_basis.extent(1),
1077 drv_grad_basis.extent(2),
1078 drv_grad_basis.extent(3));
1079 Kokkos::deep_copy(drv_grad_basis_tmp, drv_grad_basis);
1080 ots::modifyBasisByOrientation(drv_grad_basis,
1094 auto drv_basis_vector = Kokkos::subview(basis_vector.get_view(), range_cell, Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL());
1096 "drv_basis_vector_tmp",
1097 drv_basis_vector.extent(0),
1098 drv_basis_vector.extent(1),
1099 drv_basis_vector.extent(2),
1100 drv_basis_vector.extent(3));
1101 Kokkos::deep_copy(drv_basis_vector_tmp, drv_basis_vector);
1102 ots::modifyBasisByOrientation(drv_basis_vector,
1103 drv_basis_vector_tmp,
1107 if(build_weighted) {
1108 auto drv_basis_vector = Kokkos::subview(weighted_basis_vector.get_view(), range_cell, Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL());
1110 "drv_basis_vector_tmp",
1111 drv_basis_vector.extent(0),
1112 drv_basis_vector.extent(1),
1113 drv_basis_vector.extent(2),
1114 drv_basis_vector.extent(3));
1115 Kokkos::deep_copy(drv_basis_vector_tmp, drv_basis_vector);
1116 ots::modifyBasisByOrientation(drv_basis_vector,
1117 drv_basis_vector_tmp,
1123 if (compute_derivatives) {
1125 auto drv_curl_basis_scalar = Kokkos::subview(curl_basis_scalar.get_view(), range_cell, Kokkos::ALL(), Kokkos::ALL());
1127 "drv_curl_basis_scalar_tmp",
1128 drv_curl_basis_scalar.extent(0),
1129 drv_curl_basis_scalar.extent(1),
1130 drv_curl_basis_scalar.extent(2));
1131 Kokkos::deep_copy(drv_curl_basis_scalar_tmp, drv_curl_basis_scalar);
1132 ots::modifyBasisByOrientation(drv_curl_basis_scalar,
1133 drv_curl_basis_scalar_tmp,
1138 if(build_weighted) {
1139 auto drv_curl_basis_scalar = Kokkos::subview(weighted_curl_basis_scalar.get_view(), range_cell, Kokkos::ALL(), Kokkos::ALL());
1141 "drv_curl_basis_scalar_tmp",
1142 drv_curl_basis_scalar.extent(0),
1143 drv_curl_basis_scalar.extent(1),
1144 drv_curl_basis_scalar.extent(2));
1145 Kokkos::deep_copy(drv_curl_basis_scalar_tmp, drv_curl_basis_scalar);
1146 ots::modifyBasisByOrientation(drv_curl_basis_scalar,
1147 drv_curl_basis_scalar_tmp,
1160 auto drv_basis_vector = Kokkos::subview(basis_vector.get_view(), range_cell, Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL());
1162 "drv_basis_vector_tmp",
1163 drv_basis_vector.extent(0),
1164 drv_basis_vector.extent(1),
1165 drv_basis_vector.extent(2),
1166 drv_basis_vector.extent(3));
1167 Kokkos::deep_copy(drv_basis_vector_tmp, drv_basis_vector);
1168 ots::modifyBasisByOrientation(drv_basis_vector,
1169 drv_basis_vector_tmp,
1173 if(build_weighted) {
1174 auto drv_basis_vector = Kokkos::subview(weighted_basis_vector.get_view(), range_cell, Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL());
1176 "drv_basis_vector_tmp",
1177 drv_basis_vector.extent(0),
1178 drv_basis_vector.extent(1),
1179 drv_basis_vector.extent(2),
1180 drv_basis_vector.extent(3));
1181 Kokkos::deep_copy(drv_basis_vector_tmp, drv_basis_vector);
1182 ots::modifyBasisByOrientation(drv_basis_vector,
1183 drv_basis_vector_tmp,
1189 if (compute_derivatives) {
1191 auto drv_curl_basis_vector = Kokkos::subview(curl_basis_vector.get_view(), range_cell, Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL());
1193 "drv_curl_basis_vector_tmp",
1194 drv_curl_basis_vector.extent(0),
1195 drv_curl_basis_vector.extent(1),
1196 drv_curl_basis_vector.extent(2),
1197 drv_curl_basis_vector.extent(3));
1198 Kokkos::deep_copy(drv_curl_basis_vector_tmp, drv_curl_basis_vector);
1199 ots::modifyBasisByOrientation(drv_curl_basis_vector,
1200 drv_curl_basis_vector_tmp,
1204 if(build_weighted) {
1205 auto drv_curl_basis_vector = Kokkos::subview(weighted_curl_basis_vector.get_view(), range_cell, Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL());
1207 "drv_curl_basis_vector_tmp",
1208 drv_curl_basis_vector.extent(0),
1209 drv_curl_basis_vector.extent(1),
1210 drv_curl_basis_vector.extent(2),
1211 drv_curl_basis_vector.extent(3));
1212 Kokkos::deep_copy(drv_curl_basis_vector_tmp, drv_curl_basis_vector);
1213 ots::modifyBasisByOrientation(drv_curl_basis_vector,
1214 drv_curl_basis_vector_tmp,
1226 auto drv_basis_vector = Kokkos::subview(basis_vector.get_view(), range_cell, Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL());
1228 "drv_basis_vector_tmp",
1229 drv_basis_vector.extent(0),
1230 drv_basis_vector.extent(1),
1231 drv_basis_vector.extent(2),
1232 drv_basis_vector.extent(3));
1233 Kokkos::deep_copy(drv_basis_vector_tmp, drv_basis_vector);
1234 ots::modifyBasisByOrientation(drv_basis_vector,
1235 drv_basis_vector_tmp,
1239 if(build_weighted) {
1240 auto drv_basis_vector = Kokkos::subview(weighted_basis_vector.get_view(), range_cell, Kokkos::ALL(), Kokkos::ALL(), Kokkos::ALL());
1242 "drv_basis_vector_tmp",
1243 drv_basis_vector.extent(0),
1244 drv_basis_vector.extent(1),
1245 drv_basis_vector.extent(2),
1246 drv_basis_vector.extent(3));
1247 Kokkos::deep_copy(drv_basis_vector_tmp, drv_basis_vector);
1248 ots::modifyBasisByOrientation(drv_basis_vector,
1249 drv_basis_vector_tmp,
1254 if (compute_derivatives) {
1256 auto drv_div_basis = Kokkos::subview(div_basis.get_view(), range_cell, Kokkos::ALL(), Kokkos::ALL());
1258 "drv_div_basis_tmp",
1259 drv_div_basis.extent(0),
1260 drv_div_basis.extent(1),
1261 drv_div_basis.extent(2));
1262 Kokkos::deep_copy(drv_div_basis_tmp, drv_div_basis);
1263 ots::modifyBasisByOrientation(drv_div_basis,
1268 if(build_weighted) {
1269 auto drv_div_basis = Kokkos::subview(weighted_div_basis.get_view(), range_cell, Kokkos::ALL(), Kokkos::ALL());
1271 "drv_div_basis_tmp",
1272 drv_div_basis.extent(0),
1273 drv_div_basis.extent(1),
1274 drv_div_basis.extent(2));
1275 Kokkos::deep_copy(drv_div_basis_tmp, drv_div_basis);
1276 ots::modifyBasisByOrientation(drv_div_basis,
1286 template <
typename Scalar>
1291 TEUCHOS_TEST_FOR_EXCEPT_MSG(
true,
"panzer::BasisValues2::applyOrientations : this should not be called.");
1293 int num_cell = orientations.extent(0);
1294 int num_basis = orientations.extent(1);
1295 int num_dim = basis_layout->dimension();
1296 int num_ip = basis_layout->numPoints();
1304 for (
int c=0; c<num_cell; c++)
1305 for (
int b=0; b<num_basis; b++)
1306 for (
int p=0; p<num_ip; p++)
1307 for (
int d=0; d<num_dim; d++)
1308 basis_vector(c, b, p, d) *= orientations(c, b);
1310 if(compute_derivatives) {
1312 for (
int c=0; c<num_cell; c++)
1313 for (
int b=0; b<num_basis; b++)
1314 for (
int p=0; p<num_ip; p++)
1315 curl_basis_scalar(c, b, p) *= orientations(c, b);
1319 if(build_weighted) {
1320 Intrepid2::FunctionSpaceTools<PHX::Device::execution_space>::applyFieldSigns(weighted_basis_vector.get_view(),orientations.get_view());
1322 if(compute_derivatives)
1323 Intrepid2::FunctionSpaceTools<PHX::Device::execution_space>::applyFieldSigns(weighted_curl_basis_scalar.get_view(),orientations.get_view());
1331 for (
int c=0; c<num_cell; c++)
1332 for (
int b=0; b<num_basis; b++)
1333 for (
int p=0; p<num_ip; p++)
1334 for (
int d=0; d<num_dim; d++)
1335 basis_vector(c, b, p, d) *= orientations(c, b);
1337 if(compute_derivatives) {
1339 for (
int c=0; c<num_cell; c++)
1340 for (
int b=0; b<num_basis; b++)
1341 for (
int p=0; p<num_ip; p++)
1342 for (
int d=0; d<num_dim; d++)
1343 curl_basis_vector(c, b, p,d) *= orientations(c, b);
1347 if(build_weighted) {
1348 Intrepid2::FunctionSpaceTools<PHX::Device::execution_space>::applyFieldSigns(weighted_basis_vector.get_view(),orientations.get_view());
1350 if(compute_derivatives)
1351 Intrepid2::FunctionSpaceTools<PHX::Device::execution_space>::applyFieldSigns(weighted_curl_basis_vector.get_view(),orientations.get_view());
1358 for (
int c=0; c<num_cell; c++)
1359 for (
int b=0; b<num_basis; b++)
1360 for (
int p=0; p<num_ip; p++)
1361 for (
int d=0; d<num_dim; d++)
1362 basis_vector(c, b, p, d) *= orientations(c, b);
1364 if(compute_derivatives) {
1367 for (
int c=0; c<num_cell; c++)
1368 for (
int b=0; b<num_basis; b++)
1369 for (
int p=0; p<num_ip; p++)
1370 div_basis(c, b, p) *= orientations(c, b);
1374 if(build_weighted) {
1375 Intrepid2::FunctionSpaceTools<PHX::Device::execution_space>::applyFieldSigns(weighted_basis_vector.get_view(),orientations.get_view());
1377 if(compute_derivatives)
1378 Intrepid2::FunctionSpaceTools<PHX::Device::execution_space>::applyFieldSigns(weighted_div_basis.get_view(),orientations.get_view());
1383 template <
typename Scalar>
1385 {
return basis_layout->getBasis()->getElementSpace(); }
1387 template <
typename Scalar>
1390 bool computeDerivatives)
1394 compute_derivatives = computeDerivatives;
1395 basis_layout = layout;
1396 Teuchos::RCP<const panzer::PureBasis> basisDesc = layout->getBasis();
1399 int num_quad = layout->numPoints();
1400 int dim = basisDesc->dimension();
1401 int card = basisDesc->cardinality();
1402 int numcells = basisDesc->numCells();
1404 Teuchos::RCP<const shards::CellTopology> cellTopo = basisDesc->getCellTopology();
1406 intrepid_basis = basisDesc->getIntrepid2Basis<PHX::Device::execution_space,Scalar,Scalar>();
1417 basis_ref_scalar = af.
buildStaticArray<Scalar,BASIS,IP>(
"basis_ref",card,num_quad);
1418 basis_scalar = af.
buildStaticArray<Scalar,Cell,BASIS,IP>(
"basis",numcells,card,num_quad);
1421 weighted_basis_scalar = af.
buildStaticArray<Scalar,Cell,BASIS,IP>(
"weighted_basis",numcells,card,num_quad);
1426 if(compute_derivatives) {
1427 grad_basis_ref = af.
buildStaticArray<Scalar,BASIS,IP,Dim>(
"grad_basis_ref",card,num_quad,dim);
1428 grad_basis = af.
buildStaticArray<Scalar,Cell,BASIS,IP,Dim>(
"grad_basis",numcells,card,num_quad,dim);
1431 weighted_grad_basis = af.
buildStaticArray<Scalar,Cell,BASIS,IP,Dim>(
"weighted_grad_basis",numcells,card,num_quad,dim);
1445 basis_ref_vector = af.
buildStaticArray<Scalar,BASIS,IP,Dim>(
"basis_ref",card,num_quad,dim);
1446 basis_vector = af.
buildStaticArray<Scalar,Cell,BASIS,IP,Dim>(
"basis",numcells,card,num_quad,dim);
1449 weighted_basis_vector = af.
buildStaticArray<Scalar,Cell,BASIS,IP,Dim>(
"weighted_basis",numcells,card,num_quad,dim);
1459 if(compute_derivatives) {
1462 curl_basis_ref_scalar = af.
buildStaticArray<Scalar,BASIS,IP>(
"curl_basis_ref",card,num_quad);
1463 curl_basis_scalar = af.
buildStaticArray<Scalar,Cell,BASIS,IP>(
"curl_basis",numcells,card,num_quad);
1466 weighted_curl_basis_scalar = af.
buildStaticArray<Scalar,Cell,BASIS,IP>(
"weighted_curl_basis",numcells,card,num_quad);
1469 curl_basis_ref_vector = af.
buildStaticArray<Scalar,BASIS,IP,Dim>(
"curl_basis_ref",card,num_quad,dim);
1470 curl_basis_vector = af.
buildStaticArray<Scalar,Cell,BASIS,IP,Dim>(
"curl_basis",numcells,card,num_quad,dim);
1473 weighted_curl_basis_vector = af.
buildStaticArray<Scalar,Cell,BASIS,IP,Dim>(
"weighted_curl_basis",numcells,card,num_quad,dim);
1475 else { TEUCHOS_ASSERT(
false); }
1484 basis_ref_vector = af.
buildStaticArray<Scalar,BASIS,IP,Dim>(
"basis_ref",card,num_quad,dim);
1485 basis_vector = af.
buildStaticArray<Scalar,Cell,BASIS,IP,Dim>(
"basis",numcells,card,num_quad,dim);
1488 weighted_basis_vector = af.
buildStaticArray<Scalar,Cell,BASIS,IP,Dim>(
"weighted_basis",numcells,card,num_quad,dim);
1503 if(compute_derivatives) {
1504 div_basis_ref = af.
buildStaticArray<Scalar,BASIS,IP>(
"div_basis_ref",card,num_quad);
1505 div_basis = af.
buildStaticArray<Scalar,Cell,BASIS,IP>(
"div_basis",numcells,card,num_quad);
1508 weighted_div_basis = af.
buildStaticArray<Scalar,Cell,BASIS,IP>(
"weighted_div_basis",numcells,card,num_quad);
1516 basis_ref_scalar = af.
buildStaticArray<Scalar,BASIS,IP>(
"basis_ref",card,num_quad);
1517 basis_scalar = af.
buildStaticArray<Scalar,Cell,BASIS,IP>(
"basis",numcells,card,num_quad);
1520 weighted_basis_scalar = af.
buildStaticArray<Scalar,Cell,BASIS,IP>(
"weighted_basis",numcells,card,num_quad);
1537 else { TEUCHOS_ASSERT(
false); }
1539 basis_coordinates_ref = af.
buildStaticArray<Scalar,BASIS,Dim>(
"basis_coordinates_ref",card,dim);
1540 basis_coordinates = af.
buildStaticArray<Scalar,Cell,BASIS,Dim>(
"basis_coordinates",numcells,card,dim);
1545 #define BASIS_VALUES_INSTANTIATION(SCALAR) \ 1546 template class BasisValues2<SCALAR>; 1550 #ifdef Panzer_BUILD_HESSIAN_SUPPORT
void evaluateValues_HGrad(const PHX::MDField< Scalar, Cell, IP, Dim, void, void, void, void, void > &cub_points, const PHX::MDField< Scalar, Cell, IP, Dim, Dim, void, void, void, void > &jac_inv, const PHX::MDField< Scalar, Cell, IP > &weighted_measure)
PHX::MDField< Scalar, T0 > buildStaticArray(const std::string &str, int d0) const
void evaluateValues(const PHX::MDField< Scalar, IP, Dim, void, void, void, void, void, void > &cub_points, const PHX::MDField< Scalar, Cell, IP, Dim, Dim, void, void, void, void > &jac, const PHX::MDField< Scalar, Cell, IP, void, void, void, void, void, void > &jac_det, const PHX::MDField< Scalar, Cell, IP, Dim, Dim, void, void, void, void > &jac_inv)
void evaluateReferenceValues(const PHX::MDField< Scalar, IP, Dim > &cub_points, bool compute_derivatives, bool use_vertex_coordinates)
ArrayTraits< Scalar, PHX::MDField< Scalar, void, void, void, void, void, void, void, void > >::size_type size_type
void evaluateBasisCoordinates(const PHX::MDField< Scalar, Cell, NODE, Dim > &vertex_coordinates)
PHX::MDField< Scalar > buildArray(const std::string &str, int d0) const
void evaluateValues_Const(const PHX::MDField< Scalar, Cell, IP, Dim, void, void, void, void, void > &cub_points, const PHX::MDField< Scalar, Cell, IP, Dim, Dim, void, void, void, void > &jac_inv, const PHX::MDField< Scalar, Cell, IP > &weighted_measure)
void applyOrientations(const PHX::MDField< const Scalar, Cell, BASIS > &orientations)
Method to apply orientations to a basis values container.
Kokkos::DynRankView< typename InputArray::value_type, PHX::Device > createDynRankView(const InputArray &a, const std::string &name, const DimensionPack... dims)
Wrapper to simplify Panzer use of Sacado ViewFactory.
void evaluateValues_HCurl(const PHX::MDField< Scalar, Cell, IP, Dim, void, void, void, void, void > &cub_points, const PHX::MDField< Scalar, Cell, IP, Dim, Dim, void, void, void, void > &jac, const PHX::MDField< Scalar, Cell, IP, void, void, void, void, void, void > &jac_det, const PHX::MDField< Scalar, Cell, IP, Dim, Dim, void, void, void, void > &jac_inv, const PHX::MDField< Scalar, Cell, IP > &weighted_measure)
#define BASIS_VALUES_INSTANTIATION(SCALAR)
void setupArrays(const Teuchos::RCP< const panzer::BasisIRLayout > &basis, bool computeDerivatives=true)
Sizes/allocates memory for arrays.
Sacado::Fad::DFad< Sacado::Fad::SFad< RealType, 1 > > HessianType
Description and data layouts associated with a particular basis.
void evaluateValuesCV(const PHX::MDField< Scalar, Cell, IP, Dim, void, void, void, void, void > &cell_cub_points, const PHX::MDField< Scalar, Cell, IP, Dim, Dim, void, void, void, void > &jac, const PHX::MDField< Scalar, Cell, IP, void, void, void, void, void, void > &jac_det, const PHX::MDField< Scalar, Cell, IP, Dim, Dim, void, void, void, void > &jac_inv)
PureBasis::EElementSpace getElementSpace() const
int cardinality() const
Returns the number of basis coefficients.
void evaluateValues_HDiv(const PHX::MDField< Scalar, Cell, IP, Dim, void, void, void, void, void > &cub_points, const PHX::MDField< Scalar, Cell, IP, Dim, Dim, void, void, void, void > &jac, const PHX::MDField< Scalar, Cell, IP, void, void, void, void, void, void > &jac_det, const PHX::MDField< Scalar, Cell, IP > &weighted_measure)
PHX::MDField< Scalar > ArrayDynamic