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 <Kokkos_DefaultNode.hpp>
#include <Teuchos_Describable.hpp>
 
#include "Xpetra_ConfigDefs.hpp"
#include "Xpetra_Map_decl.hpp"
 
namespace Xpetra {
 
template<class LocalOrdinal,
         class GlobalOrdinal,
         class Node = 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;
 
 
  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_KOKKOS_REFACTOR
    #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
#endif      // HAVE_XPETRA_KOKKOS_REFACTOR
 
 
 
    /* // 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 getNodeNumElements() 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> getNodeElementList() 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