Panzer_BlockedDOFManager.hpp

Go to the documentation of this file.

// @HEADER
// *****************************************************************************
//           Panzer: A partial differential equation assembly
//       engine for strongly coupled complex multiphysics systems
//
// Copyright 2011 NTESS and the Panzer contributors.
// SPDX-License-Identifier: BSD-3-Clause
// *****************************************************************************
// @HEADER
 
#ifndef __Panzer_BlockedDOFManager_hpp__
#define __Panzer_BlockedDOFManager_hpp__
 
#include <map>
#include <set>
 
#ifdef HAVE_MPI
   #include <mpi.h>
#endif
 
#include "PanzerDofMgr_config.hpp"
#include "Panzer_FieldPattern.hpp"
#include "Panzer_FieldAggPattern.hpp"
#include "Panzer_ConnManager.hpp"
#include "Panzer_GlobalIndexer.hpp"
#include "Panzer_DOFManager.hpp"
#include "Panzer_NodeType.hpp"
#include "Panzer_HashUtils.hpp"
 
#include "Teuchos_RCP.hpp"
#include "Teuchos_DefaultMpiComm.hpp"
 
#include <unordered_set>
 
namespace panzer {
 
class BlockedDOFManager : public GlobalIndexer {
public:
   // typedef std::pair<int,GlobalOrdinalT> GlobalOrdinal;
  using GlobalOrdinal = panzer::GlobalOrdinal;
  using LocalOrdinal = panzer::LocalOrdinal;
  using const_field_iterator = std::map<int,std::string>::const_iterator;
 
   virtual ~BlockedDOFManager() {}
 
   BlockedDOFManager();
 
   BlockedDOFManager(const Teuchos::RCP<ConnManager> & connMngr,MPI_Comm mpiComm);
 
 
 
   virtual Teuchos::RCP<Teuchos::Comm<int> > getComm() const
   { return communicator_; }
 
   int getFieldNum(const std::string & str) const; // ?
 
   const std::string & getFieldString(int num) const;
 
   virtual void getElementBlockIds(std::vector<std::string> & elementBlockIds) const
   { getConnManager()->getElementBlockIds(elementBlockIds); }
 
   virtual bool fieldInBlock(const std::string & field, const std::string & block) const; // ?
 
   virtual const std::vector<LocalOrdinal> & getElementBlock(const std::string & blockId) const // ?
   { return getConnManager()->getElementBlock(blockId); }
 
   virtual const std::vector<int> & getBlockFieldNumbers(const std::string & block) const; // ?
 
   void getElementGIDs(panzer::LocalOrdinal localElmtId,std::vector<GlobalOrdinal> & gids,const std::string & blockIdHint="") const; // ?
 
  void getElementGIDsPair(panzer::LocalOrdinal localElmtId,std::vector<std::pair<int,GlobalOrdinal>> & gids,const std::string & blockIdHint="") const;
 
   virtual void getElementOrientation(panzer::LocalOrdinal localElmtId,std::vector<double> & gidsOrientation) const; // ?
 
   virtual const std::vector<int> & getGIDFieldOffsets(const std::string & blockId,int fieldNum) const; // ?
 
   virtual const std::pair<std::vector<int>,std::vector<int> > &
   getGIDFieldOffsets_closure(const std::string & blockId,int fieldNum,int subcellDim,int subcellId) const; // ?
 
   virtual void getOwnedIndices(std::vector<GlobalOrdinal>& indices) const;
 
   virtual void
   getGhostedIndices(std::vector<GlobalOrdinal>& indices) const;
 
   virtual void
   getOwnedAndGhostedIndices(std::vector<GlobalOrdinal>& indices) const;
  
   // For backwards compatibility with Epetra. Will be deprecated.
   void getElementGIDsAsInt(panzer::LocalOrdinal localElmtId,std::vector<int> & gids,const std::string & blockIdHint="") const;
   virtual void getOwnedIndicesAsInt(std::vector<int>& indices) const;
   virtual void getGhostedIndicesAsInt(std::vector<int>& indices) const;
   virtual void getOwnedAndGhostedIndicesAsInt(std::vector<int>& indices) const;
 
   virtual int
   getNumOwned() const;
 
   virtual int
   getNumGhosted() const;
 
   virtual int
   getNumOwnedAndGhosted() const;
 
   virtual void ownedIndices(const std::vector<GlobalOrdinal> & indices,std::vector<bool> & isOwned) const; // ?
 
 
 
   void setUseDOFManagerFEI(bool useFEI)
   { useDOFManagerFEI_ = useFEI; }
 
   bool getUseDOFManagerFEI() const
   {
     return false;
   }
 
   void setConnManager(const Teuchos::RCP<ConnManager> & connMngr,MPI_Comm mpiComm);
 
 
   Teuchos::RCP<const FieldPattern> getGeometricFieldPattern() const // ?
   { return geomPattern_; }
 
   Teuchos::RCP<ConnManager> resetIndices(); // ?
 
   void addField(const std::string & str,const Teuchos::RCP<const FieldPattern> & pattern);
 
   void addField(const std::string & blockId,const std::string & str,const Teuchos::RCP<const FieldPattern> & pattern);
 
   void setFieldOrder(const std::vector<std::vector<std::string> > & fieldOrder);
 
   int getNumFieldBlocks() const;
 
   void getFieldOrder(std::vector<std::vector<std::string> > & fieldOrder) const;
 
