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