43 #ifndef PANZER_DOF_MANAGER2_IMPL_HPP 44 #define PANZER_DOF_MANAGER2_IMPL_HPP 51 #include "PanzerDofMgr_config.hpp" 59 #include "Teuchos_GlobalMPISession.hpp" 62 #include "Teuchos_RCP.hpp" 63 #include "Teuchos_Array.hpp" 64 #include "Teuchos_ArrayView.hpp" 66 #include "Tpetra_Map.hpp" 67 #include "Tpetra_Export.hpp" 68 #include "Tpetra_Vector.hpp" 69 #include "Tpetra_MultiVector.hpp" 71 #include <unordered_set> 85 template <
typename LocalOrdinal,
typename GlobalOrdinal>
86 class HashTieBreak :
public Tpetra::Details::TieBreak<LocalOrdinal,GlobalOrdinal> {
90 HashTieBreak(
const unsigned int seed = (2654435761U))
93 virtual std::size_t selectedIndex(GlobalOrdinal GID,
94 const std::vector<std::pair<int,LocalOrdinal> > & pid_and_lid)
const 97 int intkey = (int) ((GID & 0x000000007fffffffLL) +
98 ((GID & 0x7fffffff80000000LL) >> 31));
99 return std::size_t((
seed_ ^ intkey) % pid_and_lid.size());
107 template <
typename LocalOrdinal,
typename GlobalOrdinal>
108 class GreedyTieBreak :
public Tpetra::Details::TieBreak<LocalOrdinal,GlobalOrdinal> {
113 virtual bool mayHaveSideEffects()
const {
117 virtual std::size_t selectedIndex(GlobalOrdinal ,
118 const std::vector<std::pair<int,LocalOrdinal> > & pid_and_lid)
const 121 const std::size_t numLids = pid_and_lid.size();
123 int minpid = pid_and_lid[0].first;
124 std::size_t minidx = 0;
125 for (idx = 0; idx < numLids; ++idx) {
126 if (pid_and_lid[idx].first < minpid) {
127 minpid = pid_and_lid[idx].first;
143 using Teuchos::ArrayRCP;
144 using Teuchos::Array;
145 using Teuchos::ArrayView;
149 : numFields_(0),buildConnectivityRun_(false),requireOrientations_(false), useTieBreak_(false), useNeighbors_(false)
154 : numFields_(0),buildConnectivityRun_(false),requireOrientations_(false), useTieBreak_(false), useNeighbors_(false)
163 "DOFManager::setConnManager: setConnManager cannot be called after " 164 "buildGlobalUnknowns has been called");
183 "DOFManager::addField: addField cannot be called after " 184 "buildGlobalUnknowns has been called");
203 int DOFManager::addField(
const std::string & blockID,
const std::string & str,
const Teuchos::RCP<const FieldPattern> & pattern,
207 "DOFManager::addField: addField cannot be called after " 208 "buildGlobalUnknowns has been called");
209 TEUCHOS_TEST_FOR_EXCEPTION((
connMngr_==Teuchos::null),std::logic_error,
210 "DOFManager::addField: you must add a ConnManager before" 211 "you can associate a FP with a given block.")
221 TEUCHOS_TEST_FOR_EXCEPTION(!found,std::logic_error,
"DOFManager::addField: Invalid block name.");
226 std::map<std::string,int>::const_iterator fpIter =
fieldNameToAID_.find(str);
252 std::map<std::string,int>::const_iterator fitr =
fieldNameToAID_.find(name);
254 return Teuchos::null;
259 return Teuchos::null;
265 std::map<std::string,int>::const_iterator fitr =
fieldNameToAID_.find(fieldName);
267 return Teuchos::null;
280 return Teuchos::null;
289 return Teuchos::null;
309 for (
size_t i(0); i <
owned_.size(); ++i)
311 for (
size_t i(0); i <
ghosted_.size(); ++i)
318 const auto & element_ids =
elementGIDs_[localElementID];
319 gids.resize(element_ids.size());
320 for (std::size_t i=0; i < gids.size(); ++i)
321 gids[i] = element_ids[i];
327 indices.resize(
owned_.size());
328 for (std::size_t i=0; i <
owned_.size(); ++i)
336 for (std::size_t i=0; i <
ghosted_.size(); ++i)
344 for (std::size_t i=0; i <
owned_.size(); ++i)
346 for (std::size_t i=0; i <
ghosted_.size(); ++i)
375 const std::vector<int> &
378 TEUCHOS_TEST_FOR_EXCEPTION(!
buildConnectivityRun_,std::logic_error,
"DOFManager::getGIDFieldOffsets: cannot be called before " 379 "buildGlobalUnknowns has been called");
380 std::map<std::string,int>::const_iterator bitr =
blockNameToID_.find(blockID);
382 TEUCHOS_TEST_FOR_EXCEPTION(
true,std::logic_error,
"DOFManager::fieldInBlock: invalid block name");
383 int bid=bitr->second;
384 if(
fa_fps_[bid]!=Teuchos::null)
385 return fa_fps_[bid]->localOffsets(fieldNum);
387 static const std::vector<int> empty;
392 const PHX::View<const int*>
395 TEUCHOS_TEST_FOR_EXCEPTION(!
buildConnectivityRun_,std::logic_error,
"DOFManager::getGIDFieldOffsets: cannot be called before " 396 "buildGlobalUnknowns has been called");
397 std::map<std::string,int>::const_iterator bitr =
blockNameToID_.find(blockID);
399 TEUCHOS_TEST_FOR_EXCEPTION(
true,std::logic_error,
"DOFManager::fieldInBlock: invalid block name");
402 int bid=bitr->second;
403 if(
fa_fps_[bid]!=Teuchos::null)
404 return fa_fps_[bid]->localOffsetsKokkos(fieldNum);
406 static const PHX::View<int*> empty(
"panzer::DOFManager::getGIDFieldOffsetsKokkos() empty",0);
428 std::vector<std::pair<FieldType,Teuchos::RCP<const FieldPattern>>> tmp;
434 connMngr_->buildConnectivity(*aggFieldPattern);
445 typedef Tpetra::Map<panzer::LocalOrdinal, panzer::GlobalOrdinal, Node> Map;
447 typedef Tpetra::Import<panzer::LocalOrdinal,panzer::GlobalOrdinal,Node> Import;
450 typedef Tpetra::MultiVector<panzer::GlobalOrdinal,panzer::LocalOrdinal,panzer::GlobalOrdinal,Node> MultiVector;
452 PANZER_FUNC_TIME_MONITOR_DIFF(
"panzer::DOFManager::buildGlobalUnknowns",
buildGlobalUnknowns);
454 Teuchos::FancyOStream out(Teuchos::rcpFromRef(std::cout));
455 out.setOutputToRootOnly(-1);
456 out.setShowProcRank(
true);
459 "DOFManager::buildGlobalUnknowns: buildGlobalUnknowns cannot be called again " 460 "after buildGlobalUnknowns has been called");
465 std::size_t sz = geomPattern->getSubcellIndices(0,0).size();
467 TEUCHOS_TEST_FOR_EXCEPTION(sz==0,std::logic_error,
468 "DOFManager::buildGlobalUnknowns requires a geometric pattern including " 469 "the nodes when orientations are needed!");
484 RCP<const Map> overlap_map = tagged_overlap_mv->getMap();
486 RCP<MultiVector> overlap_mv = Tpetra::createMultiVector<panzer::GlobalOrdinal>(overlap_map,(size_t)
numFields_);
490 RCP<MultiVector> non_overlap_mv = non_overlap_pair.first;
491 RCP<MultiVector> tagged_non_overlap_mv = non_overlap_pair.second;
492 RCP<const Map> non_overlap_map = non_overlap_mv->getMap();
507 RCP<const Map> overlap_map_neighbor =
511 Import imp_neighbor(non_overlap_map,overlap_map_neighbor);
513 Teuchos::RCP<MultiVector> overlap_mv_neighbor =
514 Tpetra::createMultiVector<panzer::GlobalOrdinal>(overlap_map_neighbor, (size_t)
numFields_);
517 overlap_mv_neighbor->doImport(*non_overlap_mv, imp_neighbor,
521 *overlap_map_neighbor, *overlap_mv_neighbor);
530 panzer::GlobalOrdinal offset = 0xFFFFFFFFLL;
533 const std::vector<panzer::LocalOrdinal> & myElements =
connMngr_->getElementBlock(
blockOrder_[b]);
534 for (std::size_t l = 0; l < myElements.size(); ++l) {
535 std::vector<panzer::GlobalOrdinal> & localGIDs =
elementGIDs_[myElements[l]];
536 for(std::size_t c=0;c<localGIDs.size();c++)
537 localGIDs[c] += offset;
541 Teuchos::ArrayRCP<panzer::GlobalOrdinal> nvals = non_overlap_mv->get1dViewNonConst();
542 for (
int j = 0; j < nvals.size(); ++j)
549 PANZER_FUNC_TIME_MONITOR_DIFF(
"panzer::DOFManager::buildGlobalUnknowns::build_owned_vector",build_owned_vector);
551 typedef std::unordered_set<panzer::GlobalOrdinal> HashTable;
552 HashTable isOwned, remainingOwned;
555 auto nvals = non_overlap_mv->getLocalViewHost(Tpetra::Access::ReadOnly);
556 auto tagged_vals = tagged_non_overlap_mv->getLocalViewHost(Tpetra::Access::ReadOnly);
557 TEUCHOS_ASSERT(nvals.size()==tagged_vals.size());
558 for (
size_t i = 0; i < nvals.extent(1); ++i) {
559 for (
size_t j = 0; j < nvals.extent(0); ++j) {
560 if (nvals(j,i) != -1) {
561 for(panzer::GlobalOrdinal offset=0;offset<tagged_vals(j,i);++offset)
562 isOwned.insert(nvals(j,i)+offset);
566 TEUCHOS_ASSERT(tagged_vals(j,i)==0);
570 remainingOwned = isOwned;
578 const std::vector<panzer::LocalOrdinal> & myElements =
connMngr_->getElementBlock(
blockOrder_[b]);
580 for (
size_t l = 0; l < myElements.size(); ++l) {
581 const std::vector<panzer::GlobalOrdinal> & localOrdering =
elementGIDs_[myElements[l]];
584 for(std::size_t i=0;i<localOrdering.size();i++) {
586 if(isOwned.find(localOrdering[i])==isOwned.end())
590 std::pair<typename HashTable::iterator,bool> insertResult = hashTable.insert(localOrdering[i]);
591 if(insertResult.second) {
592 owned_.push_back(localOrdering[i]);
593 remainingOwned.erase(localOrdering[i]);
602 for(
typename HashTable::const_iterator itr=remainingOwned.begin();itr!=remainingOwned.end();itr++)
605 if(
owned_.size()!=isOwned.size()) {
606 out <<
"I'm about to hang because of unknown numbering failure ... sorry! (line = " << __LINE__ <<
")" << std::endl;
607 TEUCHOS_TEST_FOR_EXCEPTION(
owned_.size()!=isOwned.size(),std::logic_error,
608 "DOFManager::buildGlobalUnkonwns: Failure because not all owned unknowns have been accounted for.");
619 PANZER_FUNC_TIME_MONITOR_DIFF(
"panzer::DOFManager::buildGlobalUnknowns::build_ghosted_array",BGA);
622 typedef std::unordered_set<panzer::GlobalOrdinal> HashTable;
624 for (std::size_t i = 0; i <
owned_.size(); i++)
625 hashTable.insert(
owned_[i]);
630 std::vector<ElementBlockAccess> blockAccessVec;
634 for (std::size_t a = 0; a < blockAccessVec.size(); ++a)
640 if (
fa_fps_[b] == Teuchos::null)
642 const std::vector<panzer::LocalOrdinal>& myElements =
644 for (
size_t l = 0; l < myElements.size(); ++l)
646 const std::vector<panzer::GlobalOrdinal>& localOrdering =
elementGIDs_[myElements[l]];
649 for (std::size_t i = 0; i < localOrdering.size(); ++i)
651 std::pair<typename HashTable::iterator, bool> insertResult =
652 hashTable.insert(localOrdering[i]);
656 if(insertResult.second)
657 ghosted_.push_back(localOrdering[i]);
668 PANZER_FUNC_TIME_MONITOR_DIFF(
"panzer::DOFManager::buildGlobalUnknowns::build_orientation",BO);
674 PANZER_FUNC_TIME_MONITOR_DIFF(
"panzer::DOFManager::buildGlobalUnknowns::build_local_ids_from_owned_and_ghosted",BLOFOG);
678 PANZER_FUNC_TIME_MONITOR_DIFF(
"panzer::DOFManager::buildGlobalUnknowns::build_local_ids",BLI);
684 std::pair<Teuchos::RCP<Tpetra::MultiVector<panzer::GlobalOrdinal,panzer::LocalOrdinal,panzer::GlobalOrdinal,panzer::TpetraNodeType> >,
685 Teuchos::RCP<Tpetra::MultiVector<panzer::GlobalOrdinal,panzer::LocalOrdinal,panzer::GlobalOrdinal,panzer::TpetraNodeType> > >
687 Tpetra::MultiVector<panzer::GlobalOrdinal,panzer::LocalOrdinal,panzer::GlobalOrdinal,panzer::TpetraNodeType> & overlap_mv)
const 691 typedef Tpetra::Map<panzer::LocalOrdinal, panzer::GlobalOrdinal, Node> Map;
693 typedef Tpetra::Export<panzer::LocalOrdinal,panzer::GlobalOrdinal,Node> Export;
694 typedef Tpetra::Import<panzer::LocalOrdinal,panzer::GlobalOrdinal,Node> Import;
697 typedef Tpetra::MultiVector<panzer::GlobalOrdinal,panzer::LocalOrdinal,panzer::GlobalOrdinal,Node> MultiVector;
699 PANZER_FUNC_TIME_MONITOR_DIFF(
"panzer::DOFManager::buildGlobalUnknowns_GUN",BGU_GUN);
702 RCP<const Map> overlap_map = tagged_overlap_mv.getMap();
709 RCP<const Map> non_overlap_map;
711 PANZER_FUNC_TIME_MONITOR_DIFF(
"panzer::DOFManager::buildGlobalUnknowns_GUN::line_04 createOneToOne",GUN04);
713 GreedyTieBreak<panzer::LocalOrdinal,panzer::GlobalOrdinal> greedy_tie_break;
714 non_overlap_map = Tpetra::createOneToOne<panzer::LocalOrdinal,panzer::GlobalOrdinal,Node>(overlap_map, greedy_tie_break);
719 HashTieBreak<panzer::LocalOrdinal,panzer::GlobalOrdinal> tie_break;
720 non_overlap_map = Tpetra::createOneToOne<panzer::LocalOrdinal,panzer::GlobalOrdinal,Node>(overlap_map,tie_break);
728 Teuchos::RCP<MultiVector> tagged_non_overlap_mv;
730 PANZER_FUNC_TIME_MONITOR_DIFF(
"panzer::DOFManager::buildGlobalUnknowns_GUN::line_05 alloc_unique_mv",GUN05);
732 tagged_non_overlap_mv = Tpetra::createMultiVector<panzer::GlobalOrdinal>(non_overlap_map,(size_t)
numFields_);
741 RCP<MultiVector> non_overlap_mv;
743 PANZER_FUNC_TIME_MONITOR_DIFF(
"panzer::DOFManager::buildGlobalUnknowns_GUN::line_06 export",GUN06);
745 exp = rcp(
new Export(overlap_map,non_overlap_map));
749 tagged_non_overlap_mv->doExport(tagged_overlap_mv,*exp,Tpetra::ABSMAX);
753 non_overlap_mv = rcp(
new MultiVector(*tagged_non_overlap_mv,Teuchos::Copy));
761 panzer::GlobalOrdinal localsum=0;
763 PANZER_FUNC_TIME_MONITOR_DIFF(
"panzer::DOFManager::buildGlobalUnknowns_GUN::line_07-09 local_count",GUN07_09);
764 auto values = non_overlap_mv->getLocalViewDevice(Tpetra::Access::ReadOnly);
765 auto mv_size = values.extent(0);
774 panzer::GlobalOrdinal myOffset = -1;
776 PANZER_FUNC_TIME_MONITOR_DIFF(
"panzer::DOFManager::buildGlobalUnknowns_GUN::line_10 prefix_sum",GUN_10);
779 panzer::GlobalOrdinal scanResult = 0;
780 Teuchos::scan<int, panzer::GlobalOrdinal> (*
getComm(), Teuchos::REDUCE_SUM,
static_cast<panzer::GlobalOrdinal
> (localsum), Teuchos::outArg (scanResult));
781 myOffset = scanResult - localsum;
794 PANZER_FUNC_TIME_MONITOR_DIFF(
"panzer::DOFManager::buildGlobalUnknowns_GUN::line_13-21 gid_assignment",GUN13_21);
796 auto editnonoverlap = non_overlap_mv->getLocalViewHost(Tpetra::Access::ReadWrite);
797 for(
size_t i=0; i<non_overlap_mv->getLocalLength(); ++i){
799 if(editnonoverlap(i,j)!=0){
801 int ndof = Teuchos::as<int>(editnonoverlap(i,j));
802 editnonoverlap(i,j)=myOffset+which_id;
806 editnonoverlap(i,j)=-1;
822 PANZER_FUNC_TIME_MONITOR_DIFF(
"panzer::DOFManager::buildGlobalUnknowns_GUN::line_23 final_import",GUN23);
825 overlap_mv.doImport(*non_overlap_mv,*exp,Tpetra::REPLACE);
831 return std::make_pair(non_overlap_mv,tagged_non_overlap_mv);
835 Teuchos::RCP<Tpetra::MultiVector<panzer::GlobalOrdinal,panzer::LocalOrdinal,panzer::GlobalOrdinal,panzer::TpetraNodeType> >
840 typedef Tpetra::Map<panzer::LocalOrdinal, panzer::GlobalOrdinal, Node> Map;
841 typedef Tpetra::MultiVector<panzer::GlobalOrdinal,panzer::LocalOrdinal,panzer::GlobalOrdinal,Node> MultiVector;
843 PANZER_FUNC_TIME_MONITOR_DIFF(
"panzer::DOFManager::buildTaggedMultiVector",BTMV);
849 std::vector<std::tuple< int, panzer::FieldType, RCP<const panzer::FieldPattern> > > faConstruct;
864 if(faConstruct.size()>0) {
872 fa_fps_.push_back(Teuchos::null);
882 Teuchos::RCP<MultiVector> overlap_mv;
884 PANZER_FUNC_TIME_MONITOR_DIFF(
"panzer::DOFManager::buildTaggedMultiVector::allocate_tagged_multivector",ATMV);
886 overlap_mv = Tpetra::createMultiVector<panzer::GlobalOrdinal>(overlapmap,(size_t)
numFields_);
887 overlap_mv->putScalar(0);
895 PANZER_FUNC_TIME_MONITOR_DIFF(
"panzer::DOFManager::buildTaggedMultiVector::fill_tagged_multivector",FTMV);
898 std::vector<int> working(overlap_mv->getNumVectors());
899 auto edittwoview_host = overlap_mv->getLocalViewHost(Tpetra::Access::ReadWrite);
905 const std::vector<panzer::LocalOrdinal> &
numFields=
fa_fps_[b]->numFieldsPerId();
906 const std::vector<panzer::LocalOrdinal> & fieldIds=
fa_fps_[b]->fieldIds();
907 const std::vector<panzer::LocalOrdinal> & myElements =
connMngr_->getElementBlock(
blockOrder_[b]);
908 for (
size_t l = 0; l < myElements.size(); ++l) {
909 auto connSize =
connMngr_->getConnectivitySize(myElements[l]);
910 const auto * elmtConn =
connMngr_->getConnectivity(myElements[l]);
912 for (
int c = 0; c < connSize; ++c) {
913 size_t lid = overlapmap->getLocalElement(elmtConn[c]);
915 for(std::size_t i=0;i<working.size();i++)
918 int whichField = fieldIds[offset];
921 working[whichField]++;
924 for(std::size_t i=0;i<working.size();i++) {
925 auto current = edittwoview_host(lid,i);
926 edittwoview_host(lid,i) = (current > working[i]) ? current : working[i];
975 std::stringstream ss;
977 TEUCHOS_TEST_FOR_EXCEPTION(
true,std::logic_error,
"DOFManager::fieldInBlock: invalid field name. DOF information is:\n"+ss.str());
979 std::map<std::string,int>::const_iterator bitr =
blockNameToID_.find(block);
981 std::stringstream ss;
983 TEUCHOS_TEST_FOR_EXCEPTION(
true,std::logic_error,
"DOFManager::fieldInBlock: invalid block name. DOF information is:\n"+ss.str());
985 int fid=fitr->second;
986 int bid=bitr->second;
1002 TEUCHOS_TEST_FOR_EXCEPTION(!
buildConnectivityRun_,std::logic_error,
"DOFManager::getBlockFieldNumbers: BuildConnectivity must be run first.");
1004 std::map<std::string,int>::const_iterator bitr =
blockNameToID_.find(blockId);
1006 TEUCHOS_TEST_FOR_EXCEPTION(
true,std::logic_error,
"DOFManager::fieldInBlock: invalid block name");
1007 int bid=bitr->second;
1010 if(
fa_fps_[bid]!=Teuchos::null)
1011 return fa_fps_[bid]->fieldIds();
1014 static std::vector<int> empty;
1019 const std::pair<std::vector<int>,std::vector<int> > &
1022 TEUCHOS_TEST_FOR_EXCEPTION(!
buildConnectivityRun_,std::logic_error,
"DOFManager::getGIDFieldOffsets_closure: BuildConnectivity must be run first.");
1023 std::map<std::string,int>::const_iterator bitr =
blockNameToID_.find(blockId);
1025 TEUCHOS_TEST_FOR_EXCEPTION(
true,std::logic_error,
"DOFManager::getGIDFieldOffsets_closure: invalid block name.");
1028 if(
fa_fps_[bitr->second]!=Teuchos::null)
1029 return fa_fps_[bitr->second]->localOffsets_closure(fieldNum, subcellDim, subcellId);
1031 static std::pair<std::vector<int>,std::vector<int> > empty;
1039 if(indices.size()!=isOwned.size())
1040 isOwned.resize(indices.size(),
false);
1041 typename std::vector<panzer::GlobalOrdinal>::const_iterator endOf =
owned_.end();
1042 for (std::size_t i = 0; i < indices.size(); ++i) {
1043 isOwned[i] = ( std::find(
owned_.begin(),
owned_.end(), indices[i])!=endOf );
1051 "DOFManager::setFieldOrder: setFieldOrder cannot be called after " 1052 "buildGlobalUnknowns has been called");
1061 TEUCHOS_TEST_FOR_EXCEPTION(
true,std::logic_error,
"DOFManager::setFieldOrder: Invalid Field Ordering!");
1074 for (
size_t j = 0; j < proposed_fieldOrder.size(); ++j) {
1089 TEUCHOS_TEST_FOR_EXCEPTION(
true, std::logic_error,
"DOFManager::getFieldString: invalid number");
1103 std::vector<std::string> elementBlockIds;
1104 connMngr_->getElementBlockIds(elementBlockIds);
1107 std::size_t myElementCount = 0;
1108 for(std::vector<std::string>::const_iterator blockItr=elementBlockIds.begin(); blockItr!=elementBlockIds.end();++blockItr)
1109 myElementCount +=
connMngr_->getElementBlock(*blockItr).size();
1115 for(std::vector<std::string>::const_iterator blockItr=elementBlockIds.begin();
1116 blockItr!=elementBlockIds.end();++blockItr) {
1117 const std::string & blockName = *blockItr;
1120 std::map<std::string,int>::const_iterator fap =
blockNameToID_.find(blockName);
1122 TEUCHOS_TEST_FOR_EXCEPTION(
true,std::logic_error,
"DOFManager::buildUnknownsOrientation: invalid block name");
1125 int bid=fap->second;
1127 if(
fa_fps_[bid]==Teuchos::null)
1134 std::vector<std::pair<int,int> > topEdgeIndices;
1138 std::vector<std::vector<int> > topFaceIndices;
1139 if(
ga_fp_->getDimension()==3)
1143 const std::vector<panzer::LocalOrdinal> & elmts =
connMngr_->getElementBlock(blockName);
1144 for(std::size_t e=0;e<elmts.size();e++) {
1146 std::vector<signed char> & eOrientation =
orientation_[elmts[e]];
1151 eOrientation.resize(fieldPattern.
numberIds());
1152 for(std::size_t s=0;s<eOrientation.size();s++)
1153 eOrientation[s] = 1;
1156 auto connSz =
connMngr_->getConnectivitySize(elmts[e]);
1157 const panzer::GlobalOrdinal * connPtr =
connMngr_->getConnectivity(elmts[e]);
1158 const std::vector<panzer::GlobalOrdinal> connectivity(connPtr,connPtr+connSz);
1163 if(
ga_fp_->getDimension()==3)
1172 TEUCHOS_TEST_FOR_EXCEPTION(
orientation_.size()==0,std::logic_error,
1173 "DOFManager::getElementOrientations: Orientations were not constructed!");
1175 const std::vector<signed char> & local_o =
orientation_[localElmtId];
1176 gidsOrientation.resize(local_o.size());
1177 for(std::size_t i=0;i<local_o.size();i++) {
1178 gidsOrientation[i] = double(local_o[i]);
1184 Teuchos::RCP<ConnManager> connMngr =
connMngr_;
1202 std::map<std::string,int>::const_iterator bitr =
blockNameToID_.find(blockId);
1204 TEUCHOS_TEST_FOR_EXCEPTION(
true,std::logic_error,
"DOFManager::fieldInBlock: invalid block name");
1205 return bitr->second;
1211 os <<
"DOFManager Field Information: " << std::endl;
1217 os <<
" Element Block = " <<
blockOrder_[i] << std::endl;
1221 for(std::size_t f=0;f<fieldIds.size();f++)
1222 os <<
" \"" <<
getFieldString(fieldIds[f]) <<
"\" is field ID " << fieldIds[f] << std::endl;
1227 Teuchos::RCP<const Tpetra::Map<panzer::LocalOrdinal,panzer::GlobalOrdinal,panzer::TpetraNodeType> >
1230 PANZER_FUNC_TIME_MONITOR(
"panzer::DOFManager::builderOverlapMapFromElements");
1237 std::set<panzer::GlobalOrdinal> overlapset;
1240 for (
size_t e = 0; e < myElements.size(); ++e) {
1241 auto connSize =
connMngr_->getConnectivitySize(myElements[e]);
1242 const panzer::GlobalOrdinal * elmtConn =
connMngr_->getConnectivity(myElements[e]);
1243 for (
int k = 0; k < connSize; ++k) {
1244 overlapset.insert(elmtConn[k]);
1249 Array<panzer::GlobalOrdinal> overlapVector;
1250 for (
typename std::set<panzer::GlobalOrdinal>::const_iterator itr = overlapset.begin(); itr!=overlapset.end(); ++itr) {
1251 overlapVector.push_back(*itr);
1256 return Tpetra::createNonContigMap<panzer::LocalOrdinal,panzer::GlobalOrdinal>(overlapVector,
getComm());
1262 std::vector<std::vector< panzer::GlobalOrdinal > > & elementGIDs,
1263 const Tpetra::Map<panzer::LocalOrdinal,panzer::GlobalOrdinal,panzer::TpetraNodeType> & overlapmap,
1264 const Tpetra::MultiVector<panzer::GlobalOrdinal,panzer::LocalOrdinal,panzer::GlobalOrdinal,panzer::TpetraNodeType> & const_overlap_mv)
const 1266 using Teuchos::ArrayRCP;
1269 auto overlap_mv =
const_cast<Tpetra::MultiVector<panzer::GlobalOrdinal,panzer::LocalOrdinal,panzer::GlobalOrdinal,panzer::TpetraNodeType>&
>(const_overlap_mv);
1270 const auto twoview_host = overlap_mv.getLocalViewHost(Tpetra::Access::ReadOnly);
1277 if(
fa_fps_[b]==Teuchos::null) {
1279 for (
size_t l = 0; l < myElements.size(); ++l) {
1280 panzer::LocalOrdinal thisID=myElements[l];
1281 if(elementGIDs.size()<=(size_t)thisID)
1282 elementGIDs.resize(thisID+1);
1288 const std::vector<int> & fieldIds=
fa_fps_[b]->fieldIds();
1291 for (
size_t l = 0; l < myElements.size(); ++l) {
1292 auto connSize =
connMngr_->getConnectivitySize(myElements[l]);
1293 const panzer::GlobalOrdinal * elmtConn =
connMngr_->getConnectivity(myElements[l]);
1294 std::vector<panzer::GlobalOrdinal> localOrdering;
1296 for (
int c = 0; c < connSize; ++c) {
1297 size_t lid = overlapmap.getLocalElement(elmtConn[c]);
1299 for (
int n = 0; n <
numFields[c]; ++n) {
1300 int whichField = fieldIds[offset];
1304 localOrdering.push_back(twoview_host(lid,whichField)+dofsPerField[whichField]);
1306 dofsPerField[whichField]++;
1309 panzer::LocalOrdinal thisID=myElements[l];
1310 if(elementGIDs.size()<=(size_t)thisID){
1311 elementGIDs.resize(thisID+1);
1313 elementGIDs[thisID]=localOrdering;
1320 std::vector<std::vector<panzer::LocalOrdinal> > elementLIDs(
elementGIDs_.size());
1322 std::vector<panzer::GlobalOrdinal> ownedAndGhosted;
1326 std::unordered_map<panzer::GlobalOrdinal,panzer::LocalOrdinal> hashMap;
1327 for(std::size_t i = 0; i < ownedAndGhosted.size(); ++i)
1328 hashMap[ownedAndGhosted[i]] = i;
1330 for (std::size_t i = 0; i <
elementGIDs_.size(); ++i) {
1331 const std::vector<panzer::GlobalOrdinal>& gids =
elementGIDs_[i];
1332 std::vector<panzer::LocalOrdinal>&
lids = elementLIDs[i];
1333 lids.resize(gids.size());
1334 for (std::size_t g = 0; g < gids.size(); ++g)
1335 lids[g] = hashMap[gids[g]];
std::vector< std::vector< int > > blockToAssociatedFP_
void setFieldOrder(const std::vector< std::string > &fieldOrder)
Sums all entries of a Rank 2 Kokkos View.
std::vector< Teuchos::RCP< panzer::FieldAggPattern > > fa_fps_
void ownedIndices(const std::vector< panzer::GlobalOrdinal > &indices, std::vector< bool > &isOwned) const
void getFieldOrder(std::vector< std::string > &fieldOrder) const
void buildUnknownsOrientation()
bool getOrientationsRequired() const
std::vector< std::vector< panzer::GlobalOrdinal > > elementGIDs_
const std::pair< std::vector< int >, std::vector< int > > & getGIDFieldOffsets_closure(const std::string &blockId, int fieldNum, int subcellDim, int subcellId) const
Use the field pattern so that you can find a particular field in the GIDs array. This version lets yo...
void getGhostedIndicesAsInt(std::vector< int > &indices) const
Get the set of indices ghosted for this processor.
Teuchos::RCP< Tpetra::MultiVector< panzer::GlobalOrdinal, panzer::LocalOrdinal, panzer::GlobalOrdinal, panzer::TpetraNodeType > > buildTaggedMultiVector(const ElementBlockAccess &access)
const std::vector< panzer::LocalOrdinal > & getElementBlock(const std::string &eBlock) const
void getOwnedAndGhostedIndicesAsInt(std::vector< int > &indices) const
Get the set of owned and ghosted indices for this processor.
FieldType
The type of discretization to use for a field pattern.
Teuchos::RCP< ConnManager > resetIndices()
Reset the indices for this DOF manager.
void buildGlobalUnknowns()
builds the global unknowns array
Teuchos::RCP< const panzer::FieldPattern > ga_fp_
std::size_t blockIdToIndex(const std::string &blockId) const
virtual int numberIds() const
std::vector< int > fieldAIDOrder_
void setConnManager(const Teuchos::RCP< ConnManager > &connMngr, MPI_Comm mpiComm)
Adds a Connection Manager that will be associated with this DOFManager.
std::map< std::string, int > fieldNameToAID_
void getElementGIDs(panzer::LocalOrdinal localElementID, std::vector< panzer::GlobalOrdinal > &gids, const std::string &blockIdHint="") const
get associated GIDs for a given local element
void getOwnedAndGhostedIndices(std::vector< panzer::GlobalOrdinal > &indices) const
Get the set of owned and ghosted indices for this processor.
void getOwnedIndicesAsInt(std::vector< int > &indices) const
Get the set of indices owned by this processor.
std::vector< int > elementBlockGIDCount_
bool buildConnectivityRun_
Teuchos::RCP< Teuchos::Comm< int > > communicator_
Kokkos::Compat::KokkosDeviceWrapperNode< PHX::Device > TpetraNodeType
void computeCellEdgeOrientations(const std::vector< std::pair< int, int > > &topEdgeIndices, const std::vector< panzer::GlobalOrdinal > &topology, const FieldPattern &fieldPattern, std::vector< signed char > &orientation)
std::vector< Teuchos::RCP< const FieldPattern > > fieldPatterns_
void getElementOrientation(panzer::LocalOrdinal localElmtId, std::vector< double > &gidsOrientation) const
Get a vector containg the orientation of the GIDs relative to the neighbors.
void getGhostedIndices(std::vector< panzer::GlobalOrdinal > &indices) const
Get the set of indices ghosted for this processor.
Teuchos::RCP< const Tpetra::Map< panzer::LocalOrdinal, panzer::GlobalOrdinal, panzer::TpetraNodeType > > buildOverlapMapFromElements(const ElementBlockAccess &access) const
void setLocalIds(const std::vector< std::vector< panzer::LocalOrdinal > > &localIDs)
void computePatternFaceIndices(const FieldPattern &pattern, std::vector< std::vector< int > > &faceIndices)
std::vector< panzer::GlobalOrdinal > owned_
std::vector< std::string > blockOrder_
std::vector< panzer::GlobalOrdinal > ghosted_
void computeCellFaceOrientations(const std::vector< std::vector< int > > &topFaceIndices, const std::vector< panzer::GlobalOrdinal > &topology, const FieldPattern &fieldPattern, std::vector< signed char > &orientation)
Teuchos::RCP< ConnManager > connMngr_
Teuchos::RCP< const FieldPattern > getFieldPattern(const std::string &name) const
Find a field pattern stored for a particular block and field number. This will retrive the pattern ad...
const PHX::View< const int * > getGIDFieldOffsetsKokkos(const std::string &blockID, int fieldNum) const
PHX::MDField< ScalarT, panzer::Cell, panzer::BASIS > field
A field to which we'll contribute, or in which we'll store, the result of computing this integral...
void buildLocalIdsFromOwnedAndGhostedElements()
Teuchos::RCP< Teuchos::Comm< int > > getComm() const
int getFieldNum(const std::string &string) const
Get the number used for access to this field.
std::vector< std::string > fieldStringOrder_
std::pair< Teuchos::RCP< Tpetra::MultiVector< panzer::GlobalOrdinal, panzer::LocalOrdinal, panzer::GlobalOrdinal, panzer::TpetraNodeType > >, Teuchos::RCP< Tpetra::MultiVector< panzer::GlobalOrdinal, panzer::LocalOrdinal, panzer::GlobalOrdinal, panzer::TpetraNodeType > > > buildGlobalUnknowns_GUN(const Tpetra::MultiVector< panzer::GlobalOrdinal, panzer::LocalOrdinal, panzer::GlobalOrdinal, panzer::TpetraNodeType > &tagged_overlap_mv, Tpetra::MultiVector< panzer::GlobalOrdinal, panzer::LocalOrdinal, panzer::GlobalOrdinal, panzer::TpetraNodeType > &overlap_mv) const
void getOwnedIndices(std::vector< panzer::GlobalOrdinal > &indices) const
Get the set of indices owned by this processor.
int getNumGhosted() const
Get the number of indices ghosted for this processor.
void printFieldInformation(std::ostream &os) const
const std::vector< int > & getGIDFieldOffsets(const std::string &blockID, int fieldNum) const
bool validFieldOrder(const std::vector< std::string > &proposed_fieldOrder)
std::vector< std::vector< signed char > > orientation_
int addField(const std::string &str, const Teuchos::RCP< const FieldPattern > &pattern, const panzer::FieldType &type=panzer::FieldType::CG)
Add a field to the DOF manager.
int getNumOwnedAndGhosted() const
Get the number of owned and ghosted indices for this processor.
bool requireOrientations_
int getNumFields() const
gets the number of fields
void getElementGIDsAsInt(panzer::LocalOrdinal localElementID, std::vector< int > &gids, const std::string &blockIdHint="") const
Get the global IDs for a particular element. This function overwrites the gids variable.
const std::string & getFieldString(int num) const
Reverse lookup of the field string from a field number.
PHX::View< const LO ** > lids
int getNumOwned() const
Get the number of indices owned by this processor.
const std::vector< int > & getBlockFieldNumbers(const std::string &blockId) const
bool fieldInBlock(const std::string &field, const std::string &block) const
void fillGIDsFromOverlappedMV(const ElementBlockAccess &access, std::vector< std::vector< panzer::GlobalOrdinal > > &elementGIDs, const Tpetra::Map< panzer::LocalOrdinal, panzer::GlobalOrdinal, panzer::TpetraNodeType > &overlapmap, const Tpetra::MultiVector< panzer::GlobalOrdinal, panzer::LocalOrdinal, panzer::GlobalOrdinal, panzer::TpetraNodeType > &overlap_mv) const
void computePatternEdgeIndices(const FieldPattern &pattern, std::vector< std::pair< int, int > > &edgeIndices)
std::vector< FieldType > fieldTypes_
std::map< std::string, int > blockNameToID_