Panzer_STKConnManager.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_STKConnManager_hpp__
#define __Panzer_STKConnManager_hpp__
 
#include <vector>
 
// Teuchos includes
#include "Teuchos_RCP.hpp"
 
// Kokkos includes
#include "Kokkos_DynRankView.hpp"
 
// Panzer includes
#include "Panzer_ConnManager.hpp"
 
#include "Panzer_STK_Interface.hpp"
#include "Panzer_IntrepidFieldPattern.hpp"
 
namespace panzer_stk {

class STKConnManager : public panzer::ConnManager {
public:
   typedef typename panzer::ConnManager::LocalOrdinal LocalOrdinal;
   typedef typename panzer::ConnManager::GlobalOrdinal GlobalOrdinal;
   typedef typename Kokkos::DynRankView<GlobalOrdinal,PHX::Device>::host_mirror_type::const_type GlobalOrdinalView;
   typedef typename Kokkos::DynRankView<LocalOrdinal, PHX::Device>::host_mirror_type::const_type LocalOrdinalView;

   STKConnManager(const Teuchos::RCP<const STK_Interface> & stkMeshDB);

   STKConnManager(const panzer_stk::STKConnManager & cm);
 
   virtual ~STKConnManager() {}

   virtual void buildConnectivity(const panzer::FieldPattern & fp);

   virtual Teuchos::RCP<panzer::ConnManager> noConnectivityClone() const;

   virtual const panzer::GlobalOrdinal * getConnectivity(LocalOrdinal localElmtId) const
   { return &(*connectivityPtr_)[(*elmtLidToConnPtr_)[localElmtId]]; }

   virtual LocalOrdinal getConnectivitySize(LocalOrdinal localElmtId) const
   { return (*connSizePtr_)[localElmtId]; }

   const GlobalOrdinalView getConnectivityView() const
   { return GlobalOrdinalView(connectivityPtr_->data(), connectivityPtr_->size()); }

   const LocalOrdinalView getConnectivitySizeView() const
   { return LocalOrdinalView(connSizePtr_->data(), connSizePtr_->size()); }

   const LocalOrdinalView getElementLidToConnView() const
   { return LocalOrdinalView(elmtLidToConnPtr_->data(), elmtLidToConnPtr_->size()); }

   virtual std::string getBlockId(LocalOrdinal localElmtId) const;

   virtual std::size_t numElementBlocks() const
   { return stkMeshDB_->getNumElementBlocks(); }

   virtual void getElementBlockIds(std::vector<std::string> & elementBlockIds) const
   { return stkMeshDB_->getElementBlockNames(elementBlockIds); }

   virtual void getElementBlockTopologies(std::vector<shards::CellTopology> & elementBlockTopologies) const{
     std::vector<std::string> elementBlockIds;
     getElementBlockIds(elementBlockIds);
     elementBlockTopologies.reserve(elementBlockIds.size());
 
     for (unsigned i=0; i<elementBlockIds.size(); ++i) {
       elementBlockTopologies.push_back(*(stkMeshDB_->getCellTopology(elementBlockIds[i])));
     }
   }

   virtual const std::vector<LocalOrdinal> & getElementBlock(const std::string & blockId) const
   { return *(elementBlocks_.find(blockId)->second); }

   virtual const std::vector<LocalOrdinal> & getNeighborElementBlock(const std::string & blockId) const
   { return *(neighborElementBlocks_.find(blockId)->second); }

   virtual void getDofCoords(const std::string & blockId,
                             const panzer::Intrepid2FieldPattern & coordProvider,
                             std::vector<std::size_t> & localCellIds,
                             Kokkos::DynRankView<double,PHX::Device> & points) const;

    Teuchos::RCP<const STK_Interface> getSTKInterface() const
    { return stkMeshDB_; }

    std::size_t getOwnedElementCount() const
    { return ownedElementCount_; }

    void associateElementsInSideset(const std::string sideset_id);

    std::vector<std::string> checkAssociateElementsInSidesets(const Teuchos::Comm<int>& comm) const;

    virtual const std::vector<LocalOrdinal>& getAssociatedNeighbors(const LocalOrdinal& el) const;

