43 #ifndef PANZER_WORKSET_BUILDER_IMPL_HPP 44 #define PANZER_WORKSET_BUILDER_IMPL_HPP 57 #include "Phalanx_DataLayout_MDALayout.hpp" 60 #include "Shards_CellTopology.hpp" 61 #include "Intrepid2_DefaultCubatureFactory.hpp" 62 #include "Intrepid2_CellTools.hpp" 63 #include "Intrepid2_FunctionSpaceTools.hpp" 64 #include "Intrepid2_Basis.hpp" 66 template<
typename ArrayT>
69 const std::vector<std::size_t>& local_cell_ids,
70 const ArrayT& vertex_coordinates)
79 for(std::map<
int,RCP<panzer::IntegrationRule> >::const_iterator ir_itr = int_rules.begin();
80 ir_itr != int_rules.end(); ++ir_itr)
81 needs.int_rules.push_back(ir_itr->second);
83 const std::map<std::string,Teuchos::RCP<panzer::PureBasis> >& bases= pb.
getBases();
85 b_itr != bases.end(); ++b_itr)
86 needs.bases.push_back(b_itr->second);
91 template<
typename ArrayT>
94 const std::string & elementBlock,
95 const std::vector<std::size_t>& local_cell_ids,
96 const ArrayT& vertex_coordinates)
105 std::size_t total_num_cells = local_cell_ids.size();
107 std::size_t workset_size = needs.cellData.numCells();
111 std::vector<panzer::Workset>& worksets = *worksets_ptr;
114 if(total_num_cells==0) {
117 RCP<vector<int> > ir_degrees =
rcp(
new vector<int>(0));
118 RCP<vector<string> > basis_names =
rcp(
new vector<string>(0));
121 std::vector<panzer::Workset>::iterator i = worksets.begin();
123 i->block_id = elementBlock;
124 i->ir_degrees = ir_degrees;
125 i->basis_names = basis_names;
127 for (std::size_t j=0;j<needs.int_rules.size();j++) {
129 RCP<panzer::IntegrationValues2<double> > iv2 =
131 iv2->setupArrays(needs.int_rules[j]);
133 ir_degrees->push_back(needs.int_rules[j]->cubature_degree);
134 i->int_rules.push_back(iv2);
138 for (std::size_t j=0;j<needs.int_rules.size();j++) {
139 for (std::size_t b=0;b<needs.bases.size();b++) {
140 RCP<panzer::BasisIRLayout> b_layout
143 RCP<panzer::BasisValues2<double> > bv2
145 bv2->setupArrays(b_layout);
146 i->bases.push_back(bv2);
148 basis_names->push_back(b_layout->name());
157 std::size_t num_worksets = total_num_cells / workset_size;
158 bool last_set_is_full =
true;
159 std::size_t last_workset_size = total_num_cells % workset_size;
160 if (last_workset_size != 0) {
162 last_set_is_full =
false;
165 worksets.resize(num_worksets);
166 std::vector<panzer::Workset>::iterator i;
167 for (i = worksets.begin(); i != worksets.end(); ++i)
168 i->num_cells = workset_size;
170 if (!last_set_is_full) {
171 worksets.back().num_cells = last_workset_size;
176 std::vector<std::size_t>::const_iterator local_begin = local_cell_ids.begin();
177 for (std::vector<panzer::Workset>::iterator wkst = worksets.begin(); wkst != worksets.end(); ++wkst) {
178 std::vector<std::size_t>::const_iterator begin_iter = local_begin;
179 std::vector<std::size_t>::const_iterator end_iter = begin_iter + wkst->num_cells;
180 local_begin = end_iter;
181 wkst->cell_local_ids.assign(begin_iter,end_iter);
183 Kokkos::View<int*,PHX::Device> cell_local_ids_k = Kokkos::View<int*,PHX::Device>(
"Workset:cell_local_ids",wkst->cell_local_ids.size());
184 for(std::size_t i=0;i<wkst->cell_local_ids.size();i++)
185 cell_local_ids_k(i) = wkst->cell_local_ids[i];
186 wkst->cell_local_ids_k = cell_local_ids_k;
188 wkst->cell_vertex_coordinates = mdArrayFactory.buildStaticArray<double,Cell,NODE,Dim>(
"cvc",workset_size,
189 vertex_coordinates.dimension(1),
190 vertex_coordinates.dimension(2));
191 wkst->block_id = elementBlock;
192 wkst->subcell_dim = needs.cellData.baseCellDimension();
193 wkst->subcell_index = 0;
200 for (std::vector<panzer::Workset>::iterator wkst = worksets.begin(); wkst != worksets.end(); ++wkst) {
201 for (index_t cell = 0; cell < wkst->num_cells; ++cell)
202 for (std::size_t vertex = 0; vertex < Teuchos::as<std::size_t>(vertex_coordinates.dimension(1)); ++ vertex)
203 for (std::size_t dim = 0; dim < Teuchos::as<std::size_t>(vertex_coordinates.dimension(2)); ++ dim) {
205 wkst->cell_vertex_coordinates(cell,vertex,dim) = vertex_coordinates(cell +
offset,vertex,dim);
208 offset += wkst->num_cells;
214 RCP<vector<int> > ir_degrees =
rcp(
new vector<int>(0));
215 RCP<vector<string> > basis_names =
rcp(
new vector<string>(0));
216 for (std::vector<panzer::Workset>::iterator wkst = worksets.begin(); wkst != worksets.end(); ++wkst) {
217 wkst->ir_degrees = ir_degrees;
218 wkst->basis_names = basis_names;
222 for(std::vector<panzer::Workset>::iterator wkst = worksets.begin(); wkst != worksets.end(); ++wkst)
231 template<
typename ArrayT>
234 const std::vector<std::size_t>& local_cell_ids,
235 const std::vector<std::size_t>& local_side_ids,
236 const ArrayT& vertex_coordinates)
245 for(std::map<
int,RCP<panzer::IntegrationRule> >::const_iterator ir_itr = int_rules.begin();
246 ir_itr != int_rules.end(); ++ir_itr)
247 needs.int_rules.push_back(ir_itr->second);
249 const std::map<std::string,Teuchos::RCP<panzer::PureBasis> >& bases= pb.
getBases();
251 b_itr != bases.end(); ++b_itr)
252 needs.bases.push_back(b_itr->second);
257 template<
typename ArrayT>
260 const std::string & elementBlock,
261 const std::vector<std::size_t>& local_cell_ids,
262 const std::vector<std::size_t>& local_side_ids,
263 const ArrayT& vertex_coordinates,
264 const bool populate_value_arrays)
283 TEUCHOS_ASSERT(local_side_ids.size() ==
static_cast<std::size_t
>(vertex_coordinates.dimension(0)));
286 std::map<unsigned,std::vector<std::pair<std::size_t,std::size_t> > > element_list;
287 for (std::size_t cell=0; cell < local_cell_ids.size(); ++cell)
288 element_list[local_side_ids[cell]].push_back(std::make_pair(cell,local_cell_ids[cell]));
290 std::map<unsigned,panzer::Workset>& worksets = *worksets_ptr;
293 std::map<unsigned,std::vector<std::pair<std::size_t,std::size_t> > >::const_iterator side;
294 for (side = element_list.begin(); side != element_list.end(); ++side) {
296 std::vector<std::size_t>& cell_local_ids = worksets[side->first].cell_local_ids;
298 worksets[side->first].cell_vertex_coordinates = mdArrayFactory.buildStaticArray<double,Cell,NODE,Dim>(
"cvc",
300 vertex_coordinates.dimension(1),
301 vertex_coordinates.dimension(2));
302 Workset::CellCoordArray coords = worksets[side->first].cell_vertex_coordinates;
304 for (std::size_t cell = 0; cell < side->second.size(); ++cell) {
305 cell_local_ids.push_back(side->second[cell].second);
307 for (std::size_t vertex = 0; vertex < Teuchos::as<std::size_t>(vertex_coordinates.dimension(1)); ++ vertex)
308 for (std::size_t dim = 0; dim < Teuchos::as<std::size_t>(vertex_coordinates.dimension(2)); ++ dim) {
309 coords(cell,vertex,dim) = vertex_coordinates(side->second[cell].first,vertex,dim);
313 Kokkos::View<int*,PHX::Device> cell_local_ids_k = Kokkos::View<int*,PHX::Device>(
"Workset:cell_local_ids",worksets[side->first].cell_local_ids.size());
314 for(std::size_t i=0;i<worksets[side->first].cell_local_ids.size();i++)
315 cell_local_ids_k(i) = worksets[side->first].cell_local_ids[i];
316 worksets[side->first].cell_local_ids_k = cell_local_ids_k;
318 worksets[side->first].num_cells = worksets[side->first].cell_local_ids.size();
319 worksets[side->first].block_id = elementBlock;
320 worksets[side->first].subcell_dim = needs.cellData.baseCellDimension() - 1;
321 worksets[side->first].subcell_index = side->first;
324 if (populate_value_arrays) {
326 for (std::map<unsigned,panzer::Workset>::iterator wkst = worksets.begin();
327 wkst != worksets.end(); ++wkst) {
339 template<
typename ArrayT>
342 const std::vector<std::size_t>& local_cell_ids_a,
343 const std::vector<std::size_t>& local_side_ids_a,
344 const ArrayT& vertex_coordinates_a,
346 const std::vector<std::size_t>& local_cell_ids_b,
347 const std::vector<std::size_t>& local_side_ids_b,
348 const ArrayT& vertex_coordinates_b)
353 WorksetNeeds needs_a;
356 const std::map<int,RCP<panzer::IntegrationRule> >& int_rules_a = pb_a.
getIntegrationRules();
357 for(std::map<
int,RCP<panzer::IntegrationRule> >::const_iterator ir_itr = int_rules_a.begin();
358 ir_itr != int_rules_a.end(); ++ir_itr)
359 needs_a.int_rules.push_back(ir_itr->second);
361 const std::map<std::string,Teuchos::RCP<panzer::PureBasis> >& bases_a = pb_a.
getBases();
363 b_itr != bases_a.end(); ++b_itr)
364 needs_a.bases.push_back(b_itr->second);
366 WorksetNeeds needs_b;
369 const std::map<int,RCP<panzer::IntegrationRule> >& int_rules_b = pb_b.
getIntegrationRules();
370 for(std::map<
int,RCP<panzer::IntegrationRule> >::const_iterator ir_itr = int_rules_b.begin();
371 ir_itr != int_rules_b.end(); ++ir_itr)
372 needs_b.int_rules.push_back(ir_itr->second);
374 const std::map<std::string,Teuchos::RCP<panzer::PureBasis> >& bases_b = pb_b.
getBases();
376 b_itr != bases_b.end(); ++b_itr)
377 needs_b.bases.push_back(b_itr->second);
380 needs_b,pb_b.
elementBlockID(),local_cell_ids_b,local_side_ids_b,vertex_coordinates_b);
503 template<
typename ArrayT>
506 const std::string & eblock_a,
507 const std::vector<std::size_t>& local_cell_ids_a,
508 const std::vector<std::size_t>& local_side_ids_a,
509 const ArrayT& vertex_coordinates_a,
510 const WorksetNeeds & needs_b,
511 const std::string & eblock_b,
512 const std::vector<std::size_t>& local_cell_ids_b,
513 const std::vector<std::size_t>& local_side_ids_b,
514 const ArrayT& vertex_coordinates_b)
521 std::size_t total_num_cells_a = local_cell_ids_a.size();
522 std::size_t total_num_cells_b = local_cell_ids_b.size();
525 TEUCHOS_ASSERT(local_side_ids_a.size() == local_cell_ids_a.size());
526 TEUCHOS_ASSERT(local_side_ids_a.size() ==
static_cast<std::size_t
>(vertex_coordinates_a.dimension(0)));
527 TEUCHOS_ASSERT(local_side_ids_b.size() == local_cell_ids_b.size());
528 TEUCHOS_ASSERT(local_side_ids_b.size() ==
static_cast<std::size_t
>(vertex_coordinates_b.dimension(0)));
530 std::size_t total_num_cells = total_num_cells_a;
532 std::size_t workset_size = needs_a.cellData.numCells();
536 std::vector<panzer::Workset>& worksets = *worksets_ptr;
539 if(total_num_cells==0) {
542 RCP<std::vector<int> > ir_degrees =
rcp(
new std::vector<int>(0));
543 RCP<std::vector<std::string> > basis_names =
rcp(
new std::vector<std::string>(0));
546 std::vector<panzer::Workset>::iterator i = worksets.begin();
548 i->details(0).block_id = eblock_a;
550 i->details(1).block_id = eblock_b;
553 i->ir_degrees = ir_degrees;
554 i->basis_names = basis_names;
556 for(std::size_t j=0;j<needs_a.int_rules.size();j++) {
558 RCP<panzer::IntegrationValues2<double> > iv2 =
560 iv2->setupArrays(needs_a.int_rules[j]);
562 ir_degrees->push_back(needs_a.int_rules[j]->cubature_degree);
563 i->int_rules.push_back(iv2);
567 for(std::size_t j=0;j<needs_a.int_rules.size();j++) {
569 for(std::size_t b=0;b<needs_a.bases.size();b++) {
573 RCP<panzer::BasisValues2<double> > bv2 =
575 bv2->setupArrays(b_layout);
576 i->bases.push_back(bv2);
578 basis_names->push_back(b_layout->name());
589 std::map<std::pair<unsigned,unsigned>,std::vector<std::size_t> > element_list;
590 for (std::size_t cell=0; cell < local_cell_ids_a.size(); ++cell)
591 element_list[std::make_pair(local_side_ids_a[cell],local_side_ids_b[cell])].push_back(cell);
594 std::map<std::pair<unsigned,unsigned>,std::vector<std::size_t> >::const_iterator edge;
597 std::size_t num_worksets = 0;
598 for(edge=element_list.begin(); edge!=element_list.end();++edge) {
599 std::size_t num_worksets_for_edge = edge->second.size() / workset_size;
600 std::size_t last_workset_size = edge->second.size() % workset_size;
601 if(last_workset_size!=0)
602 num_worksets_for_edge += 1;
604 num_worksets += num_worksets_for_edge;
606 worksets.resize(num_worksets);
609 std::vector<Workset>::iterator current_workset = worksets.begin();
610 for(edge=element_list.begin(); edge!=element_list.end();++edge) {
612 const std::vector<std::size_t> & cell_indices = edge->second;
615 needs_a,eblock_a,local_cell_ids_a,local_side_ids_a,vertex_coordinates_a,
616 needs_b,eblock_b,local_cell_ids_b,local_side_ids_b,vertex_coordinates_b,
626 template<
typename ArrayT>
627 std::vector<panzer::Workset>::iterator
629 const WorksetNeeds & needs_a,
630 const std::string & eblock_a,
631 const std::vector<std::size_t>& local_cell_ids_a,
632 const std::vector<std::size_t>& local_side_ids_a,
633 const ArrayT& vertex_coordinates_a,
634 const WorksetNeeds & needs_b,
635 const std::string & eblock_b,
636 const std::vector<std::size_t>& local_cell_ids_b,
637 const std::vector<std::size_t>& local_side_ids_b,
638 const ArrayT& vertex_coordinates_b,
639 std::vector<Workset>::iterator beg)
643 std::vector<Workset>::iterator wkst = beg;
645 std::size_t current_cell_index = 0;
646 while (current_cell_index<cell_indices.size()) {
647 std::size_t workset_size = needs_a.cellData.numCells();
653 wkst->subcell_dim = needs_a.cellData.baseCellDimension()-1;
655 wkst->details(0).subcell_index = local_side_ids_a[cell_indices[current_cell_index]];
656 wkst->details(0).block_id = eblock_a;
657 wkst->details(0).cell_vertex_coordinates = mdArrayFactory.buildStaticArray<double,Cell,NODE,Dim>(
"cvc",workset_size,
658 vertex_coordinates_a.dimension(1),
659 vertex_coordinates_a.dimension(2));
661 wkst->details(1).subcell_index = local_side_ids_b[cell_indices[current_cell_index]];
662 wkst->details(1).block_id = eblock_b;
663 wkst->details(1).cell_vertex_coordinates = mdArrayFactory.buildStaticArray<double,Cell,NODE,Dim>(
"cvc",workset_size,
664 vertex_coordinates_a.dimension(1),
665 vertex_coordinates_a.dimension(2));
667 std::size_t remaining_cells = cell_indices.size()-current_cell_index;
668 if(remaining_cells<workset_size)
669 workset_size = remaining_cells;
672 wkst->num_cells = workset_size;
673 wkst->details(0).cell_local_ids.resize(workset_size);
674 wkst->details(1).cell_local_ids.resize(workset_size);
676 for(std::size_t cell=0;cell<workset_size; cell++,current_cell_index++) {
678 wkst->details(0).cell_local_ids[cell] = local_cell_ids_a[cell_indices[current_cell_index]];
679 wkst->details(1).cell_local_ids[cell] = local_cell_ids_b[cell_indices[current_cell_index]];
681 for (std::size_t vertex = 0; vertex < Teuchos::as<std::size_t>(vertex_coordinates_a.dimension(1)); ++ vertex) {
682 for (std::size_t dim = 0; dim < Teuchos::as<std::size_t>(vertex_coordinates_a.dimension(2)); ++ dim) {
683 wkst->details(0).cell_vertex_coordinates(cell,vertex,dim) = vertex_coordinates_a(cell_indices[current_cell_index],vertex,dim);
684 wkst->details(1).cell_vertex_coordinates(cell,vertex,dim) = vertex_coordinates_b(cell_indices[current_cell_index],vertex,dim);
689 Kokkos::View<int*,PHX::Device> cell_local_ids_k_0 = Kokkos::View<int*,PHX::Device>(
"Workset:cell_local_ids",wkst->details(0).cell_local_ids.size());
690 Kokkos::View<int*,PHX::Device> cell_local_ids_k_1 = Kokkos::View<int*,PHX::Device>(
"Workset:cell_local_ids",wkst->details(1).cell_local_ids.size());
691 for(std::size_t i=0;i<wkst->details(0).cell_local_ids.size();i++)
692 cell_local_ids_k_0(i) = wkst->details(0).cell_local_ids[i];
693 for(std::size_t i=0;i<wkst->details(1).cell_local_ids.size();i++)
694 cell_local_ids_k_1(i) = wkst->details(1).cell_local_ids[i];
695 wkst->details(0).cell_local_ids_k = cell_local_ids_k_0;
696 wkst->details(1).cell_local_ids_k = cell_local_ids_k_1;
699 std::size_t max_workset_size = needs_a.cellData.numCells();
701 populateValueArrays(max_workset_size,
true,needs_b,wkst->details(1),Teuchos::rcpFromRef(wkst->details(0)));
709 template<
typename ArrayT>
710 std::vector<panzer::Workset>::iterator
713 const std::vector<std::size_t>& local_cell_ids_a,
714 const std::vector<std::size_t>& local_side_ids_a,
715 const ArrayT& vertex_coordinates_a,
717 const std::vector<std::size_t>& local_cell_ids_b,
718 const std::vector<std::size_t>& local_side_ids_b,
719 const ArrayT& vertex_coordinates_b,
720 std::vector<Workset>::iterator beg)
725 WorksetNeeds needs_a;
728 const std::map<int,RCP<panzer::IntegrationRule> >& int_rules_a = pb_a.
getIntegrationRules();
729 for(std::map<
int,RCP<panzer::IntegrationRule> >::const_iterator ir_itr = int_rules_a.begin();
730 ir_itr != int_rules_a.end(); ++ir_itr)
731 needs_a.int_rules.push_back(ir_itr->second);
733 const std::map<std::string,Teuchos::RCP<panzer::PureBasis> >& bases_a = pb_a.
getBases();
735 b_itr != bases_a.end(); ++b_itr)
736 needs_a.bases.push_back(b_itr->second);
738 WorksetNeeds needs_b;
741 const std::map<int,RCP<panzer::IntegrationRule> >& int_rules_b = pb_b.
getIntegrationRules();
742 for(std::map<
int,RCP<panzer::IntegrationRule> >::const_iterator ir_itr = int_rules_b.begin();
743 ir_itr != int_rules_b.end(); ++ir_itr)
744 needs_b.int_rules.push_back(ir_itr->second);
746 const std::map<std::string,Teuchos::RCP<panzer::PureBasis> >& bases_b = pb_b.
getBases();
748 b_itr != bases_b.end(); ++b_itr)
749 needs_b.bases.push_back(b_itr->second);
752 needs_a,pb_a.
elementBlockID(),local_cell_ids_a,local_side_ids_a,vertex_coordinates_a,
753 needs_b,pb_b.
elementBlockID(),local_cell_ids_b,local_side_ids_b,vertex_coordinates_b,
771 const std::vector<std::size_t>& sib )
775 auto sip2i_p =
Teuchos::rcp(
new std::map< std::pair<std::size_t, std::size_t>, std::vector<std::size_t> >);
776 auto& sip2i = *sip2i_p;
778 for (std::size_t i = 0; i < sia.size(); ++i)
779 sip2i[std::make_pair(sia[i], sib[i])].push_back(i);
784 template<
typename ArrayT>
787 const std::vector<std::size_t>& local_cell_ids_a,
788 const std::vector<std::size_t>& local_side_ids_a,
789 const ArrayT& vertex_coordinates_a,
791 const std::vector<std::size_t>& local_cell_ids_b,
792 const std::vector<std::size_t>& local_side_ids_b,
793 const ArrayT& vertex_coordinates_b,
796 TEUCHOS_ASSERT(local_cell_ids_a.size() == local_cell_ids_b.size());
799 mwa =
buildBCWorkset(pb_a, local_cell_ids_a, local_side_ids_a, vertex_coordinates_a),
801 vertex_coordinates_b,
false );
803 for (std::map<unsigned,panzer::Workset>::iterator ait = mwa->begin(), bit = mwb->begin();
804 ait != mwa->end(); ++ait, ++bit) {
805 TEUCHOS_ASSERT(Teuchos::as<std::size_t>(ait->second.num_cells) == local_cell_ids_a.size() &&
806 Teuchos::as<std::size_t>(bit->second.num_cells) == local_cell_ids_b.size());
811 populateValueArrays(wa.num_cells,
true, needs_b, wa.details(1), Teuchos::rcpFromRef(wa.details(0)));
818 template <
typename T>
819 void subset(
const std::vector<T>& a,
const std::vector<std::size_t>& idxs, std::vector<T>& s)
821 s.resize(idxs.size());
822 for (std::size_t i = 0; i < idxs.size(); ++i)
828 template<
typename ArrayT>
831 const std::vector<std::size_t>& local_cell_ids_a,
832 const std::vector<std::size_t>& local_side_ids_a,
833 const ArrayT& vertex_coordinates_a,
835 const std::vector<std::size_t>& local_cell_ids_b,
836 const std::vector<std::size_t>& local_side_ids_b,
837 const ArrayT& vertex_coordinates_b)
840 WorksetNeeds needs_b;
843 const std::map<int,Teuchos::RCP<panzer::IntegrationRule> >& int_rules = pb_b.
getIntegrationRules();
845 ir_itr != int_rules.end(); ++ir_itr)
846 needs_b.int_rules.push_back(ir_itr->second);
847 const std::map<std::string,Teuchos::RCP<panzer::PureBasis> >& bases= pb_b.
getBases();
849 b_itr != bases.end(); ++b_itr)
850 needs_b.bases.push_back(b_itr->second);
857 if (side_id_associations->size() == 1) {
860 pb_b, local_cell_ids_b, local_side_ids_b, vertex_coordinates_b,
866 std::vector<std::size_t> lci_a, lci_b, lsi_a, lsi_b;
868 const int d1 = Teuchos::as<std::size_t>(vertex_coordinates_a.dimension(1)),
869 d2 = Teuchos::as<std::size_t>(vertex_coordinates_a.dimension(2));
870 for (
auto it : *side_id_associations) {
871 const auto& idxs = it.second;
876 auto vc_a = mdArrayFactory.buildStaticArray<double,Cell,NODE,Dim>(
"vc_a", idxs.size(), d1, d2);
877 auto vc_b = mdArrayFactory.buildStaticArray<double,Cell,NODE,Dim>(
"vc_b", idxs.size(), d1, d2);
878 for (std::size_t i = 0; i < idxs.size(); ++i) {
879 const auto ii = idxs[i];
880 for (
int j = 0; j < d1; ++j)
881 for (
int k = 0; k < d2; ++k) {
882 vc_a(i, j, k) = vertex_coordinates_a(ii, j, k);
883 vc_b(i, j, k) = vertex_coordinates_b(ii, j, k);
892 const std::size_t key = lsi_a[0] * 1000 + lsi_b[0];
893 (*mwa)[key] = mwa_it->begin()->second;
Teuchos::RCP< std::map< unsigned, Workset > > buildBCWorkset(const PhysicsBlock &volume_pb, const std::vector< std::size_t > &local_cell_ids, const std::vector< std::size_t > &local_side_ids, const ArrayT &vertex_coordinates)
Object that contains information on the physics and discretization of a block of elements with the SA...
std::string elementBlockID() const
PHX::MDField< ScalarT > vector
Teuchos::RCP< std::vector< Workset > > buildEdgeWorksets(const PhysicsBlock &pb_a, const std::vector< std::size_t > &local_cell_ids_a, const std::vector< std::size_t > &local_side_ids_a, const ArrayT &vertex_coordinates_a, const PhysicsBlock &pb_b, const std::vector< std::size_t > &local_cell_ids_b, const std::vector< std::size_t > &local_side_ids_b, const ArrayT &vertex_coordinates_b)
TEUCHOS_DEPRECATED RCP< T > rcp(T *p, Dealloc_T dealloc, bool owns_mem)
Teuchos::RCP< std::map< std::pair< std::size_t, std::size_t >, std::vector< std::size_t > > > associateCellsBySideIds(const std::vector< std::size_t > &sia, const std::vector< std::size_t > &sib)
Teuchos::RCP< std::vector< Workset > > buildWorksets(const PhysicsBlock &pb, const std::vector< std::size_t > &local_cell_ids, const ArrayT &vertex_coordinates)
const panzer::CellData & cellData() const
void subset(const std::vector< T > &a, const std::vector< std::size_t > &idxs, std::vector< T > &s)
const std::map< std::string, Teuchos::RCP< panzer::PureBasis > > & getBases() const
Returns the unique set of bases, key is the unique panzer::PureBasis::name() of the basis...
Teuchos::RCP< WorksetDetails > other
#define TEUCHOS_ASSERT(assertion_test)
void populateValueArrays(std::size_t num_cells, bool isSide, const WorksetNeeds &needs, WorksetDetails &details, const Teuchos::RCP< WorksetDetails > other_details)
const std::map< int, Teuchos::RCP< panzer::IntegrationRule > > & getIntegrationRules() const
Returns the unique set of point rules, key is the unique panzer::PointRule::name() ...
Teuchos::RCP< std::map< unsigned, panzer::Workset > > buildBCWorksetForUniqueSideId(const panzer::PhysicsBlock &pb_a, const std::vector< std::size_t > &local_cell_ids_a, const std::vector< std::size_t > &local_side_ids_a, const ArrayT &vertex_coordinates_a, const panzer::PhysicsBlock &pb_b, const std::vector< std::size_t > &local_cell_ids_b, const std::vector< std::size_t > &local_side_ids_b, const ArrayT &vertex_coordinates_b, const WorksetNeeds &needs_b)