Panzer_DOFManager.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_DOFManager_hpp__
#define __Panzer_DOFManager_hpp__
#include <map>
 
#include <mpi.h>
 
#include "PanzerDofMgr_config.hpp"
#include "Panzer_FieldPattern.hpp"
#include "Panzer_FieldAggPattern.hpp"
#include "Panzer_GeometricAggFieldPattern.hpp"
#include "Panzer_ConnManager.hpp"
#include "Panzer_GlobalIndexer.hpp"
#include "Panzer_NodeType.hpp"
#include "Panzer_FieldType.hpp"
#include "Phalanx_KokkosDeviceTypes.hpp"
#include "Phalanx_KokkosViewOfViews.hpp"
 
#include "Teuchos_RCP.hpp"
 
#include "Tpetra_Map.hpp"
#include "Tpetra_MultiVector.hpp"
 
namespace panzer {
 
class DOFManager : public GlobalIndexer {
public:
 
  virtual ~DOFManager() {}
 
  DOFManager();
 
  DOFManager(const Teuchos::RCP<ConnManager> & connMngr, MPI_Comm mpiComm);
 
  void setConnManager(const Teuchos::RCP<ConnManager> & connMngr, MPI_Comm mpiComm);
 
  Teuchos::RCP<const ConnManager> getConnManager() const
  { return connMngr_; }
 
  int addField(const std::string & str, const Teuchos::RCP<const FieldPattern> & pattern,
               const panzer::FieldType& type = panzer::FieldType::CG);
 
  int addField(const std::string & blockID, const std::string & str,
               const Teuchos::RCP<const FieldPattern> & pattern,
               const panzer::FieldType& type = panzer::FieldType::CG);
 
  Teuchos::RCP<const FieldPattern> getFieldPattern(const std::string & name) const;
 
  Teuchos::RCP<const FieldPattern> getFieldPattern(const std::string & blockId, const std::string & fieldName) const;
 
  void getOwnedIndices(std::vector<panzer::GlobalOrdinal>& indices) const;
 
  void getGhostedIndices(std::vector<panzer::GlobalOrdinal>& indices) const;
 
  void getOwnedAndGhostedIndices(std::vector<panzer::GlobalOrdinal>& indices) const;
 
  // Epetra specifiic interfaces. Will be deprecated.
  void getElementGIDsAsInt(panzer::LocalOrdinal localElementID, std::vector<int> & gids, const std::string & blockIdHint="") const;
  void getOwnedIndicesAsInt(std::vector<int>& indices) const;
  void getGhostedIndicesAsInt(std::vector<int>& indices) const;
  void getOwnedAndGhostedIndicesAsInt(std::vector<int>& indices) const;
 
  int
  getNumOwned() const;
 
  int
  getNumGhosted() const;
 
  int
  getNumOwnedAndGhosted() const;
 
  int getNumFields() const;
 
  const std::vector<int> & getGIDFieldOffsets(const std::string & blockID, int fieldNum) const;
 
  const PHX::View<const int*> getGIDFieldOffsetsKokkos(const std::string & blockID, int fieldNum) const;
 
 
  const PHX::ViewOfViews<1,PHX::View<const int*>> getGIDFieldOffsetsKokkos(const std::string & blockID, const std::vector<int> & fieldNum) const;
 
  void getElementGIDs(panzer::LocalOrdinal localElementID, std::vector<panzer::GlobalOrdinal> & gids, const std::string & blockIdHint="") const;
 
  virtual void buildGlobalUnknowns();
 
  virtual void buildGlobalUnknowns(const Teuchos::RCP<const FieldPattern> & geomPattern);
 
  int getFieldNum(const std::string & string) const;
 
  Teuchos::RCP<Teuchos::Comm<int> > getComm() const
  { return communicator_; }
 
  Teuchos::RCP<const FieldPattern> getGeometricFieldPattern() const
  { return ga_fp_; }
 
  void getElementBlockIds(std::vector<std::string> & elementBlockIds) const
  { connMngr_->getElementBlockIds(elementBlockIds); }
 
  bool fieldInBlock(const std::string & field, const std::string & block) const;
 
  const std::vector<int> & getBlockFieldNumbers(const std::string & blockId) const;
 
//************************************************************************
 
  const std::pair<std::vector<int>,std::vector<int> > &
  getGIDFieldOffsets_closure(const std::string & blockId, int fieldNum, int subcellDim,int subcellId) const;
 
  const std::vector<panzer::LocalOrdinal> & getElementBlock(const std::string & blockId) const
  { return connMngr_->getElementBlock(blockId); }
 
  void ownedIndices(const std::vector<panzer::GlobalOrdinal> & indices,std::vector<bool> & isOwned) const;
 
  void setFieldOrder(const std::vector<std::string> & fieldOrder );
 
  void getFieldOrder(std::vector<std::string> & fieldOrder) const;
 
  bool validFieldOrder(const std::vector<std::string> & proposed_fieldOrder);
 
  //TODO:this
  void buildUnknownsOrientation();
 