    virtual bool hasAssociatedNeighbors() const;

  static void cacheConnectivity()
  { cache_connectivity_ = true; }

  static void clearCachedConnectivityData()
  {
    PANZER_FUNC_TIME_MONITOR("panzer::ConnectivityManager::clearCachedConnectivityData()");
    cached_conn_managers_.clear();
  }

  static void clearCachedConnectivityData(const Teuchos::RCP<const STK_Interface>& mesh);

  static int getCachedReuseCount()
  { return cached_reuse_count_; }
 
protected:
   void applyPeriodicBCs( const panzer::FieldPattern & fp, GlobalOrdinal nodeOffset, GlobalOrdinal edgeOffset,
                                                           GlobalOrdinal faceOffset, GlobalOrdinal cellOffset);
   void applyInterfaceConditions();
 
   void buildLocalElementMapping();
   void clearLocalElementMapping();
   void buildOffsetsAndIdCounts(const panzer::FieldPattern & fp,
                                LocalOrdinal & nodeIdCnt, LocalOrdinal & edgeIdCnt,
                                LocalOrdinal & faceIdCnt, LocalOrdinal & cellIdCnt,
                                GlobalOrdinal & nodeOffset, GlobalOrdinal & edgeOffset,
                                GlobalOrdinal & faceOffset, GlobalOrdinal & cellOffset) const;

   LocalOrdinal addSubcellConnectivities(stk::mesh::Entity element,unsigned subcellRank,
                                         LocalOrdinal idCnt,GlobalOrdinal offset,const unsigned maxIds=0);
 
   void modifySubcellConnectivities(const panzer::FieldPattern & fp, stk::mesh::Entity element,
                                    unsigned subcellRank,unsigned subcellId,GlobalOrdinal newId,GlobalOrdinal offset);
 
   Teuchos::RCP<const STK_Interface> stkMeshDB_;
 
   Teuchos::RCP<std::vector<stk::mesh::Entity> > elements_;
 
   // element block information
   std::map<std::string,Teuchos::RCP<std::vector<LocalOrdinal> > > elementBlocks_;
   std::map<std::string,Teuchos::RCP<std::vector<LocalOrdinal> > > neighborElementBlocks_;
 
   // Large arrays are held by RCP so cached connectivity can be shared
   // instead of copied. A rebuild must allocate new arrays rather than
   // modify these in place, since they may be shared with the cache.
   Teuchos::RCP<std::vector<LocalOrdinal> > elmtLidToConnPtr_; // element LID to Connectivity map
   Teuchos::RCP<std::vector<LocalOrdinal> > connSizePtr_; // element LID to Connectivity size
   Teuchos::RCP<std::vector<GlobalOrdinal> > connectivityPtr_; // Connectivity
 
   std::size_t ownedElementCount_;
 
   std::vector<std::string> sidesetsToAssociate_;
   std::vector<bool> sidesetYieldedAssociations_;
   Teuchos::RCP<std::vector<std::vector<LocalOrdinal> > > elmtToAssociatedElmtsPtr_;
 
  using CachedEntry = std::pair<Teuchos::RCP<const panzer::FieldPattern>,Teuchos::RCP<panzer_stk::STKConnManager>>;
  struct CacheKeyCompare {
    const panzer::FieldPattern& fp_;
    const STK_Interface* mesh_;
    const std::vector<std::string>& sidesets_;
    CacheKeyCompare(const panzer::FieldPattern& fp,
                    const STK_Interface* mesh,
                    const std::vector<std::string>& sidesets)
      : fp_(fp), mesh_(mesh), sidesets_(sidesets) {}
    bool inline operator()(const CachedEntry& entry_to_compare) const
    {
      const STKConnManager& cm = *entry_to_compare.second;
      return (cm.stkMeshDB_.get() == mesh_) &&
             (cm.sidesetsToAssociate_ == sidesets_) &&
             fp_.equals(*entry_to_compare.first);
    }
  };
 
  static bool cache_connectivity_;
  static std::vector<CachedEntry> cached_conn_managers_;
  static int cached_reuse_count_;
};
 
}
 
#endif