Xpetra_StridedMap_decl.hpp

Go to the documentation of this file.

// @HEADER
// *****************************************************************************
//             Xpetra: A linear algebra interface package
//
// Copyright 2012 NTESS and the Xpetra contributors.
// SPDX-License-Identifier: BSD-3-Clause
// *****************************************************************************
// @HEADER
 
// WARNING: This code is experimental. Backwards compatibility should not be expected.
 
#ifndef XPETRA_STRIDEDMAP_DECL_HPP
#define XPETRA_STRIDEDMAP_DECL_HPP
 
#include <Tpetra_KokkosCompat_DefaultNode.hpp>
#include <Teuchos_Describable.hpp>
 
#include "Xpetra_ConfigDefs.hpp"
#include "Xpetra_Map_decl.hpp"
 
namespace Xpetra {
 
template <class LocalOrdinal,
          class GlobalOrdinal,
          class Node = Tpetra::KokkosClassic::DefaultNode::DefaultNodeType>
class StridedMap : public virtual Map<LocalOrdinal, GlobalOrdinal, Node> {
 public:
  typedef LocalOrdinal local_ordinal_type;
  typedef GlobalOrdinal global_ordinal_type;
  typedef Node node_type;
  typedef typename Map<LocalOrdinal, GlobalOrdinal, Node>::global_indices_array_device_type global_indices_array_device_type;
 
 private:
#undef XPETRA_STRIDEDMAP_SHORT
#include "Xpetra_UseShortNamesOrdinal.hpp"
 
 public:
 
 
  StridedMap(UnderlyingLib xlib,
             global_size_t numGlobalElements,
             GlobalOrdinal indexBase,
             std::vector<size_t>& stridingInfo,
             const Teuchos::RCP<const Teuchos::Comm<int>>& comm,
             LocalOrdinal stridedBlockId = -1,  // FIXME (mfh 03 Sep 2014) This breaks for unsigned LocalOrdinal
             GlobalOrdinal offset        = 0,
             LocalGlobal lg              = GloballyDistributed);
 
 
  StridedMap(UnderlyingLib xlib,
             global_size_t numGlobalElements,
             size_t numLocalElements,
             GlobalOrdinal indexBase,
             std::vector<size_t>& stridingInfo,
             const Teuchos::RCP<const Teuchos::Comm<int>>& comm,
             LocalOrdinal stridedBlockId = -1,
             GlobalOrdinal offset        = 0);
 
  StridedMap(UnderlyingLib xlib,
             global_size_t numGlobalElements,
             const Teuchos::ArrayView<const GlobalOrdinal>& elementList,
             GlobalOrdinal indexBase,
             std::vector<size_t>& stridingInfo,
             const Teuchos::RCP<const Teuchos::Comm<int>>& comm,
             LocalOrdinal stridedBlockId = -1);
 
  StridedMap(const RCP<const Map>& map,
             std::vector<size_t>& stridingInfo,
             GlobalOrdinal /* indexBase */,
             LocalOrdinal stridedBlockId = -1,
             GlobalOrdinal offset        = 0);
 
  virtual ~StridedMap();
 
 
 
 
  std::vector<size_t> getStridingData() const;
 
  void setStridingData(std::vector<size_t> stridingInfo);
 
  size_t getFixedBlockSize() const;
 
  LocalOrdinal getStridedBlockId() const;
 
  bool isStrided() const;
 
  bool isBlocked() const;
 
  GlobalOrdinal getOffset() const;
 
  void setOffset(GlobalOrdinal offset);
 
  // returns number of strided block id which gid belongs to.
  size_t GID2StridingBlockId(GlobalOrdinal gid) const;
 
 
 
  RCP<const Xpetra::Map<LocalOrdinal, GlobalOrdinal, Node>> getMap() const;
 
  using local_map_type = typename Xpetra::Map<LocalOrdinal, GlobalOrdinal, Node>::local_map_type;
 