  bool getOrientationsRequired() const
  { return requireOrientations_; }
 
  void setOrientationsRequired(bool ro)
  { requireOrientations_ = ro; }
 
  void getElementOrientation(panzer::LocalOrdinal localElmtId,std::vector<double> & gidsOrientation) const;
 
  const std::string & getFieldString(int num) const;
 
  Teuchos::RCP<ConnManager> resetIndices();
 
  virtual int getElementBlockGIDCount(const std::string & blockId) const
  { return getElementBlockGIDCount(blockIdToIndex(blockId)); }
 
  virtual int getElementBlockGIDCount(const std::size_t & blockIndex) const
  { return elementBlockGIDCount_[blockIndex]; }
 
  void printFieldInformation(std::ostream & os) const;
 
  void enableTieBreak(bool enable)
  { useTieBreak_ = enable; }
 
  void useNeighbors(bool flag)
  { useNeighbors_ = flag; }
 
  // These functions are primarily for testing purposes
  // they are not intended to be useful otherwise (thus they are not
  // documented in the Doxygen style
 
  // Return the number of elemnts as measured by the count of GID arrays.
  // note that this will include ghosted elements!
  std::size_t getNumberElementGIDArrays() const
  { return elementGIDs_.size(); }
 
protected:
 
  Teuchos::RCP<const Tpetra::Map<panzer::LocalOrdinal,panzer::GlobalOrdinal,panzer::TpetraNodeType> >
  runLocalRCMReordering(const Teuchos::RCP<const Tpetra::Map<panzer::LocalOrdinal,panzer::GlobalOrdinal,panzer::TpetraNodeType> > &);
 
  std::size_t blockIdToIndex(const std::string & blockId) const;
 
  class ElementBlockAccess {
  public:
    bool useOwned_;
    Teuchos::RCP<const ConnManager> connMngr_;
  public:
    ElementBlockAccess(bool owned,const Teuchos::RCP<const ConnManager> & connMngr)
      : useOwned_(owned), connMngr_(connMngr) {}
 
    const std::vector<panzer::LocalOrdinal> & getElementBlock(const std::string & eBlock) const
    {
      if(useOwned_==true)
        return connMngr_->getElementBlock(eBlock);
      else
        return connMngr_->getNeighborElementBlock(eBlock);
    }
  };
 
  virtual Teuchos::RCP<const Tpetra::Map<panzer::LocalOrdinal,panzer::GlobalOrdinal,panzer::TpetraNodeType> >
  buildOverlapMapFromElements(const ElementBlockAccess & access) const;
 
  virtual Teuchos::RCP<Tpetra::MultiVector<panzer::GlobalOrdinal,panzer::LocalOrdinal,panzer::GlobalOrdinal,panzer::TpetraNodeType> >
  buildTaggedMultiVector(const ElementBlockAccess & access);
 
  virtual 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;
 
  virtual 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 buildLocalIdsFromOwnedAndGhostedElements();
 
  Teuchos::RCP<ConnManager> connMngr_;
  Teuchos::RCP<Teuchos::Comm<int> > communicator_;
 
  //Please note: AID=absolute ID. This is an attempt to remember that
  // fieldPatterns_ is unchanging storage for FPs.
  std::vector<Teuchos::RCP<const FieldPattern> > fieldPatterns_;
  std::vector<FieldType> fieldTypes_; // FieldType for a Field Pattern. Use AID to access just like fieldPatterns_.
  std::map<std::string,int> fieldNameToAID_;
 
  std::vector<std::string> blockOrder_; // Get this from the ConnManager.
  std::map<std::string,int> blockNameToID_; // I'm not sure the above vector is needed, this might suffice.
  std::vector<std::vector<int> > blockToAssociatedFP_; // each sub-vector is associated by
  // a block, with ordering given in blockOrder_. ints refer to the order in fieldPatterns_;
  std::vector<std::string> fieldStringOrder_;
  std::vector<int> fieldAIDOrder_; // Both of these must be updated and edited together.
  // The AID offers a simpler way to manage FPs internally.
 
  Teuchos::RCP<const panzer::FieldPattern> ga_fp_; // geometric aggregate field pattern
  std::vector<Teuchos::RCP<panzer::FieldAggPattern> > fa_fps_; //Ordered by blockOrder_;
 
  std::vector<panzer::GlobalOrdinal> owned_;
  std::vector<panzer::GlobalOrdinal> ghosted_;
 
  // Element GIDS ordered by LID.
  std::vector<std::vector< panzer::GlobalOrdinal > > elementGIDs_;
 
  // Mimics the functionality of the getElemenentBlockGIDCount in
  // the original DOFManager. Indexed according to blockOrder_.
  std::vector<int> elementBlockGIDCount_;
 
  int numFields_;
 
  bool buildConnectivityRun_;
 
  bool requireOrientations_;
  std::vector<std::vector<signed char> > orientation_;
 
  bool useTieBreak_;
  bool useNeighbors_;
};
 
}
 
#endif