Tpetra_Map_decl.hpp

Go to the documentation of this file.

// @HEADER
// *****************************************************************************
//          Tpetra: Templated Linear Algebra Services Package
//
// Copyright 2008 NTESS and the Tpetra contributors.
// SPDX-License-Identifier: BSD-3-Clause
// *****************************************************************************
// @HEADER
 
#ifndef TPETRA_MAP_DECL_HPP
#define TPETRA_MAP_DECL_HPP
 
 
#include "Tpetra_ConfigDefs.hpp"
#include "Tpetra_Details_iallreduce.hpp"
#include "Tpetra_Map_fwd.hpp"
#include "Tpetra_Directory_fwd.hpp"
#include "Tpetra_TieBreak_fwd.hpp"
#include "Tpetra_Details_LocalMap.hpp"
#include "Tpetra_KokkosCompat_DefaultNode.hpp"
#include "Kokkos_DualView.hpp"
#include "Teuchos_Array.hpp"
#include "Teuchos_Comm.hpp"
#include "Teuchos_Describable.hpp"
 
namespace Tpetra {
 
template <class LocalOrdinal, class GlobalOrdinal, class Node>
class Map : public Teuchos::Describable {
 public:
 
 
  using local_ordinal_type = LocalOrdinal;
 
  using global_ordinal_type = GlobalOrdinal;
 
  using device_type = typename Node::device_type;
 
  using execution_space = typename device_type::execution_space;
 
  using memory_space = typename device_type::memory_space;
 
  using node_type = Node;
 
  using local_map_type =
      ::Tpetra::Details::LocalMap<local_ordinal_type,
                                  global_ordinal_type,
                                  device_type>;
 
 
 
  Map(const global_size_t numGlobalElements,
      const global_ordinal_type indexBase,
      const Teuchos::RCP<const Teuchos::Comm<int>>& comm,
      const LocalGlobal lg = GloballyDistributed);
 
  Map(const global_size_t numGlobalElements,
      const size_t numLocalElements,
      const global_ordinal_type indexBase,
      const Teuchos::RCP<const Teuchos::Comm<int>>& comm);
 
  Map(const global_size_t numGlobalElements,
      const Kokkos::View<const global_ordinal_type*, device_type>& indexList,
      const global_ordinal_type indexBase,
      const Teuchos::RCP<const Teuchos::Comm<int>>& comm,
      const Teuchos::RCP<Teuchos::ParameterList>& params = Teuchos::null);
 
  Map(const global_size_t numGlobalElements,
      const global_ordinal_type indexList[],
      const local_ordinal_type indexListSize,
      const global_ordinal_type indexBase,
      const Teuchos::RCP<const Teuchos::Comm<int>>& comm,
      const Teuchos::RCP<Teuchos::ParameterList>& params = Teuchos::null);
 
  Map(const global_size_t numGlobalElements,
      const Teuchos::ArrayView<const global_ordinal_type>& indexList,
      const global_ordinal_type indexBase,
      const Teuchos::RCP<const Teuchos::Comm<int>>& comm,
      const Teuchos::RCP<Teuchos::ParameterList>& params = Teuchos::null);
 
  Map();
 
  Map(const Map<local_ordinal_type, global_ordinal_type, node_type>&) = default;
 
  Map(Map<local_ordinal_type, global_ordinal_type, node_type>&&) = default;
 
  Map&
  operator=(const Map<local_ordinal_type, global_ordinal_type, node_type>&) = default;
 
  Map&
  operator=(Map<local_ordinal_type, global_ordinal_type, node_type>&&) = default;
 
  virtual ~Map();
 
 
 
  bool isOneToOne() const;
 
  global_size_t getGlobalNumElements() const {
    return numGlobalElements_;
  }
 
  size_t getLocalNumElements() const {
    return numLocalElements_;
  }
 
  global_ordinal_type getIndexBase() const {
    return indexBase_;
  }
 
  local_ordinal_type getMinLocalIndex() const {
    return static_cast<local_ordinal_type>(0);
  }
 
  local_ordinal_type getMaxLocalIndex() const {
    if (this->getLocalNumElements() == 0) {
      return Tpetra::Details::OrdinalTraits<local_ordinal_type>::invalid();
    } else {  // Local indices are always zero-based.
      return static_cast<local_ordinal_type>(this->getLocalNumElements() - 1);
    }
  }
 
  global_ordinal_type getMinGlobalIndex() const {
    return minMyGID_;
  }
 
  global_ordinal_type getMaxGlobalIndex() const {
    return maxMyGID_;
  }
 
  global_ordinal_type getMinAllGlobalIndex() const {
    TEUCHOS_TEST_FOR_EXCEPTION(!haveGlobalConstants(), std::logic_error, "\"Map::getMinAllGlobalIndex\" called, but global constants have not been computed with \"Map::computeGlobalConstants\".");
    return minAllGID_;
  }
 
