Tpetra_Map_decl.hpp

Go to the documentation of this file.

// @HEADER
// ***********************************************************************
// 
//          Tpetra: Templated Linear Algebra Services Package
//                 Copyright (2008) Sandia Corporation
// 
// Under terms of Contract DE-AC04-94AL85000, there is a non-exclusive
// license for use of this work by or on behalf of the U.S. Government.
// 
// This library is free software; you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as
// published by the Free Software Foundation; either version 2.1 of the
// License, or (at your option) any later version.
//  
// This library is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// Lesser General Public License for more details.
//  
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
// USA
// Questions? Contact Michael A. Heroux (maherou@sandia.gov) 
// 
// ***********************************************************************
// @HEADER

#ifndef TPETRA_MAP_DECL_HPP
#define TPETRA_MAP_DECL_HPP

#include <Kokkos_DefaultNode.hpp>
#include <Teuchos_Describable.hpp>

// enums and defines
#include "Tpetra_ConfigDefs.hpp"

namespace Tpetra {

#ifndef DOXYGEN_SHOULD_SKIP_THIS
  // forward dec
  template <class LO, class GO, class N> class Directory;
#endif

  template <class LocalOrdinal, class GlobalOrdinal = LocalOrdinal, class Node = Kokkos::DefaultNode::DefaultNodeType>
  class Map : public Teuchos::Describable {

  public:



    Map(global_size_t numGlobalElements, GlobalOrdinal indexBase, const Teuchos::RCP<const Teuchos::Comm<int> > &comm, 
        LocalGlobal lg=GloballyDistributed, const Teuchos::RCP<Node> &node = Kokkos::DefaultNode::getDefaultNode());

    Map(global_size_t numGlobalElements, size_t numLocalElements, GlobalOrdinal indexBase, 
        const Teuchos::RCP<const Teuchos::Comm<int> > &comm, const Teuchos::RCP<Node> &node = Kokkos::DefaultNode::getDefaultNode());
        

    Map(global_size_t numGlobalElements, const Teuchos::ArrayView<const GlobalOrdinal> &elementList, GlobalOrdinal indexBase, 
        const Teuchos::RCP<const Teuchos::Comm<int> > &comm, const Teuchos::RCP<Node> &node = Kokkos::DefaultNode::getDefaultNode());

    ~Map();





    inline global_size_t getGlobalNumElements() const { return numGlobalElements_; }

    inline size_t getNodeNumElements() const { return numLocalElements_; }

    inline GlobalOrdinal getIndexBase() const { return indexBase_; }

    inline LocalOrdinal getMinLocalIndex() const { return Teuchos::OrdinalTraits<LocalOrdinal>::zero(); }

    inline LocalOrdinal getMaxLocalIndex() const { return Teuchos::as<LocalOrdinal>(numLocalElements_-1); }

    inline GlobalOrdinal getMinGlobalIndex() const { return minMyGID_; }

    inline GlobalOrdinal getMaxGlobalIndex() const { return maxMyGID_; }

    inline GlobalOrdinal getMinAllGlobalIndex() const { return minAllGID_; }

    inline GlobalOrdinal getMaxAllGlobalIndex() const { return maxAllGID_; }


    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<LocalOrdinal,GlobalOrdinal,Node> &map) const;

    bool isSameAs (const Map<LocalOrdinal,GlobalOrdinal,Node> &map) const;



    const Teuchos::RCP<const Teuchos::Comm<int> > & getComm() const;

    const Teuchos::RCP<Node> & getNode() const;



    std::string description() const;

    void describe( Teuchos::FancyOStream &out, const Teuchos::EVerbosityLevel verbLevel = verbLevel_default) const;



  private:

    void setupDirectory();

    bool checkIsDist() const;

    Map(const Map<LocalOrdinal,GlobalOrdinal,Node> & source);

    Map<LocalOrdinal,GlobalOrdinal,Node>& operator=(const Map<LocalOrdinal,GlobalOrdinal,Node> & source);

    // some of the following are globally coherent: that is, they have been guaranteed to 
    // match across all images, and may be assumed to do so
    Teuchos::RCP<const Teuchos::Comm<int> > comm_;

    // Map doesn't need node yet, but it likely will later. In the meantime, passing a Node to Map means that we don't have to 
    // pass a Node to downstream classes such as MultiVector, Vector, CrsGraph and CrsMatrix
    Teuchos::RCP<Node> node_;

    // The based for global IDs in this Map.
    GlobalOrdinal indexBase_;
    global_size_t numGlobalElements_;
    size_t numLocalElements_;
    GlobalOrdinal minMyGID_, maxMyGID_;
    GlobalOrdinal minAllGID_, maxAllGID_;
    bool contiguous_;
    bool distributed_;
    mutable Teuchos::ArrayRCP<GlobalOrdinal> lgMap_;
    std::map<GlobalOrdinal, LocalOrdinal> glMap_;
    Teuchos::RCP< Directory<LocalOrdinal,GlobalOrdinal,Node> > directory_;

  }; // Map class

  template <class LocalOrdinal, class GlobalOrdinal>
  Teuchos::RCP< const Map<LocalOrdinal,GlobalOrdinal,Kokkos::DefaultNode::DefaultNodeType> >
  createLocalMap(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(size_t numElements, const Teuchos::RCP< const Teuchos::Comm< int > > &comm, const Teuchos::RCP< Node > &node);

  template <class LocalOrdinal, class GlobalOrdinal, class Node>
  Teuchos::RCP< const Map<LocalOrdinal,GlobalOrdinal,Node> >
  createUniformContigMapWithNode(global_size_t numElements,
                                 const Teuchos::RCP< const Teuchos::Comm< int > > &comm, const Teuchos::RCP< Node > &node);

  template <class LocalOrdinal, class GlobalOrdinal>
  Teuchos::RCP< const Map<LocalOrdinal,GlobalOrdinal,Kokkos::DefaultNode::DefaultNodeType> >
  createUniformContigMap(global_size_t numElements, const Teuchos::RCP< const Teuchos::Comm< int > > &comm);

  template <class LocalOrdinal, class GlobalOrdinal>
  Teuchos::RCP< const Map<LocalOrdinal,GlobalOrdinal,Kokkos::DefaultNode::DefaultNodeType> >
  createContigMap(global_size_t numElements, 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(global_size_t numElements, size_t localNumElements, 
                          const Teuchos::RCP< const Teuchos::Comm< int > > &comm, const Teuchos::RCP< Node > &node);

  template <class LocalOrdinal, class GlobalOrdinal, class Node>
  Teuchos::RCP< const Map<LocalOrdinal,GlobalOrdinal,Node> >
  createWeightedContigMapWithNode(int thisNodeWeight, global_size_t numElements, 
                                  const Teuchos::RCP< const Teuchos::Comm< int > > &comm, const Teuchos::RCP< Node > &node);

} // Tpetra namespace

template <class LocalOrdinal, class GlobalOrdinal, class Node>
bool operator== (const Tpetra::Map<LocalOrdinal,GlobalOrdinal,Node> &map1, const Tpetra::Map<LocalOrdinal,GlobalOrdinal,Node> &map2);

template <class LocalOrdinal, class GlobalOrdinal, class Node>
bool operator!= (const Tpetra::Map<LocalOrdinal,GlobalOrdinal,Node> &map1, const Tpetra::Map<LocalOrdinal,GlobalOrdinal,Node> &map2);

#endif // TPETRA_MAP_DECL_HPP