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_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);

  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);

  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);

  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 {
    return minAllGID_;
  }

  global_ordinal_type getMaxAllGlobalIndex() const {
    return maxAllGID_;
  }

  local_ordinal_type getLocalElement(global_ordinal_type globalIndex) const;

  global_ordinal_type getGlobalElement(local_ordinal_type localIndex) 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);

 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_;

  global_ordinal_type minAllGID_;

  global_ordinal_type maxAllGID_;

  global_ordinal_type firstContiguousGID_;

  global_ordinal_type lastContiguousGID_;

  bool uniform_;

  bool contiguous_;

  bool distributed_;

  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);

}  // 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