Tpetra_Details_LocalMap.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_DETAILS_LOCALMAP_HPP
#define TPETRA_DETAILS_LOCALMAP_HPP
 
 
#include "Tpetra_Details_FixedHashTable.hpp"
// #include "Tpetra_Details_OrdinalTraits.hpp" // comes in above
// #include "Kokkos_Core.hpp" // comes in above
#include "Tpetra_Details_LocalMap_fwd.hpp"
 
namespace Tpetra {
namespace Details {
 
template <class LocalOrdinal, class GlobalOrdinal, class DeviceType>
class LocalMap {
 public:
  using local_ordinal_type = LocalOrdinal;
 
  using global_ordinal_type = GlobalOrdinal;
 
  using device_type = DeviceType;
 
  using execution_space = typename device_type::execution_space;
 
  using memory_space = typename device_type::memory_space;
 
  KOKKOS_DEFAULTED_FUNCTION LocalMap() = default;
 
  LocalMap(const ::Tpetra::Details::FixedHashTable<GlobalOrdinal, LocalOrdinal, device_type>& glMap,
           const ::Kokkos::View<const GlobalOrdinal*, ::Kokkos::LayoutLeft, device_type>& lgMap,
           const GlobalOrdinal indexBase,
           const GlobalOrdinal myMinGid,
           const GlobalOrdinal myMaxGid,
           const GlobalOrdinal firstContiguousGid,
           const GlobalOrdinal lastContiguousGid,
           const LocalOrdinal numLocalElements,
           const bool contiguous)
    : glMap_(glMap)
    , lgMap_(lgMap)
    , indexBase_(indexBase)
    , myMinGid_(myMinGid)
    , myMaxGid_(myMaxGid)
    , firstContiguousGid_(firstContiguousGid)
    , lastContiguousGid_(lastContiguousGid)
    , numLocalElements_(numLocalElements)
    , contiguous_(contiguous) {}
 
  KOKKOS_INLINE_FUNCTION LocalOrdinal getLocalNumElements() const {
    return numLocalElements_;
  }
 
  KOKKOS_INLINE_FUNCTION GlobalOrdinal getIndexBase() const {
    return indexBase_;
  }
 
  KOKKOS_INLINE_FUNCTION bool isContiguous() const {
    return contiguous_;
  }
 
  KOKKOS_INLINE_FUNCTION LocalOrdinal getMinLocalIndex() const {
    return 0;
  }
 
  KOKKOS_INLINE_FUNCTION LocalOrdinal
  getMaxLocalIndex() const {
    if (numLocalElements_ == 0) {
      return ::Tpetra::Details::OrdinalTraits<LocalOrdinal>::invalid();
    } else {  // Local indices are always zero-based.
      return static_cast<LocalOrdinal>(numLocalElements_ - 1);
    }
  }
 
  KOKKOS_INLINE_FUNCTION GlobalOrdinal getMinGlobalIndex() const {
    return myMinGid_;
  }
 
  KOKKOS_INLINE_FUNCTION GlobalOrdinal getMaxGlobalIndex() const {
    return myMaxGid_;
  }
 
  KOKKOS_INLINE_FUNCTION LocalOrdinal
  getLocalElement(const GlobalOrdinal globalIndex) const {
    if (contiguous_) {
      if (globalIndex < myMinGid_ || globalIndex > myMaxGid_) {
        return ::Tpetra::Details::OrdinalTraits<LocalOrdinal>::invalid();
      }
      return static_cast<LocalOrdinal>(globalIndex - myMinGid_);
    } else if (globalIndex >= firstContiguousGid_ &&
               globalIndex <= lastContiguousGid_) {
      return static_cast<LocalOrdinal>(globalIndex - firstContiguousGid_);
    } else {
      // If the given global index is not in the table, this returns
      // the same value as OrdinalTraits<LocalOrdinal>::invalid().
      return glMap_.get(globalIndex);
    }
  }
 
  KOKKOS_INLINE_FUNCTION GlobalOrdinal
  getGlobalElement(const LocalOrdinal localIndex) const {
    if (localIndex < getMinLocalIndex() || localIndex > getMaxLocalIndex()) {
      return ::Tpetra::Details::OrdinalTraits<GlobalOrdinal>::invalid();
    }
    if (isContiguous()) {
      return getMinGlobalIndex() + localIndex;
    } else {
      return lgMap_(localIndex);
    }
  }
 
 private:
  ::Tpetra::Details::FixedHashTable<GlobalOrdinal, LocalOrdinal, device_type> glMap_;
  ::Kokkos::View<const GlobalOrdinal*, ::Kokkos::LayoutLeft, device_type> lgMap_;
 
  GlobalOrdinal indexBase_          = 0;
  GlobalOrdinal myMinGid_           = Tpetra::Details::OrdinalTraits<GlobalOrdinal>::invalid();
  GlobalOrdinal myMaxGid_           = Tpetra::Details::OrdinalTraits<GlobalOrdinal>::invalid();
  GlobalOrdinal firstContiguousGid_ = Tpetra::Details::OrdinalTraits<GlobalOrdinal>::invalid();
  GlobalOrdinal lastContiguousGid_  = Tpetra::Details::OrdinalTraits<GlobalOrdinal>::invalid();
  LocalOrdinal numLocalElements_    = 0;
  bool contiguous_                  = false;
};
 
}  // namespace Details
}  // namespace Tpetra
 
#endif  // TPETRA_DETAILS_LOCALMAP_HPP