Xpetra_StridedMap_decl.hpp

Go to the documentation of this file.

// @HEADER
//
// ***********************************************************************
//
//             Xpetra: A linear algebra interface package
//                  Copyright 2012 Sandia Corporation
//
// Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
// the U.S. Government retains certain rights in this software.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// 1. Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
//
// 3. Neither the name of the Corporation nor the names of the
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
// EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
// PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
// CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
// EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
// PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
// PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
// LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
// NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
// Questions? Contact
//                    Jonathan Hu       (jhu@sandia.gov)
//                    Andrey Prokopenko (aprokop@sandia.gov)
//                    Ray Tuminaro      (rstumin@sandia.gov)
//
// ***********************************************************************
//
// @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;

#ifdef HAVE_XPETRA_TPETRA
  using local_map_type = typename Xpetra::Map<LocalOrdinal, GlobalOrdinal, Node>::local_map_type;

  local_map_type getLocalMap() const {
    return map_->getLocalMap();
  }
#else  // HAVE_XPETRA_TPETRA
#ifdef __GNUC__
#warning \
    "Xpetra Kokkos interface for CrsMatrix is enabled (HAVE_XPETRA_KOKKOS_REFACTOR) but Tpetra is disabled. The Kokkos interface needs Tpetra to be enabled, too."
#endif  // __GNUC__
#endif  // HAVE_XPETRA_TPETRA ELSE


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