43 #ifndef PANZER_BLOCKED_DOF_MANAGER_IMPL_HPP 44 #define PANZER_BLOCKED_DOF_MANAGER_IMPL_HPP 51 #include "Teuchos_DefaultMpiComm.hpp" 61 template <
typename LocalOrdinalT,
typename GlobalOrdinalT>
63 : fieldsRegistered_(false), maxSubFieldNum_(-1), requireOrientations_(false), useDOFManagerFEI_(true), useTieBreak_(false)
66 template <
typename LocalOrdinalT,
typename GlobalOrdinalT>
68 : fieldsRegistered_(false), maxSubFieldNum_(-1), requireOrientations_(false), useDOFManagerFEI_(true), useTieBreak_(false)
76 template <
typename LocalOrdinalT,
typename GlobalOrdinalT>
79 std::map<std::string,int>::const_iterator itr = fieldStrToNum_.find(str);
82 if(itr==fieldStrToNum_.end()) {
84 TEUCHOS_TEST_FOR_EXCEPTION(
true,std::logic_error,
85 "BlockedDOFManager::getFieldNum No field with the name \"" + str +
"\" has been added");
92 template <
typename LocalOrdinalT,
typename GlobalOrdinalT>
95 std::map<int,std::string>::const_iterator itr = fieldNumToStr_.find(number);
98 if(itr==fieldNumToStr_.end()) {
99 std::stringstream ss; ss << number;
101 TEUCHOS_TEST_FOR_EXCEPTION(
true,std::logic_error,
102 "BlockedDOFManager::getFieldString No field with number \"" + ss.str() +
"\" has been added");
109 template <
typename LocalOrdinalT,
typename GlobalOrdinalT>
113 std::map<std::string,std::set<std::string> >::const_iterator fieldsItr = blockIdToFieldStrings_.find(block);
114 TEUCHOS_TEST_FOR_EXCEPTION(fieldsItr==blockIdToFieldStrings_.end(),std::logic_error,
115 "BlockedDOFManager::fieldInBlock could not find the element block \""+block+
"\"");
118 const std::set<std::string> & fields = fieldsItr->second;
119 std::set<std::string>::const_iterator itr = fields.find(
field);
120 return itr!=fields.end();
125 template <
typename LocalOrdinalT,
typename GlobalOrdinalT>
129 std::map<std::string,std::vector<int> >::const_iterator fieldsItr = blockIdToFieldNumbers_.find(block);
130 if(fieldsItr!=blockIdToFieldNumbers_.end())
131 return fieldsItr->second;
134 static std::vector<int> empty;
138 template <
typename LocalOrdinalT,
typename GlobalOrdinalT>
152 for(std::size_t fbm=0;fbm<fieldBlockManagers_.size();fbm++) {
153 std::vector<GlobalOrdinalT> fieldBlockOwned;
155 fieldBlockManagers_[fbm]->getElementGIDs(localElmtId,fieldBlockOwned,blockIdHint);
157 for(std::size_t i=0;i<fieldBlockOwned.size();i++)
158 gids.push_back(std::make_pair(fbm,fieldBlockOwned[i]));
162 template <
typename LocalOrdinalT,
typename GlobalOrdinalT>
173 gidsOrientation.resize(0);
176 for(std::size_t fbm=0;fbm<fieldBlockManagers_.size();fbm++) {
177 std::vector<double> blkOrientation;
179 fieldBlockManagers_[fbm]->getElementOrientation(localElmtId,blkOrientation);
181 for(std::size_t i=0;i<blkOrientation.size();i++)
182 gidsOrientation.push_back(blkOrientation[i]);
186 template <
typename LocalOrdinalT,
typename GlobalOrdinalT>
189 typedef std::map<std::string,std::map<int,std::vector<int> > > FieldOffsetsMap;
191 FieldOffsetsMap::iterator blockItr = gidFieldOffsets_.find(blockId);
192 if(blockItr!=gidFieldOffsets_.end()) {
193 std::map<int,std::vector<int> > & fieldToVectorMap = blockItr->second;
194 std::map<int,std::vector<int> >::const_iterator itr = fieldToVectorMap.find(fieldNum);
197 if(itr!=fieldToVectorMap.end())
201 std::vector<std::string> elementBlocks;
202 getElementBlockIds(elementBlocks);
203 TEUCHOS_TEST_FOR_EXCEPTION(std::find(elementBlocks.begin(),elementBlocks.end(),blockId)==elementBlocks.end(),std::logic_error,
204 "BlockedDOFManager::getGIDFieldOffsets: Block ID \""+blockId+
"\" does not exist");
206 gidFieldOffsets_[blockId] = std::map<int,std::vector<int> >();
207 blockItr = gidFieldOffsets_.find(blockId);
211 std::map<int,std::vector<int> > & fieldToVectorMap = blockItr->second;
218 Teuchos::RCP<const UniqueGlobalIndexer<LocalOrdinalT,GlobalOrdinalT> > dofManager = fieldBlockManagers_[fieldBlock];
221 const std::vector<int> & subGIDOffsets
222 = dofManager->getGIDFieldOffsets(blockId,dofManager->getFieldNum(getFieldString(fieldNum)));
225 int gidOffset = getBlockGIDOffset(blockId,fieldBlock);
226 std::vector<int> & finalFieldOffsets = fieldToVectorMap[fieldNum];
227 finalFieldOffsets.resize(subGIDOffsets.size());
228 for(std::size_t i=0;i<finalFieldOffsets.size();i++)
229 finalFieldOffsets[i] = gidOffset+subGIDOffsets[i];
231 return finalFieldOffsets;
234 template <
typename LocalOrdinalT,
typename GlobalOrdinalT>
236 ::operator()(
const Teuchos::Tuple<int,3> & a,
const Teuchos::Tuple<int,3> & b)
const 238 if(a[0] < b[0])
return true;
239 if(a[0] > b[0])
return false;
242 if(a[1] < b[1])
return true;
243 if(a[1] > b[1])
return false;
246 if(a[2] < b[2])
return true;
247 if(a[2] > b[2])
return false;
253 template <
typename LocalOrdinalT,
typename GlobalOrdinalT>
254 const std::pair<std::vector<int>,std::vector<int> > &
257 typename std::map<std::string,TupleToVectorPairMap>::iterator blockItr = gidFieldOffsets_closure_.find(blockId);
258 if(blockItr!=gidFieldOffsets_closure_.end()) {
260 typename TupleToVectorPairMap::const_iterator itr =
261 fieldToTupleMap.find(Teuchos::tuple(fieldNum,subcellDim,subcellId));
264 if(itr!=fieldToTupleMap.end())
268 std::vector<std::string> elementBlocks;
269 getElementBlockIds(elementBlocks);
270 TEUCHOS_TEST_FOR_EXCEPTION(std::find(elementBlocks.begin(),elementBlocks.end(),blockId)==elementBlocks.end(),std::logic_error,
271 "BlockedDOFManager::getGIDFieldOffsets: Block ID \""+blockId+
"\" does not exist");
274 blockItr = gidFieldOffsets_closure_.find(blockId);
285 Teuchos::RCP<const UniqueGlobalIndexer<LocalOrdinalT,GlobalOrdinalT> > dofManager = fieldBlockManagers_[fieldBlock];
288 const std::pair<std::vector<int>,std::vector<int> > & subGIDOffsets_closure
289 = dofManager->getGIDFieldOffsets_closure(blockId,dofManager->getFieldNum(getFieldString(fieldNum)),subcellDim,subcellId);
292 int gidOffset = getBlockGIDOffset(blockId,fieldBlock);
293 std::pair<std::vector<int>,std::vector<int> > & finalFieldOffsets = fieldToTupleMap[Teuchos::tuple(fieldNum,subcellDim,subcellId)];
294 finalFieldOffsets.first.resize(subGIDOffsets_closure.first.size());
295 finalFieldOffsets.second = subGIDOffsets_closure.second;
296 for(std::size_t i=0;i<finalFieldOffsets.first.size();i++)
297 finalFieldOffsets.first[i] = gidOffset+subGIDOffsets_closure.first[i];
299 return finalFieldOffsets;
302 template <
typename LocalOrdinalT,
typename GlobalOrdinalT>
306 for(std::size_t fbm=0;fbm<fieldBlockManagers_.size();fbm++) {
307 std::vector<GlobalOrdinalT> fieldBlockOwned;
309 fieldBlockManagers_[fbm]->getOwnedIndices(fieldBlockOwned);
311 for(std::size_t i=0;i<fieldBlockOwned.size();i++)
312 indices.push_back(std::make_pair(fbm,fieldBlockOwned[i]));
316 template <
typename LocalOrdinalT,
typename GlobalOrdinalT>
320 for(std::size_t fbm=0;fbm<fieldBlockManagers_.size();fbm++) {
321 std::vector<GlobalOrdinalT> fieldBlockOwned;
323 fieldBlockManagers_[fbm]->getOwnedAndGhostedIndices(fieldBlockOwned);
325 for(std::size_t i=0;i<fieldBlockOwned.size();i++)
326 indices.push_back(std::make_pair(fbm,fieldBlockOwned[i]));
330 template <
typename LocalOrdinalT,
typename GlobalOrdinalT>
335 std::vector<std::vector<GlobalOrdinalT> > blockIndices(fieldBlockManagers_.size());
336 for(std::size_t i=0;i<indices.size();i++)
337 blockIndices[indices[i].first].push_back(indices[i].second);
340 std::vector<std::vector<bool> > blockIsOwned(fieldBlockManagers_.size());
341 std::vector<std::vector<bool>::const_iterator> blockItrs;
342 for(std::size_t fbm=0;fbm<fieldBlockManagers_.size();fbm++) {
343 fieldBlockManagers_[fbm]->ownedIndices(blockIndices[fbm],blockIsOwned[fbm]);
346 blockItrs.push_back(blockIsOwned[fbm].begin());
351 for(std::size_t i=0;i<indices.size();i++) {
352 int block = indices[i].first;
355 bool owned = *blockItrs[block];
356 isOwned.push_back(owned);
363 TEUCHOS_ASSERT(isOwned.size()==indices.size());
364 for(std::size_t fbm=0;fbm<fieldBlockManagers_.size();fbm++) {
365 TEUCHOS_TEST_FOR_EXCEPTION(blockItrs[fbm]!=blockIsOwned[fbm].end(),std::logic_error,
366 "BlockedDOFManager::ownedIndices: Did not consume all sub block boolean entries as expected.");
387 template <
typename LocalOrdinalT,
typename GlobalOrdinalT>
390 communicator_ = Teuchos::rcp(
new Teuchos::MpiComm<int>(Teuchos::opaqueWrapper(mpiComm)));
395 connMngr_ = connMngr;
397 mpiComm_ = *communicator_->getRawMpiComm();
408 template <
typename LocalOrdinalT,
typename GlobalOrdinalT>
411 Teuchos::RCP<ConnManager<LocalOrdinalT,GlobalOrdinalT> > connMngr = connMngr_;
413 connMngr_ = Teuchos::null;
414 ownedGIDHashTable_.clear();
415 blockGIDOffset_.clear();
417 #ifdef PANZER_HAVE_FEI 418 for(std::size_t fbm=0;fbm<fieldBlockManagers_.size();fbm++) {
419 Teuchos::RCP<DOFManagerFEI<LocalOrdinalT,GlobalOrdinalT> > dofMngr
420 = Teuchos::rcp_dynamic_cast<DOFManagerFEI<LocalOrdinalT,GlobalOrdinalT> >(fieldBlockManagers_[fbm]);
421 if(dofMngr!=Teuchos::null)
422 dofMngr->resetIndices();
429 template <
typename LocalOrdinalT,
typename GlobalOrdinalT>
431 const Teuchos::RCP<const FieldPattern> & pattern)
433 std::vector<std::string> elementBlockIds;
434 connMngr_->getElementBlockIds(elementBlockIds);
437 for(std::size_t i=0;i<elementBlockIds.size();i++)
438 addField(elementBlockIds[i],str,pattern);
441 template <
typename LocalOrdinalT,
typename GlobalOrdinalT>
443 const Teuchos::RCP<const FieldPattern> & pattern)
445 TEUCHOS_TEST_FOR_EXCEPTION(fieldsRegistered(),std::logic_error,
446 "BlockedDOFManager::addField: addField cannot be called after registerFields or" 447 "buildGlobalUnknowns has been called");
449 fieldStringToPattern_[std::make_pair(blockId,str)] = pattern;
450 blockIdToFieldStrings_[blockId].insert(str);
453 template <
typename LocalOrdinalT,
typename GlobalOrdinalT>
457 fieldBlockManagers_.clear();
458 fieldStrToNum_.clear();
459 fieldNumToStr_.clear();
460 fieldNumToFieldBlk_.clear();
461 maxSubFieldNum_ = -1;
463 fieldsRegistered_ =
false;
468 std::set<std::string> fields;
469 for(std::map<std::pair<std::string,std::string>,Teuchos::RCP<const FieldPattern> >::const_iterator
470 fieldItr=fieldStringToPattern_.begin(); fieldItr!=fieldStringToPattern_.end();++fieldItr) {
471 std::string fieldName = fieldItr->first.second;
472 fields.insert(fieldName);
476 if(fieldOrder_.size()==0) {
477 std::set<std::string>::const_iterator itr;
478 for(itr=fields.begin();itr!=fields.end();itr++) {
479 std::vector<std::string> block;
480 block.push_back(*itr);
481 fieldOrder_.push_back(block);
486 bool validOrder = validFieldOrder(fieldOrder_,fields);
489 std::stringstream ss;
491 ss <<
"BlockedDOFManager::registerFields - Field order is invalid!\n";
493 ss <<
" fields = [ ";
494 for(std::set<std::string>::const_iterator itr=fields.begin();
495 itr!=fields.end();++itr)
496 ss <<
"\"" << *itr <<
"\" ";
499 ss <<
" fieldOrder = [ ";
500 for(
std::vector<std::vector<std::string> >::const_iterator bitr=fieldOrder_.begin();
501 bitr!=fieldOrder_.end();++bitr) {
503 for(std::vector<std::string>::const_iterator itr=bitr->begin();
504 itr!=bitr->end();++itr) {
505 ss <<
"\"" << *itr <<
"\" ";
511 TEUCHOS_TEST_FOR_EXCEPTION(!validOrder,std::logic_error,ss.str());
517 for(std::size_t fldBlk=0;fldBlk<fieldOrder_.size();fldBlk++) {
518 Teuchos::RCP<panzer::UniqueGlobalIndexer<LocalOrdinalT,GlobalOrdinalT> > dofManager = buildNewIndexer(getConnManager(),mpiComm_);
521 this->addFieldsToFieldBlockManager(fieldOrder_[fldBlk],*dofManager);
523 fieldBlockManagers_.push_back(dofManager);
535 maxSubFieldNum_ = -1;
536 std::map<std::string,int> tempStrToNum;
537 for(std::size_t fldBlk=0;fldBlk<fieldBlockManagers_.size();fldBlk++) {
538 Teuchos::RCP<const panzer::UniqueGlobalIndexer<LocalOrdinalT,GlobalOrdinalT> > dofManager =
539 fieldBlockManagers_[fldBlk];
540 const std::vector<std::string> & activeFields = fieldOrder_[fldBlk];
543 for(std::size_t f=0;f<activeFields.size();f++) {
544 fieldNum = dofManager->getFieldNum(activeFields[f]);
545 tempStrToNum[activeFields[f]] = fieldNum;
547 maxSubFieldNum_ = (fieldNum>maxSubFieldNum_) ? fieldNum : maxSubFieldNum_;
554 for(std::size_t fldBlk=0;fldBlk<fieldBlockManagers_.size();fldBlk++) {
555 const std::vector<std::string> & activeFields = fieldOrder_[fldBlk];
557 for(std::size_t f=0;f<activeFields.size();f++) {
559 int fieldNum = tempStrToNum[activeFields[f]]+numOffset;
562 fieldStrToNum_[activeFields[f]] = fieldNum;
563 fieldNumToStr_[fieldNum] = activeFields[f];
564 fieldNumToFieldBlk_[fieldNum] = fldBlk;
568 numOffset += (maxSubFieldNum_+1);
576 for(std::map<std::string,std::set<std::string> >::const_iterator itr=blockIdToFieldStrings_.begin();
577 itr!=blockIdToFieldStrings_.end();++itr) {
578 const std::set<std::string> & fields = itr->second;
580 std::vector<int> & fieldNums = blockIdToFieldNumbers_[itr->first];
581 for(std::set<std::string>::const_iterator fldItr=fields.begin();
582 fldItr!=fields.end();++fldItr) {
583 fieldNums.push_back(getFieldNum(*fldItr));
588 fieldsRegistered_ =
true;
591 template <
typename LocalOrdinalT,
typename GlobalOrdinalT>
592 Teuchos::RCP<UniqueGlobalIndexer<LocalOrdinalT,GlobalOrdinalT> >
596 #ifdef PANZER_HAVE_FEI 597 if(getUseDOFManagerFEI()) {
598 Teuchos::RCP<panzer::DOFManagerFEI<LocalOrdinalT,GlobalOrdinalT> > dofManager = Teuchos::rcp(
new panzer::DOFManagerFEI<LocalOrdinalT,GlobalOrdinalT>);
599 dofManager->setConnManager(connManager,mpiComm);
606 dofManager->enableTieBreak(useTieBreak_);
607 dofManager->setConnManager(connManager,mpiComm);
613 dofManager->enableTieBreak(useTieBreak_);
614 dofManager->setConnManager(connManager,mpiComm);
621 template <
typename LocalOrdinalT,
typename GlobalOrdinalT>
626 using Teuchos::rcp_dynamic_cast;
632 if(dofManager!=Teuchos::null) {
638 #ifdef PANZER_HAVE_FEI 641 RCP<DOFManagerFEI<LocalOrdinalT,GlobalOrdinalT> > dofManager = rcp_dynamic_cast<DOFManagerFEI<LocalOrdinalT,GlobalOrdinalT> >(indexer);
643 if(dofManager!=Teuchos::null) {
644 dofManager->setOrientationsRequired(required);
651 TEUCHOS_ASSERT(
false);
654 template <
typename LocalOrdinalT,
typename GlobalOrdinalT>
659 using Teuchos::rcp_dynamic_cast;
665 if(dofManager!=Teuchos::null) {
671 #ifdef PANZER_HAVE_FEI 674 RCP<DOFManagerFEI<LocalOrdinalT,GlobalOrdinalT> > dofManager = rcp_dynamic_cast<DOFManagerFEI<LocalOrdinalT,GlobalOrdinalT> >(indexer);
676 if(dofManager!=Teuchos::null) {
677 dofManager->buildGlobalUnknowns(geomPattern);
684 TEUCHOS_ASSERT(
false);
687 template <
typename LocalOrdinalT,
typename GlobalOrdinalT>
692 using Teuchos::rcp_dynamic_cast;
698 if(dofManager!=Teuchos::null) {
704 #ifdef PANZER_HAVE_FEI 707 RCP<DOFManagerFEI<LocalOrdinalT,GlobalOrdinalT> > dofManager = rcp_dynamic_cast<DOFManagerFEI<LocalOrdinalT,GlobalOrdinalT> >(indexer);
709 if(dofManager!=Teuchos::null) {
710 dofManager->printFieldInformation(os);
717 TEUCHOS_ASSERT(
false);
720 template <
typename LocalOrdinalT,
typename GlobalOrdinalT>
725 using Teuchos::rcp_dynamic_cast;
727 TEUCHOS_ASSERT(indexer!=Teuchos::null);
729 return indexer->getElementBlockGIDCount(elementBlock);
732 template <
typename LocalOrdinalT,
typename GlobalOrdinalT>
737 using Teuchos::rcp_dynamic_cast;
739 TEUCHOS_ASSERT(indexer!=Teuchos::null);
741 return indexer->getElementBlockGIDCount(elementBlock);
744 template <
typename LocalOrdinalT,
typename GlobalOrdinalT>
749 for(std::size_t i=0;i<fieldBlockManagers_.size();i++)
750 gidCount += fieldBlockManagers_[i]->getElementBlockGIDCount(elementBlock);
755 template <
typename LocalOrdinalT,
typename GlobalOrdinalT>
760 for(std::size_t i=0;i<fieldBlockManagers_.size();i++)
761 gidCount += fieldBlockManagers_[i]->getElementBlockGIDCount(elementBlock);
766 template <
typename LocalOrdinalT,
typename GlobalOrdinalT>
772 using Teuchos::ptrFromRef;
773 using Teuchos::ptr_dynamic_cast;
775 Ptr<UniqueGlobalIndexer<LocalOrdinalT,GlobalOrdinalT> > ugi_ptr = ptrFromRef(fieldBlockManager);
781 if(dofManager_ptr!=Teuchos::null) {
782 addFieldsToFieldBlockManager(activeFields,*dofManager_ptr);
787 #ifdef PANZER_HAVE_FEI 790 Ptr<DOFManagerFEI<LocalOrdinalT,GlobalOrdinalT> > dofManager_ptr = ptr_dynamic_cast<DOFManagerFEI<LocalOrdinalT,GlobalOrdinalT> >(ugi_ptr);
792 if(dofManager_ptr!=Teuchos::null) {
793 addFieldsToFieldBlockManager(activeFields,*dofManager_ptr);
800 TEUCHOS_ASSERT(
false);
803 #ifdef PANZER_HAVE_FEI 804 template <
typename LocalOrdinalT,
typename GlobalOrdinalT>
807 DOFManagerFEI<LocalOrdinalT,GlobalOrdinalT> & fieldBlockManager)
const 809 std::vector<std::size_t> correctnessCheck(activeFields.size(),0);
810 std::vector<std::string> elementBlocks;
811 this->getElementBlockIds(elementBlocks);
814 for(std::size_t eb=0;eb<elementBlocks.size();eb++) {
815 std::string elementBlock = elementBlocks[eb];
818 for(std::size_t f=0;f<activeFields.size();f++) {
819 std::string fieldName = activeFields[f];
820 Teuchos::RCP<const FieldPattern> fp = this->getFieldPattern(elementBlock,fieldName);
822 if(fp!=Teuchos::null) {
823 fieldBlockManager.addField(elementBlock,fieldName,fp);
824 correctnessCheck[f] = 1;
830 std::size_t correctFlag = std::accumulate(correctnessCheck.begin(),correctnessCheck.end(),0);
831 TEUCHOS_TEST_FOR_EXCEPTION(correctFlag!=activeFields.size(),std::logic_error,
832 "BlockedDOFManager::addFieldsToFieldBlockManager detected inconsistincies in the active fields.");
835 fieldBlockManager.setFieldOrder(activeFields);
838 fieldBlockManager.registerFields();
842 template <
typename LocalOrdinalT,
typename GlobalOrdinalT>
847 std::vector<std::size_t> correctnessCheck(activeFields.size(),0);
848 std::vector<std::string> elementBlocks;
849 this->getElementBlockIds(elementBlocks);
852 for(std::size_t eb=0;eb<elementBlocks.size();eb++) {
853 std::string elementBlock = elementBlocks[eb];
856 for(std::size_t f=0;f<activeFields.size();f++) {
857 std::string fieldName = activeFields[f];
858 Teuchos::RCP<const FieldPattern> fp = this->getFieldPattern(elementBlock,fieldName);
860 if(fp!=Teuchos::null) {
861 fieldBlockManager.
addField(elementBlock,fieldName,fp);
862 correctnessCheck[f] = 1;
868 std::size_t correctFlag = std::accumulate(correctnessCheck.begin(),correctnessCheck.end(),0);
869 TEUCHOS_TEST_FOR_EXCEPTION(correctFlag!=activeFields.size(),std::logic_error,
870 "BlockedDOFManager::addFieldsToFieldBlockManager detected inconsistincies in the active fields.");
876 template <
typename LocalOrdinalT,
typename GlobalOrdinalT>
879 fieldOrder_ = fieldOrder;
884 template <
typename LocalOrdinalT,
typename GlobalOrdinalT>
887 fieldOrder = fieldOrder_;
890 template <
typename LocalOrdinalT,
typename GlobalOrdinalT>
893 if(fieldsRegistered())
894 return fieldStrToNum_.size();
898 std::set<std::string> fields;
899 std::map<std::pair<std::string,std::string>,Teuchos::RCP<const FieldPattern> >::const_iterator itr;
900 for(itr=fieldStringToPattern_.begin();itr!=fieldStringToPattern_.end();++itr)
901 fields.insert(itr->first.second);
903 return fields.size();
910 template <
typename LocalOrdinalT,
typename GlobalOrdinalT>
915 using Teuchos::rcp_dynamic_cast;
917 RCP<const FieldPattern> refGeomPattern;
918 RCP<ConnManager<LocalOrdinalT,GlobalOrdinalT> > refConnManager = getConnManager();
926 TEUCHOS_ASSERT(fieldBlockManagers.size()>0);
929 RCP<const DOFManager<LocalOrdinalT,GlobalOrdinalT> > refDofManager
932 TEUCHOS_TEST_FOR_EXCEPTION(refDofManager==Teuchos::null,std::runtime_error,
933 "panzer::BlockedDOFManager::buildGlobalUnknowns: UGI at index " << 0 <<
934 " is not of DOFManager type!");
936 RCP<const ConnManager<LocalOrdinalT,GlobalOrdinalT> > connManager = refDofManager->getConnManager();
937 TEUCHOS_TEST_FOR_EXCEPTION(refConnManager!=connManager,std::runtime_error,
938 "panzer::BlockedDOFManager::buildGlobalUnknowns: connection manager for UGI " << 0 <<
939 " does not match the reference connection manager");
941 refGeomPattern = refDofManager->getGeometricFieldPattern();
943 for(std::size_t i=1;i<fieldBlockManagers.size();i++) {
944 RCP<const DOFManager<LocalOrdinalT,GlobalOrdinalT> > dofManager
947 TEUCHOS_TEST_FOR_EXCEPTION(refDofManager==Teuchos::null,std::runtime_error,
948 "panzer::BlockedDOFManager::buildGlobalUnknowns: UGI at index " << i <<
949 " is not of DOFManager type!");
951 RCP<const FieldPattern> geomPattern = dofManager->getGeometricFieldPattern();
952 RCP<const ConnManager<LocalOrdinalT,GlobalOrdinalT> > connManager = dofManager->getConnManager();
954 TEUCHOS_TEST_FOR_EXCEPTION(!refGeomPattern->equals(*geomPattern),std::runtime_error,
955 "panzer::BlockedDOFManager::buildGlobalUnknowns: geometric pattern for UGI " << i <<
956 " does not match the reference pattern (from UGI 0)");
957 TEUCHOS_TEST_FOR_EXCEPTION(refConnManager!=connManager,std::runtime_error,
958 "panzer::BlockedDOFManager::buildGlobalUnknowns: connection manager for UGI " << i <<
959 " does not match the reference connection manager (from UGI 0)");
966 std::vector<std::string> eblocks;
967 this->getElementBlockIds(eblocks);
969 for(std::size_t i=0;i<fieldBlockManagers.size();i++) {
970 RCP<const DOFManager<LocalOrdinalT,GlobalOrdinalT> > dofManager
973 for(std::size_t e=0;e<eblocks.size();e++) {
977 for(std::size_t f=0;f<fieldIds.size();f++) {
979 std::string fieldName = dofManager->getFieldString(fieldIds[f]);
980 Teuchos::RCP<const panzer::FieldPattern> fieldPattern
981 = dofManager->getFieldPattern(eblocks[e],fieldName);
984 this->addField(eblocks[e],fieldName,fieldPattern);
991 fieldBlockManagers_ = fieldBlockManagers;
993 registerFields(
false);
995 geomPattern_ = refGeomPattern;
1001 std::vector<std::string> elementBlocks;
1002 getElementBlockIds(elementBlocks);
1003 for(std::size_t eb=0;eb<elementBlocks.size();eb++) {
1005 for(std::size_t fb=0;fb<fieldBlockManagers_.size();fb++) {
1006 int cnt = getElementBlockGIDCount(fieldBlockManagers_[fb],elementBlocks[eb]);
1007 blockGIDOffset_[std::make_pair(elementBlocks[eb],fb)] =
offset;
1018 template <
typename LocalOrdinalT,
typename GlobalOrdinalT>
1021 if(!fieldsRegistered()) {
1022 registerFields(
true);
1026 geomPattern_ = geomPattern;
1029 for(std::size_t fb=0;fb<fieldBlockManagers_.size();fb++) {
1030 setOrientationsRequired(fieldBlockManagers_[fb],getOrientationsRequired());
1031 buildGlobalUnknowns(fieldBlockManagers_[fb],geomPattern_);
1036 std::vector<std::string> elementBlocks;
1037 getElementBlockIds(elementBlocks);
1038 for(std::size_t eb=0;eb<elementBlocks.size();eb++) {
1040 for(std::size_t fb=0;fb<fieldBlockManagers_.size();fb++) {
1042 int cnt = getElementBlockGIDCount(fieldBlockManagers_[fb],elementBlocks[eb]);
1043 blockGIDOffset_[std::make_pair(elementBlocks[eb],fb)] =
offset;
1053 template <
typename LocalOrdinalT,
typename GlobalOrdinalT>
1056 if(!fieldsRegistered())
1057 registerFields(
true);
1060 std::vector<RCP<const FieldPattern> > patVector;
1061 std::map<std::pair<std::string,std::string>,Teuchos::RCP<const FieldPattern> >::iterator f2p_itr;
1062 for(f2p_itr=fieldStringToPattern_.begin();f2p_itr!=fieldStringToPattern_.end();f2p_itr++)
1063 patVector.push_back(f2p_itr->second);
1066 if(requireOrientations_)
1067 patVector.push_back(Teuchos::rcp(
new NodalFieldPattern(patVector[0]->getCellTopology())));
1070 aggFieldPattern->buildPattern(patVector);
1073 connMngr_->buildConnectivity(*aggFieldPattern);
1076 buildGlobalUnknowns(aggFieldPattern);
1079 template <
typename LocalOrdinalT,
typename GlobalOrdinalT>
1082 os <<
"BlockedDOFManager Field Information: " << std::endl;
1084 if(fieldsRegistered()) {
1086 for(std::size_t fbm=0;fbm<fieldBlockManagers_.size();fbm++) {
1087 os <<
"*************************************************\n";
1088 os <<
"Field Block Index = " << fbm << std::endl;
1089 printFieldInformation(fieldBlockManagers_[fbm],os);
1092 os <<
" Field String to Field Id (blocked/sub):\n";
1093 for(std::size_t i=0;i<fieldOrder_[fbm].size();i++) {
1094 std::string fieldString = fieldOrder_[fbm][i];
1095 int fieldNum = getFieldNum(fieldString);
1096 os <<
" \"" << fieldString <<
"\" is field ID " << fieldNum
1097 <<
"/" << fieldBlockManagers_[fbm]->getFieldNum(fieldString) << std::endl;
1104 os <<
"Fields not yet registered! Unknowns not built (call registerFields or buildGlobalUnknowns)" << std::endl;
1108 template <
typename LocalOrdinalT,
typename GlobalOrdinalT>
1109 Teuchos::RCP<const FieldPattern>
1112 std::map<std::pair<std::string,std::string>,Teuchos::RCP<const FieldPattern> >::const_iterator itr;
1113 itr = fieldStringToPattern_.find(std::make_pair(blockId,fieldName));
1115 if(itr==fieldStringToPattern_.end())
1116 return Teuchos::null;
1129 template <
typename LocalOrdinalT,
typename GlobalOrdinalT>
1131 const std::set<std::string> & fields)
const 1133 std::set<std::string> orderedFields;
1134 std::size_t numberInOrder = 0;
1136 for(std::size_t b=0;b<fieldOrder_ut.size();b++) {
1137 numberInOrder += fieldOrder_ut[b].size();
1138 orderedFields.insert(fieldOrder_ut[b].begin(),
1139 fieldOrder_ut[b].end());
1142 bool correctCount = (numberInOrder==fields.size());
1143 bool sameFields = (orderedFields==fields);
1145 return correctCount && sameFields;
1148 template <
typename LocalOrdinalT,
typename GlobalOrdinalT>
1151 if(fieldOrder_.size()==0)
1153 return fieldOrder_.size();
int getFieldBlock(const std::string &fieldName, const std::vector< Teuchos::RCP< UniqueGlobalIndexer< LocalOrdinalT, GlobalOrdinalT > > > &ugis)
const std::vector< int > & getBlockFieldNumbers(const std::string &blockId) const
Teuchos::RCP< const FieldPattern > getFieldPattern(const std::string &blockId, const std::string &fieldName) const
Find a field pattern stored for a particular block and field number. This will retrive the pattern ad...
void setOrientationsRequired(bool ro)
void setOrientationsRequired(bool ro)
virtual 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 setConnManager(const Teuchos::RCP< ConnManager< LocalOrdinalT, GlobalOrdinalT > > &connMngr, MPI_Comm mpiComm)
Set the connection manager and MPI_Comm objects.
Teuchos::RCP< UniqueGlobalIndexer< LocalOrdinalT, GlobalOrdinalT > > buildNewIndexer(const Teuchos::RCP< ConnManager< LocalOrdinalT, GlobalOrdinalT > > &connManager, MPI_Comm mpiComm) const
void printFieldInformation(std::ostream &os) const
virtual void getOwnedIndices(std::vector< GlobalOrdinal > &indices) const
virtual const std::vector< int > & getBlockFieldNumbers(const std::string &block) const
void addField(const std::string &str, const Teuchos::RCP< const FieldPattern > &pattern)
Add a field to the DOF manager.
PHX::MDField< ScalarT > vector
int getNumFields() const
How many fields are handled by this manager.
virtual void buildGlobalUnknowns()
void addFieldsToFieldBlockManager(const std::vector< std::string > &activeFields, UniqueGlobalIndexer< LocalOrdinalT, GlobalOrdinalT > &fieldBlockManager) const
Teuchos::RCP< ConnManager< LocalOrdinalT, GlobalOrdinalT > > resetIndices()
Reset the indicies for this DOF manager.
virtual void getOwnedAndGhostedIndices(std::vector< GlobalOrdinal > &indices) const
virtual int getElementBlockGIDCount(const std::string &blockId) const
How any GIDs are associate with a particular element block.
void setFieldOrder(const std::vector< std::string > &fieldOrder)
virtual void getElementOrientation(LocalOrdinalT localElmtId, std::vector< double > &gidsOrientation) const
Get a vector containg the orientation of the GIDs relative to the neighbors.
int addField(const std::string &str, const Teuchos::RCP< const FieldPattern > &pattern)
Add a field to the DOF manager.
bool operator()(const Teuchos::Tuple< int, 3 > &a, const Teuchos::Tuple< int, 3 > &b) const
void buildGlobalUnknowns()
builds the global unknowns array
PHX::MDField< const ScalarT, Cell, IP > field
const std::string & getFieldString(int num) const
Get the string name associated with a field number.
virtual const std::vector< int > & getGIDFieldOffsets(const std::string &blockId, int fieldNum) const
Use the field pattern so that you can find a particular field in the GIDs array.
void registerFields(bool buildSubUGIs)
int getNumFieldBlocks() const
int getFieldNum(const std::string &str) const
Get the number used for access to this field.
void setFieldOrder(const std::vector< std::vector< std::string > > &fieldOrder)
void printFieldInformation(std::ostream &os) const
bool validFieldOrder(const std::vector< std::vector< std::string > > &fieldOrder_ut, const std::set< std::string > &fields) const
virtual bool fieldInBlock(const std::string &field, const std::string &block) const
void getFieldOrder(std::vector< std::vector< std::string > > &fieldOrder) const
std::map< Teuchos::Tuple< int, 3 >, std::pair< std::vector< int >, std::vector< int > >, LessThan > TupleToVectorPairMap
virtual void ownedIndices(const std::vector< GlobalOrdinal > &indices, std::vector< bool > &isOwned) const
void getElementGIDs(LocalOrdinalT localElmtId, std::vector< GlobalOrdinal > &gids, const std::string &blockIdHint="") const
Get the global IDs for a particular element. This function overwrites the gids variable.