  global_ordinal_type getMaxAllGlobalIndex() const {
    TEUCHOS_TEST_FOR_EXCEPTION(!haveGlobalConstants(), std::logic_error, "\"Map::getMaxAllGlobalIndex\" called, but global constants have not been computed with \"Map::computeGlobalConstants\".");
    return maxAllGID_;
  }
 
  local_ordinal_type getLocalElement(global_ordinal_type globalIndex) const;
 
  global_ordinal_type getGlobalElement(local_ordinal_type localIndex) const;
 
  bool getGlobalElements(
      const local_ordinal_type localIndices[], size_t numEntries, global_ordinal_type globalIndices[]) const;
 
  local_map_type getLocalMap() const;
 
  LookupStatus
  getRemoteIndexList(const Teuchos::ArrayView<const global_ordinal_type>& GIDList,
                     const Teuchos::ArrayView<int>& nodeIDList,
                     const Teuchos::ArrayView<local_ordinal_type>& LIDList) const;
 
  LookupStatus
  getRemoteIndexList(const Teuchos::ArrayView<const global_ordinal_type>& GIDList,
                     const Teuchos::ArrayView<int>& nodeIDList) const;
 
 private:
  typedef Kokkos::View<const global_ordinal_type*,
                       Kokkos::LayoutLeft,
                       Kokkos::HostSpace>
      global_indices_array_type;
 
  typedef Kokkos::View<const global_ordinal_type*,
                       device_type>
      global_indices_array_device_type;
 
 public:
  global_indices_array_type getMyGlobalIndices() const;
 
  global_indices_array_device_type getMyGlobalIndicesDevice() const;
 
  Teuchos::ArrayView<const global_ordinal_type> getLocalElementList() const;
 
 
 
  bool isNodeLocalElement(local_ordinal_type localIndex) const;
 
  bool isNodeGlobalElement(global_ordinal_type globalIndex) const;
 
  bool isUniform() const;
 
  bool isContiguous() const;
 
  bool isDistributed() const;
 
  bool isCompatible(const Map<local_ordinal_type, global_ordinal_type, Node>& map) const;
 
  bool isSameAs(const Map<local_ordinal_type, global_ordinal_type, Node>& map) const;
 
  bool locallySameAs(const Map<local_ordinal_type, global_ordinal_type, node_type>& map) const;
 
  bool isLocallyFitted(const Map<local_ordinal_type, global_ordinal_type, Node>& map) const;
 
 
 
  Teuchos::RCP<const Teuchos::Comm<int>> getComm() const;
 
 
 
  std::string description() const;
 
  void
  describe(Teuchos::FancyOStream& out,
           const Teuchos::EVerbosityLevel verbLevel =
               Teuchos::Describable::verbLevel_default) const;
 
 
  Teuchos::RCP<const Map<local_ordinal_type, global_ordinal_type, Node>>
  removeEmptyProcesses() const;
 
  Teuchos::RCP<const Map<local_ordinal_type, global_ordinal_type, Node>>
  replaceCommWithSubset(const Teuchos::RCP<const Teuchos::Comm<int>>& newComm) const;
 
 private:
  std::string
  localDescribeToString(const Teuchos::EVerbosityLevel vl) const;
 
  void setupDirectory() const;
 
  bool checkIsDist() const;
 
  global_size_t
  initialNonuniformDebugCheck(
      const char errorMessagePrefix[],
      const global_size_t numGlobalElements,
      const size_t numLocalElements,
      const global_ordinal_type indexBase,
      const Teuchos::RCP<const Teuchos::Comm<int>>& comm) const;
 
  void
  initWithNonownedHostIndexList(
      const char errorMessagePrefix[],
      const global_size_t numGlobalElements,
      const Kokkos::View<const global_ordinal_type*,
                         Kokkos::LayoutLeft,
                         Kokkos::HostSpace,
                         Kokkos::MemoryUnmanaged>& entryList,
      const global_ordinal_type indexBase,
      const Teuchos::RCP<const Teuchos::Comm<int>>& comm,
      const Teuchos::RCP<Teuchos::ParameterList>& params = Teuchos::null);
 
 public:
  void lazyPushToHost() const;
 
 private:
  Teuchos::RCP<const Teuchos::Comm<int>> comm_;
 
  global_ordinal_type indexBase_;
 
  global_size_t numGlobalElements_;
 
  size_t numLocalElements_;
 
  global_ordinal_type minMyGID_;
 
  global_ordinal_type maxMyGID_;
 
  mutable global_ordinal_type minAllGID_;
 
  mutable global_ordinal_type maxAllGID_;
 
  global_ordinal_type firstContiguousGID_;
 
  global_ordinal_type lastContiguousGID_;
 
  bool uniform_;
 
  bool contiguous_;
 
  mutable bool distributed_;
 
 private:
  mutable bool haveGlobalConstants_ = false;
 
 public:
  bool haveGlobalConstants() const { return haveGlobalConstants_; }
 
  void computeGlobalConstants() const;
 
  mutable Kokkos::View<const global_ordinal_type*,
                       Kokkos::LayoutLeft,
                       device_type>
      lgMap_;
 
#ifndef SWIG
  mutable Kokkos::View<const global_ordinal_type*,
                       Kokkos::LayoutLeft,
                       Kokkos::HostSpace>
      lgMapHost_;
#endif
 