  local_map_type getLocalMap() const {
    return map_->getLocalMap();
  }
 
 
  /* // function currently not needed but maybe useful
  std::vector<GlobalOrdinal> NodeId2GlobalDofIds(GlobalOrdinal nodeId) const {
    TEUCHOS_TEST_FOR_EXCEPTION(stridingInfo_.size() == 0, Exceptions::RuntimeError, "StridedMap::NodeId2GlobalDofIds:
  stridingInfo not valid: stridingInfo.size() = 0?"); std::vector<GlobalOrdinal> dofs; if(stridedBlockId_ > -1) {
        TEUCHOS_TEST_FOR_EXCEPTION(stridingInfo_[stridedBlockId_] == 0, Exceptions::RuntimeError,
  "StridedMap::NodeId2GlobalDofIds: stridingInfo not valid: stridingInfo[stridedBlockId] = 0?");
 
        // determine nStridedOffset
        size_t nStridedOffset = 0;
        for(int j=0; j<stridedBlockId_; j++) {
          nStridedOffset += stridingInfo_[j];
        }
 
        for(size_t i = 0; i<stridingInfo_[stridedBlockId_]; i++) {
          GlobalOrdinal gid =
              nodeId * Teuchos::as<GlobalOrdinal>(getFixedBlockSize()) +
              offset_ +
              Teuchos::as<GlobalOrdinal>(nStridedOffset) +
              Teuchos::as<GlobalOrdinal>(i);
          dofs.push_back(gid);
        }
    } else {
      for(size_t i = 0; i<getFixedBlockSize(); i++) {
        GlobalOrdinal gid =
            nodeId * Teuchos::as<GlobalOrdinal>(getFixedBlockSize()) +
            offset_ +
            Teuchos::as<GlobalOrdinal>(i);
        dofs.push_back(gid);
      }
    }
    return dofs;
  }*/
 
 private:
  virtual bool CheckConsistency();
 
 private:
  RCP<const Xpetra::Map<LocalOrdinal, GlobalOrdinal, Node>> map_;
 
  std::vector<size_t> stridingInfo_;
 
  LocalOrdinal stridedBlockId_;
 
  GlobalOrdinal offset_;
 
  GlobalOrdinal indexBase_;
 
 public:
 
 
  global_size_t getGlobalNumElements() const;
 
  size_t getLocalNumElements() const;
 
  GlobalOrdinal getIndexBase() const;
 
  LocalOrdinal getMinLocalIndex() const;
 
  LocalOrdinal getMaxLocalIndex() const;
 
  GlobalOrdinal getMinGlobalIndex() const;
 
  GlobalOrdinal getMaxGlobalIndex() const;
 
  GlobalOrdinal getMinAllGlobalIndex() const;
 
  GlobalOrdinal getMaxAllGlobalIndex() const;
 
  LocalOrdinal getLocalElement(GlobalOrdinal globalIndex) const;
 
  GlobalOrdinal getGlobalElement(LocalOrdinal localIndex) const;
 
  LookupStatus getRemoteIndexList(const Teuchos::ArrayView<const GlobalOrdinal>& GIDList,
                                  const Teuchos::ArrayView<int>& nodeIDList,
                                  const Teuchos::ArrayView<LocalOrdinal>& LIDList) const;
 
  LookupStatus getRemoteIndexList(const Teuchos::ArrayView<const GlobalOrdinal>& GIDList,
                                  const Teuchos::ArrayView<int>& nodeIDList) const;
 
  Teuchos::ArrayView<const GlobalOrdinal> getLocalElementList() const;
 
  global_indices_array_device_type getMyGlobalIndicesDevice() const;
 
  bool isNodeLocalElement(LocalOrdinal localIndex) const;
 
  bool isNodeGlobalElement(GlobalOrdinal globalIndex) const;
 
  bool isContiguous() const;
 
  bool isDistributed() const;
 
 
  bool isCompatible(const Map& map) const;
 
  bool isSameAs(const Map& map) const;
 
  Teuchos::RCP<const Teuchos::Comm<int>> getComm() const;
 
  RCP<const Map> removeEmptyProcesses() const;
 
  RCP<const Map> replaceCommWithSubset(const Teuchos::RCP<const Teuchos::Comm<int>>& newComm) const;
 
  std::string description() const;
 
  void describe(Teuchos::FancyOStream& out,
                const Teuchos::EVerbosityLevel verbLevel = Teuchos::Describable::verbLevel_default) const;
 
  UnderlyingLib lib() const;
 
};  // StridedMap class
 
}  // namespace Xpetra
 
#define XPETRA_STRIDEDMAP_SHORT
#endif  // XPETRA_STRIDEDMAP_DECL_HPP