   void getFieldOrder(std::vector<std::string>& /* fieldOrder */) const { TEUCHOS_ASSERT(false); } // what???
 
   Teuchos::RCP<const FieldPattern> getFieldPattern(const std::string & blockId, const std::string & fieldName) const; // ?
 
   int getNumFields() const; // ?
 
   Teuchos::RCP<const ConnManager> getConnManager() const
   { return connMngr_; }
 
   Teuchos::RCP<ConnManager> getConnManager()
   { return connMngr_; }
 
   virtual void buildGlobalUnknowns();
 
   virtual void buildGlobalUnknowns(const Teuchos::RCP<const FieldPattern> & geomPattern);
 
   virtual void buildGlobalUnknowns(const std::vector<Teuchos::RCP<GlobalIndexer>> & fieldBlockManagers);
 
   void printFieldInformation(std::ostream & os) const; // ?
 
   bool validFieldOrder(const std::vector<std::vector<std::string> > & fieldOrder_ut,const std::set<std::string> & fields) const;
 
   void registerFields(bool buildSubUGIs);
 
   bool fieldsRegistered() const
   { return fieldsRegistered_; }
 
   const std::vector<Teuchos::RCP<GlobalIndexer>> &
   getFieldDOFManagers() const
   { return fieldBlockManagers_; }
 
   inline int getMaxSubFieldNumber() const
   { return maxSubFieldNum_; }
 
   int getFieldBlock(int fieldNum) const
   { return fieldNumToFieldBlk_.find(fieldNum)->second; }
 
   int getBlockGIDOffset(const std::string & elementBlock,int fieldBlock) const
   {
      std::map<std::pair<std::string,int>,int>::const_iterator itr =
            blockGIDOffset_.find(std::make_pair(elementBlock,fieldBlock));
 
      if(itr==blockGIDOffset_.end())
         return -1;
      else
         return itr->second;
   }
 
   bool getOrientationsRequired() const
   { return requireOrientations_; }
 
   void setOrientationsRequired(bool ro)
   { requireOrientations_ = ro; }
 
   void enableTieBreak(bool useTieBreak)
   { useTieBreak_ = useTieBreak; }
 
   virtual int getElementBlockGIDCount(const std::string & blockId) const;
 
   virtual int getElementBlockGIDCount(const std::size_t & blockIndex) const;
 
protected:
 
   Teuchos::RCP<GlobalIndexer> buildNewIndexer(const Teuchos::RCP<ConnManager> & connManager,
                                                     MPI_Comm mpiComm) const;
 
   void setOrientationsRequired(const Teuchos::RCP<GlobalIndexer> & indexer,bool required) const;
 
   void buildGlobalUnknowns(const Teuchos::RCP<GlobalIndexer> & indexer,const Teuchos::RCP<const FieldPattern> & geomPattern) const;
 
   int getElementBlockGIDCount(const Teuchos::RCP<GlobalIndexer> & indexer,const std::string & elementBlock) const;
 
   int getElementBlockGIDCount(const Teuchos::RCP<GlobalIndexer> & indexer,const std::size_t & blockIndex) const;
 
   void printFieldInformation(const Teuchos::RCP<GlobalIndexer> & indexer,std::ostream & os) const;
 
   void addFieldsToFieldBlockManager(const std::vector<std::string> & activeFields,
                                     GlobalIndexer & fieldBlockManager) const;
 
   void addFieldsToFieldBlockManager(const std::vector<std::string> & activeFields,
                                     DOFManager & fieldBlockManager) const;
 
   // computes connectivity
   Teuchos::RCP<ConnManager> connMngr_;
 
 
 
   std::map<std::string,int> fieldStrToNum_;
 
   std::map<int,std::string> fieldNumToStr_;
 
   std::map<int,int> fieldNumToFieldBlk_;
 
   std::map<std::pair<std::string,std::string>,Teuchos::RCP<const FieldPattern> > fieldStringToPattern_;
 
   std::map<std::string,std::set<std::string> > blockIdToFieldStrings_;
 
   std::map<std::string,std::vector<int> > blockIdToFieldNumbers_;
 
   std::map<std::pair<std::string,int>,int> blockGIDOffset_;
 
 
   // storage for fast lookups of GID ownership
  //std::unordered_set<GlobalOrdinal,panzer::pair_hash> ownedGIDHashTable_;
 
   std::vector<std::vector<std::string> > fieldOrder_;
 
   bool fieldsRegistered_;
 
   Teuchos::RCP<const FieldPattern> geomPattern_;
   Teuchos::RCP<Teuchos::MpiComm<int> > communicator_;
 
   std::vector<Teuchos::RCP<GlobalIndexer>> fieldBlockManagers_;
 
   MPI_Comm mpiComm_;
   int maxSubFieldNum_;
 
   mutable std::map<std::string,std::map<int,std::vector<int> > > gidFieldOffsets_;
 
   struct LessThan
   { bool operator()(const Teuchos::Tuple<int,3> & a,const Teuchos::Tuple<int,3> & b) const; };
   typedef std::map<Teuchos::Tuple<int,3>, std::pair<std::vector<int>,std::vector<int> >,LessThan> TupleToVectorPairMap;
 
   mutable std::map<std::string,TupleToVectorPairMap> gidFieldOffsets_closure_;
 
   bool requireOrientations_;
 
   bool useDOFManagerFEI_;
   bool useTieBreak_;
};
 
}
 
#endif