  typedef ::Tpetra::Details::FixedHashTable<global_ordinal_type,
                                            local_ordinal_type, device_type>
      global_to_local_table_type;
 
  global_to_local_table_type glMap_;
 
  typedef ::Tpetra::Details::FixedHashTable<
      global_ordinal_type, local_ordinal_type, Kokkos::HostSpace::device_type>
      global_to_local_table_host_type;
 
  mutable global_to_local_table_host_type glMapHost_;
 
  mutable Teuchos::RCP<
      Directory<
          local_ordinal_type, global_ordinal_type, node_type>>
      directory_;
};  // Map class
 
template <class LocalOrdinal, class GlobalOrdinal>
Teuchos::RCP<const Map<LocalOrdinal, GlobalOrdinal>>
createLocalMap(const size_t numElements,
               const Teuchos::RCP<const Teuchos::Comm<int>>& comm);
 
template <class LocalOrdinal, class GlobalOrdinal, class Node>
Teuchos::RCP<const Map<LocalOrdinal, GlobalOrdinal, Node>>
createLocalMapWithNode(const size_t numElements,
                       const Teuchos::RCP<const Teuchos::Comm<int>>& comm);
 
template <class LocalOrdinal, class GlobalOrdinal>
Teuchos::RCP<const Map<LocalOrdinal, GlobalOrdinal>>
createUniformContigMap(const global_size_t numElements,
                       const Teuchos::RCP<const Teuchos::Comm<int>>& comm);
 
template <class LocalOrdinal, class GlobalOrdinal, class Node>
Teuchos::RCP<const Map<LocalOrdinal, GlobalOrdinal, Node>>
createUniformContigMapWithNode(const global_size_t numElements,
                               const Teuchos::RCP<const Teuchos::Comm<int>>& comm);
 
template <class LocalOrdinal, class GlobalOrdinal>
Teuchos::RCP<const Map<LocalOrdinal, GlobalOrdinal>>
createContigMap(const global_size_t numElements,
                const size_t localNumElements,
                const Teuchos::RCP<const Teuchos::Comm<int>>& comm);
 
template <class LocalOrdinal, class GlobalOrdinal, class Node>
Teuchos::RCP<const Map<LocalOrdinal, GlobalOrdinal, Node>>
createContigMapWithNode(const global_size_t numElements,
                        const size_t localNumElements,
                        const Teuchos::RCP<const Teuchos::Comm<int>>& comm);
 
template <class LocalOrdinal, class GlobalOrdinal>
Teuchos::RCP<const Map<LocalOrdinal, GlobalOrdinal>>
createNonContigMap(const Teuchos::ArrayView<const GlobalOrdinal>& elementList,
                   const Teuchos::RCP<const Teuchos::Comm<int>>& comm);
 
template <class LocalOrdinal, class GlobalOrdinal, class Node>
Teuchos::RCP<const Map<LocalOrdinal, GlobalOrdinal, Node>>
createNonContigMapWithNode(const Teuchos::ArrayView<const GlobalOrdinal>& elementList,
                           const Teuchos::RCP<const Teuchos::Comm<int>>& comm);
 
template <class LocalOrdinal, class GlobalOrdinal, class Node>
Teuchos::RCP<const Map<LocalOrdinal, GlobalOrdinal, Node>>
createOneToOne(const Teuchos::RCP<const Map<LocalOrdinal, GlobalOrdinal, Node>>& M);
 
template <class LocalOrdinal, class GlobalOrdinal, class Node>
Teuchos::RCP<const Map<LocalOrdinal, GlobalOrdinal, Node>>
createOneToOne(const Teuchos::RCP<const Map<LocalOrdinal, GlobalOrdinal, Node>>& M,
               const ::Tpetra::Details::TieBreak<LocalOrdinal, GlobalOrdinal>& tie_break);
 
 
template <class LO, class GO, class NT>
Teuchos::RCP<const Tpetra::Map<LO, GO, NT>>
createOneToOneAndMakeOverlappingMapFitted(Teuchos::RCP<const Tpetra::Map<LO, GO, NT>>& M);
 
}  // namespace Tpetra
 
#include "Tpetra_Directory_decl.hpp"
 
template <class LocalOrdinal, class GlobalOrdinal, class Node>
bool operator==(const Tpetra::Map<LocalOrdinal, GlobalOrdinal, Node>& map1,
                const Tpetra::Map<LocalOrdinal, GlobalOrdinal, Node>& map2) { return map1.isSameAs(map2); }
 
template <class LocalOrdinal, class GlobalOrdinal, class Node>
bool operator!=(const Tpetra::Map<LocalOrdinal, GlobalOrdinal, Node>& map1,
                const Tpetra::Map<LocalOrdinal, GlobalOrdinal, Node>& map2) { return !map1.isSameAs(map2); }
 
#endif  // TPETRA_MAP_DECL_HPP