Tpetra parallel linear algebra  Version of the Day
Tpetra_Directory_decl.hpp
1 // @HEADER
2 // ***********************************************************************
3 //
4 // Tpetra: Templated Linear Algebra Services Package
5 // Copyright (2008) Sandia Corporation
6 //
7 // Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
8 // the U.S. Government retains certain rights in this software.
9 //
10 // Redistribution and use in source and binary forms, with or without
11 // modification, are permitted provided that the following conditions are
12 // met:
13 //
14 // 1. Redistributions of source code must retain the above copyright
15 // notice, this list of conditions and the following disclaimer.
16 //
17 // 2. Redistributions in binary form must reproduce the above copyright
18 // notice, this list of conditions and the following disclaimer in the
19 // documentation and/or other materials provided with the distribution.
20 //
21 // 3. Neither the name of the Corporation nor the names of the
22 // contributors may be used to endorse or promote products derived from
23 // this software without specific prior written permission.
24 //
25 // THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
26 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
27 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
28 // PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
29 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
30 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
31 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
32 // PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
33 // LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
34 // NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
35 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
36 //
37 // Questions? Contact Michael A. Heroux (maherou@sandia.gov)
38 //
39 // ************************************************************************
40 // @HEADER
41 
42 #ifndef TPETRA_DIRECTORY_DECL_HPP
43 #define TPETRA_DIRECTORY_DECL_HPP
44 
45 #include <Kokkos_DefaultNode.hpp>
46 #include <Teuchos_Describable.hpp>
47 #include "Tpetra_ConfigDefs.hpp"
48 #include "Tpetra_Map_decl.hpp"
50 #include "Tpetra_TieBreak.hpp"
51 
52 namespace Tpetra {
53 
124  template<class LocalOrdinal = Details::DefaultTypes::local_ordinal_type,
125  class GlobalOrdinal = Details::DefaultTypes::global_ordinal_type,
127  class Directory : public Teuchos::Describable {
128  public:
131 
133 
134 
139  Directory ();
140 
142  ~Directory ();
143 
145  void initialize (const map_type& map);
146 
148  void
149  initialize (const map_type& map,
151 
153  bool initialized () const;
154 
173  template <class Node2>
174  RCP<Directory<LocalOrdinal,GlobalOrdinal,Node2> >
176  {
177  typedef LocalOrdinal LO;
178  typedef GlobalOrdinal GO;
179 
180  RCP<Directory<LO, GO, Node2> > dir (new Directory<LO, GO, Node2> ());
181  if (clone_map.isDistributed ()) {
182  if (clone_map.isUniform ()) {
184  const impl_type* theImpl = dynamic_cast<const impl_type*> (impl_);
185  TEUCHOS_TEST_FOR_EXCEPTION(
186  theImpl == NULL, std::logic_error, "Tpetra::Directory::clone: "
187  "The input Map claims to be distributed, contiguous, and uniform, "
188  "but its Directory's implementation type does not match that assumption. "
189  "Please report this bug to the Tpetra developers.");
190  dir->impl_ = theImpl->template clone<Node2> (clone_map);
191  }
192  else if (clone_map.isContiguous ()) {
194  const impl_type* theImpl = dynamic_cast<const impl_type*> (impl_);
195  TEUCHOS_TEST_FOR_EXCEPTION(
196  theImpl == NULL, std::logic_error, "Tpetra::Directory::clone: "
197  "The input Map claims to be distributed and contiguous, but its "
198  "Directory's implementation type does not match that assumption. "
199  "Please report this bug to the Tpetra developers.");
200  dir->impl_ = theImpl->template clone<Node2> (clone_map);
201  }
202  else { // not contiguous
204  const impl_type* theImpl = dynamic_cast<const impl_type*> (impl_);
205  TEUCHOS_TEST_FOR_EXCEPTION(
206  theImpl == NULL, std::logic_error, "Tpetra::Directory::clone: "
207  "The input Map claims to be noncontiguous, but its "
208  "Directory's implementation type does not match that assumption. "
209  "Please report this bug to the Tpetra developers.");
210  dir->impl_ = theImpl->template clone<Node2> (clone_map);
211  }
212  }
213  else { // locally replicated (not distributed)
215  const impl_type* theImpl = dynamic_cast<const impl_type*> (impl_);
216  TEUCHOS_TEST_FOR_EXCEPTION(
217  theImpl == NULL, std::logic_error, "Tpetra::Directory::clone: "
218  "The input Map claims to be locally replicated, but its "
219  "Directory's implementation type does not match that assumption. "
220  "Please report this bug to the Tpetra developers.");
221  dir->impl_ = theImpl->template clone<Node2> (clone_map);
222  }
223  return dir;
224  }
225 
227 
229 
231  std::string description () const;
232 
234 
236 
263  getDirectoryEntries (const map_type& map,
264  const Teuchos::ArrayView<const GlobalOrdinal>& globalIDs,
265  const Teuchos::ArrayView<int>& nodeIDs) const;
266 
303  getDirectoryEntries (const map_type& map,
304  const Teuchos::ArrayView<const GlobalOrdinal>& globalIDs,
305  const Teuchos::ArrayView<int>& nodeIDs,
306  const Teuchos::ArrayView<LocalOrdinal>& localIDs) const;
307 
314  bool isOneToOne (const map_type& map) const;
315 
317  private:
325 
330  const base_type* impl_;
331 
334 
335  template <class LO, class GO, class N> friend class Directory;
336 
339  operator= (const Directory<LocalOrdinal, GlobalOrdinal, Node>& source);
340  }; // class Directory
341 } // namespace Tpetra
342 
343 #endif // TPETRA_DIRECTORY_DECL_HPP
344 
Interface for breaking ties in ownership.
Namespace Tpetra contains the class and methods constituting the Tpetra library.
Implementation of Directory for a locally replicated Map.
Interface for breaking ties in ownership.
bool isContiguous() const
True if this Map is distributed contiguously, else false.
KokkosClassic::DefaultNode::DefaultNodeType node_type
Default value of Node template parameter.
Map< LocalOrdinal, GlobalOrdinal, Node > map_type
Type of the Map specialization to give to the constructor.
LookupStatus
Return status of Map remote index lookup (getRemoteIndexList()).
bool isUniform() const
Whether the range of global indices is uniform.
Implementation of Directory for a distributed noncontiguous Map.
bool isDistributed() const
Whether this Map is globally distributed or locally replicated.
Implementation of Directory for a distributed contiguous Map.
int local_ordinal_type
Default value of LocalOrdinal template parameter.
Declarations for the Tpetra::Map class and related nonmember constructors.
bool isOneToOne(const map_type &map) const
Whether the Directory&#39;s input Map is (globally) one to one.
LookupStatus getDirectoryEntries(const map_type &map, const Teuchos::ArrayView< const GlobalOrdinal > &globalIDs, const Teuchos::ArrayView< int > &nodeIDs) const
Given a global ID list, return the list of their owning process IDs.
Describes a parallel distribution of objects over processes.
Computes the local ID and process ID corresponding to given global IDs.
Implement mapping from global ID to process ID and local ID.
bool initialized() const
Whether the Directory is initialized.
void initialize(const map_type &map)
Initialize the Directory with its Map.
RCP< Directory< LocalOrdinal, GlobalOrdinal, Node2 > > clone(const Map< LocalOrdinal, GlobalOrdinal, Node2 > &clone_map) const
Clone the Directory for a different Node type, using a cloned Map.
Directory()
Default constructor: the only one you should use.
Declaration of implementation details of Tpetra::Directory.
Implementation of Directory for a contiguous, uniformly distributed Map.
std::string description() const
A one-line human-readable description of this object.