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