Xpetra_MapFactory.hpp
Go to the documentation of this file.
1 // @HEADER
2 //
3 // ***********************************************************************
4 //
5 // Xpetra: A linear algebra interface package
6 // Copyright 2012 Sandia Corporation
7 //
8 // Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
9 // the U.S. Government retains certain rights in this software.
10 //
11 // Redistribution and use in source and binary forms, with or without
12 // modification, are permitted provided that the following conditions are
13 // met:
14 //
15 // 1. Redistributions of source code must retain the above copyright
16 // notice, this list of conditions and the following disclaimer.
17 //
18 // 2. Redistributions in binary form must reproduce the above copyright
19 // notice, this list of conditions and the following disclaimer in the
20 // documentation and/or other materials provided with the distribution.
21 //
22 // 3. Neither the name of the Corporation nor the names of the
23 // contributors may be used to endorse or promote products derived from
24 // this software without specific prior written permission.
25 //
26 // THIS SOFTWARE IS PROVIDED BY SANDIA CORPORATION "AS IS" AND ANY
27 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
28 // IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
29 // PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SANDIA CORPORATION OR THE
30 // CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
31 // EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
32 // PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
33 // PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
34 // LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
35 // NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
36 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
37 //
38 // Questions? Contact
39 // Jonathan Hu (jhu@sandia.gov)
40 // Andrey Prokopenko (aprokop@sandia.gov)
41 // Ray Tuminaro (rstumin@sandia.gov)
42 //
43 // ***********************************************************************
44 //
45 // @HEADER
46 #ifndef XPETRA_MAPFACTORY_HPP
47 #define XPETRA_MAPFACTORY_HPP
48 
49 #include "Xpetra_ConfigDefs.hpp"
50 #include "Xpetra_Map.hpp"
51 
52 #ifdef HAVE_XPETRA_TPETRA
53 # include "Xpetra_TpetraMap.hpp"
54 #endif
55 #ifdef HAVE_XPETRA_EPETRA
56 # include "Xpetra_EpetraMap.hpp"
57 #endif
58 
59 #include "Xpetra_Exceptions.hpp"
60 
61 namespace Xpetra {
67  template <class LocalOrdinal = Map<>::local_ordinal_type,
68  class GlobalOrdinal = typename Map<LocalOrdinal>::global_ordinal_type,
69  class Node = typename Map<LocalOrdinal, GlobalOrdinal>::node_type>
70  class MapFactory {
71 
72  private:
74  MapFactory() {}
75 
76  public:
77  static Teuchos::RCP<Node> defaultArgNode() {
78  // Workaround function for a deferred visual studio bug
79  //
80  // http://connect.microsoft.com/VisualStudio/feedback/details/719847/erroneous-error-c2783-could-not-deduce-template-argument
81  //
82  // Use this function for default arguments rather than calling
83  // what is the return value below. Also helps in reducing
84  // duplication in various constructors.
85  return KokkosClassic::Details::getNode<Node>();
86  }
87 
89  static Teuchos::RCP<Map<LocalOrdinal,GlobalOrdinal, Node> >
90  Build (UnderlyingLib lib,
91  global_size_t numGlobalElements,
92  GlobalOrdinal indexBase,
93  const Teuchos::RCP<const Teuchos::Comm<int> > &comm,
94  LocalGlobal lg = Xpetra::GloballyDistributed,
95  const Teuchos::RCP<Node> &node = defaultArgNode ())
96  {
97  XPETRA_MONITOR("MapFactory::Build");
98 
99 #ifdef HAVE_XPETRA_TPETRA
100  if (lib == UseTpetra)
101  return Teuchos::rcp( new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (numGlobalElements, indexBase, comm, lg, node) );
102 #endif
103 
104  XPETRA_FACTORY_ERROR_IF_EPETRA(lib);
105  XPETRA_FACTORY_END;
106  }
107 
109  static Teuchos::RCP<Map<LocalOrdinal,GlobalOrdinal, Node> >
110  Build (UnderlyingLib lib,
111  global_size_t numGlobalElements,
112  size_t numLocalElements,
113  GlobalOrdinal indexBase,
114  const Teuchos::RCP<const Teuchos::Comm<int> > &comm,
115  const Teuchos::RCP<Node> &node = defaultArgNode ())
116  {
117  XPETRA_MONITOR("MapFactory::Build");
118 
119 #ifdef HAVE_XPETRA_TPETRA
120  if (lib == UseTpetra)
121  return rcp( new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (numGlobalElements, numLocalElements, indexBase, comm, node) );
122 #endif
123 
124  XPETRA_FACTORY_ERROR_IF_EPETRA(lib);
125  XPETRA_FACTORY_END;
126  }
127 
129  static Teuchos::RCP<Map<LocalOrdinal,GlobalOrdinal, Node> >
130  Build (UnderlyingLib lib,
131  global_size_t numGlobalElements,
132  const Teuchos::ArrayView<const GlobalOrdinal> &elementList,
133  GlobalOrdinal indexBase,
134  const Teuchos::RCP<const Teuchos::Comm<int> > &comm,
135  const Teuchos::RCP<Node> &node = defaultArgNode ())
136  {
137  XPETRA_MONITOR("MapFactory::Build");
138 
139 #ifdef HAVE_XPETRA_TPETRA
140  if (lib == UseTpetra)
141  return rcp( new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (numGlobalElements, elementList, indexBase, comm, node) );
142 #endif
143 
144  XPETRA_FACTORY_ERROR_IF_EPETRA(lib);
145  XPETRA_FACTORY_END;
146  }
147 
150  static Teuchos::RCP<Map<LocalOrdinal,GlobalOrdinal, Node> >
151  Build (const Teuchos::RCP<const Map<LocalOrdinal,GlobalOrdinal,Node> >& map,
152  LocalOrdinal numDofPerNode)
153  {
154  XPETRA_MONITOR("MapFactory::Build");
155 
156 #ifdef HAVE_XPETRA_TPETRA
157  LocalOrdinal N = map->getNodeNumElements();
158  Teuchos::ArrayView<const GlobalOrdinal> oldElements = map->getNodeElementList();
159  Teuchos::Array<GlobalOrdinal> newElements(map->getNodeNumElements()*numDofPerNode);
160  for (LocalOrdinal i = 0; i < N; i++)
161  for (LocalOrdinal j = 0; j < numDofPerNode; j++)
162  newElements[i*numDofPerNode + j] = oldElements[i]*numDofPerNode + j;
163  if (map->lib() == UseTpetra)
164  return rcp( new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (map->getGlobalNumElements()*numDofPerNode, newElements, map->getIndexBase(), map->getComm(), map->getNode()) );
165 #endif
166 
167  XPETRA_FACTORY_ERROR_IF_EPETRA(map->lib());
168  XPETRA_FACTORY_END;
169  }
170 
172  static Teuchos::RCP<const Map<LocalOrdinal,GlobalOrdinal, Node> >
173  createLocalMap (UnderlyingLib lib,
174  size_t numElements,
175  const Teuchos::RCP< const Teuchos::Comm< int > > &comm)
176  {
177  XPETRA_MONITOR("MapFactory::Build");
178 
179 #ifdef HAVE_XPETRA_TPETRA
180  if (lib == UseTpetra)
181  return rcp(new Xpetra::TpetraMap<LocalOrdinal,GlobalOrdinal,Node>(Tpetra::createLocalMap<LocalOrdinal,GlobalOrdinal,Node>(numElements, comm)));
182 #endif
183 
184  XPETRA_FACTORY_ERROR_IF_EPETRA(lib);
185  XPETRA_FACTORY_END;
186  }
187 
189  static Teuchos::RCP< const Map<LocalOrdinal,GlobalOrdinal, Node> >
190  createLocalMapWithNode (UnderlyingLib lib,
191  size_t numElements,
192  const Teuchos::RCP< const Teuchos::Comm< int > > &comm,
193  const Teuchos::RCP< Node > &node)
194  {
195  XPETRA_MONITOR("MapFactory::Build");
196 
197 #ifdef HAVE_XPETRA_TPETRA
198  if (lib == UseTpetra)
199  return rcp(new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (Tpetra::createLocalMapWithNode<LocalOrdinal,GlobalOrdinal,Node>(numElements, comm, node)));
200 #endif
201 
202  XPETRA_FACTORY_ERROR_IF_EPETRA(lib);
203  XPETRA_FACTORY_END;
204  }
205 
207  static Teuchos::RCP< const Map<LocalOrdinal,GlobalOrdinal, Node> >
208  createUniformContigMapWithNode (UnderlyingLib lib,
209  global_size_t numElements,
210  const Teuchos::RCP< const Teuchos::Comm< int > > &comm,
211  const Teuchos::RCP< Node > &node)
212  {
213  XPETRA_MONITOR("MapFactory::Build");
214 
215 #ifdef HAVE_XPETRA_TPETRA
216  if (lib == UseTpetra)
217  return rcp(new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (Tpetra::createUniformContigMapWithNode<LocalOrdinal,GlobalOrdinal,Node>(numElements, comm, node)));
218 #endif
219 
220  XPETRA_FACTORY_ERROR_IF_EPETRA(lib);
221  XPETRA_FACTORY_END;
222  }
223 
225  static Teuchos::RCP< const Map<LocalOrdinal,GlobalOrdinal, Node> >
226  createUniformContigMap (UnderlyingLib lib,
227  global_size_t numElements,
228  const Teuchos::RCP< const Teuchos::Comm< int > > &comm)
229  {
230  XPETRA_MONITOR("MapFactory::Build");
231 
232 #ifdef HAVE_XPETRA_TPETRA
233  if (lib == UseTpetra)
234  return rcp(new Xpetra::TpetraMap<LocalOrdinal,GlobalOrdinal,Node>(Tpetra::createUniformContigMapWithNode<LocalOrdinal,GlobalOrdinal,Node>(numElements, comm)));
235 #endif
236 
237  XPETRA_FACTORY_ERROR_IF_EPETRA(lib);
238  XPETRA_FACTORY_END;
239  }
240 
242  static Teuchos::RCP< const Map<LocalOrdinal,GlobalOrdinal, Node> >
243  createContigMap (UnderlyingLib lib,
244  global_size_t numElements,
245  size_t localNumElements,
246  const Teuchos::RCP< const Teuchos::Comm< int > > &comm)
247  {
248  XPETRA_MONITOR("MapFactory::Build");
249 
250 #ifdef HAVE_XPETRA_TPETRA
251  if (lib == UseTpetra)
252  return rcp(new Xpetra::TpetraMap<LocalOrdinal,GlobalOrdinal,Node>(Tpetra::createContigMapWithNode<LocalOrdinal,GlobalOrdinal,Node>(numElements, localNumElements, comm)));
253 #endif
254 
255  XPETRA_FACTORY_ERROR_IF_EPETRA(lib);
256  XPETRA_FACTORY_END;
257  }
258 
260  static Teuchos::RCP< const Map<LocalOrdinal,GlobalOrdinal, Node> >
261  createContigMapWithNode (UnderlyingLib lib,
262  global_size_t numElements,
263  size_t localNumElements,
264  const Teuchos::RCP< const Teuchos::Comm< int > > &comm,
265  const Teuchos::RCP< Node > &node)
266  {
267  XPETRA_MONITOR("MapFactory::Build");
268 
269 #ifdef HAVE_XPETRA_TPETRA
270  if (lib == UseTpetra)
271  return rcp(new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (Tpetra::createContigMapWithNode<LocalOrdinal,GlobalOrdinal,Node>(numElements, localNumElements, comm, node)));
272 #endif
273 
274  XPETRA_FACTORY_ERROR_IF_EPETRA(lib);
275  XPETRA_FACTORY_END;
276  }
277  };
278 
279 // we need the Epetra specialization only if Epetra is enabled
280 #if (defined(HAVE_XPETRA_EPETRA) && !defined(XPETRA_EPETRA_NO_32BIT_GLOBAL_INDICES))
281  template <>
282  class MapFactory<int, int, EpetraNode> {
283 
284  typedef int LocalOrdinal;
285  typedef int GlobalOrdinal;
286  typedef EpetraNode Node;
287 
288  private:
290  MapFactory() {}
291 
292  public:
293 
294  static Teuchos::RCP<Node> defaultArgNode () {
295  // Workaround function for a deferred visual studio bug
296  //
297  // http://connect.microsoft.com/VisualStudio/feedback/details/719847/erroneous-error-c2783-could-not-deduce-template-argument
298  //
299  // Use this function for default arguments rather than calling
300  // what is the return value below. Also helps in reducing
301  // duplication in various constructors.
302  return KokkosClassic::Details::getNode<Node>();
303  }
304 
305  static RCP<Map<LocalOrdinal,GlobalOrdinal, Node> >
306  Build (UnderlyingLib lib,
307  global_size_t numGlobalElements,
308  int indexBase,
309  const Teuchos::RCP<const Teuchos::Comm<int> > &comm,
310  LocalGlobal lg=GloballyDistributed,
311  const Teuchos::RCP<Node>& node = defaultArgNode ()) {
312  XPETRA_MONITOR("MapFactory::Build");
313 
314 #ifdef HAVE_XPETRA_TPETRA
315  if (lib == UseTpetra)
316  return rcp( new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (numGlobalElements, indexBase, comm, lg, node) );
317 #endif
318 
319  if (lib == UseEpetra)
320  return rcp( new EpetraMapT<int, Node>(numGlobalElements, indexBase, comm, lg, node) );
321 
322  XPETRA_FACTORY_END;
323  }
324 
325  static RCP<Map<LocalOrdinal,GlobalOrdinal, Node> >
326  Build (UnderlyingLib lib,
327  global_size_t numGlobalElements,
328  size_t numLocalElements,
329  int indexBase,
330  const Teuchos::RCP<const Teuchos::Comm<int> > &comm,
331  const Teuchos::RCP<Node>& node = defaultArgNode())
332  {
333  XPETRA_MONITOR("MapFactory::Build");
334 #ifdef HAVE_XPETRA_TPETRA
335  if (lib == UseTpetra)
336  return rcp( new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (numGlobalElements, numLocalElements, indexBase, comm, node) );
337 #endif
338 
339  if (lib == UseEpetra)
340  return rcp( new EpetraMapT<int, Node>(numGlobalElements, numLocalElements, indexBase, comm, node) );
341 
342  XPETRA_FACTORY_END;
343  }
344 
345  static RCP<Map<LocalOrdinal,GlobalOrdinal, Node> > Build(UnderlyingLib lib, global_size_t numGlobalElements, const Teuchos::ArrayView<const GlobalOrdinal> &elementList, int indexBase, const Teuchos::RCP<const Teuchos::Comm<int> > &comm, const Teuchos::RCP<Node>& node = defaultArgNode ()) {
346  XPETRA_MONITOR("MapFactory::Build");
347 #ifdef HAVE_XPETRA_TPETRA
348  if (lib == UseTpetra)
349  return rcp( new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (numGlobalElements, elementList, indexBase, comm, node) );
350 #endif
351 
352  if (lib == UseEpetra)
353  return rcp( new EpetraMapT<int, Node>(numGlobalElements, elementList, indexBase, comm, node) );
354 
355  XPETRA_FACTORY_END;
356  }
357 
360  static Teuchos::RCP<Map<LocalOrdinal,GlobalOrdinal, Node> > Build(const Teuchos::RCP<const Map<LocalOrdinal,GlobalOrdinal,Node> >& map, LocalOrdinal numDofPerNode) {
361  XPETRA_MONITOR("MapFactory::Build");
362 
363  LocalOrdinal N = map->getNodeNumElements();
364  Teuchos::ArrayView<const GlobalOrdinal> oldElements = map->getNodeElementList();
365  Teuchos::Array<GlobalOrdinal> newElements(map->getNodeNumElements()*numDofPerNode);
366  for (LocalOrdinal i = 0; i < N; i++)
367  for (LocalOrdinal j = 0; j < numDofPerNode; j++)
368  newElements[i*numDofPerNode + j] = oldElements[i]*numDofPerNode + j;
369 
370 #ifdef HAVE_XPETRA_TPETRA
371  if (map->lib() == UseTpetra)
372  return rcp( new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (map->getGlobalNumElements()*numDofPerNode, newElements, map->getIndexBase(), map->getComm(), map->getNode()) );
373 #endif
374 
375  if (map->lib() == UseEpetra)
376  return rcp( new EpetraMapT<int, Node>(map->getGlobalNumElements()*numDofPerNode, newElements, map->getIndexBase(), map->getComm(), map->getNode()) );
377 
378  XPETRA_FACTORY_END;
379  }
380 
381  static Teuchos::RCP<const Map<LocalOrdinal,GlobalOrdinal, Node> >
382  createLocalMap(UnderlyingLib lib, size_t numElements, const Teuchos::RCP< const Teuchos::Comm< int > > &comm) {
383  XPETRA_MONITOR("MapFactory::Build");
384 
385 #ifdef HAVE_XPETRA_TPETRA
386  if (lib == UseTpetra)
387 #if ((defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_OPENMP) && defined(HAVE_TPETRA_INST_INT_INT))) || \
388  (!defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_SERIAL) && defined(HAVE_TPETRA_INST_INT_INT))))
389  return rcp( new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (Tpetra::createLocalMapWithNode<LocalOrdinal,GlobalOrdinal, Node>(numElements, comm)));
390 #else
391  TEUCHOS_TEST_FOR_EXCEPTION(true, Xpetra::Exceptions::RuntimeError,
392  "Xpetra::MapFactory::createLocalMap: Cannot create Xpetra::TpetraMap, since Tpetra is not instantiated on EpetraNode (Serial or OpenMP, depending on configuration) and/or GO=int");
393 #endif
394 #endif
395 
396  if (lib == UseEpetra) {
397  Teuchos::RCP< EpetraMapT<int, Node> > map;
398  map = Teuchos::rcp( new EpetraMapT<int, Node>((Xpetra::global_size_t)numElements, // num elements, global and local
399  0, // index base is zero
400  comm, LocallyReplicated));
401  return map.getConst();
402  }
403 
404  XPETRA_FACTORY_END;
405  }
406 
407  // TODO remove this
408  static Teuchos::RCP< const Map<LocalOrdinal,GlobalOrdinal, Node> >
409  createLocalMapWithNode(UnderlyingLib lib, size_t numElements, const Teuchos::RCP< const Teuchos::Comm< int > > &comm, const Teuchos::RCP<Node> &node) {
410  XPETRA_MONITOR("MapFactory::Build");
411 
412 #ifdef HAVE_XPETRA_TPETRA
413  if (lib == UseTpetra)
414 #if ((defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_OPENMP) && defined(HAVE_TPETRA_INST_INT_INT))) || \
415  (!defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_SERIAL) && defined(HAVE_TPETRA_INST_INT_INT))))
416  return rcp (new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (Tpetra::createLocalMapWithNode<int, GlobalOrdinal, Node> (numElements, comm, node)));
417 #else
418  TEUCHOS_TEST_FOR_EXCEPTION(true, Xpetra::Exceptions::RuntimeError,
419  "Xpetra::MapFactory::createLocalMapWithNode: Cannot create Xpetra::TpetraMap, since Tpetra is not instantiated on EpetraNode (Serial or OpenMP, depending on configuration) and/or GO=int");
420 #endif
421 #endif
422 
423  if (lib == UseEpetra) {
424  Teuchos::RCP< EpetraMapT<int, Node> > map;
425  map = Teuchos::rcp( new EpetraMapT<int, Node>((Xpetra::global_size_t)numElements, // num elements, global and local
426  0, // index base is zero
427  comm, LocallyReplicated, node));
428  return map.getConst();
429  }
430 
431  XPETRA_FACTORY_END;
432  }
433 
434  // TODO remove this
435  static Teuchos::RCP< const Map<LocalOrdinal,GlobalOrdinal, Node> >
436  createUniformContigMapWithNode (UnderlyingLib lib, global_size_t numElements,
437  const Teuchos::RCP< const Teuchos::Comm< int > > &comm,
438  const Teuchos::RCP<Node>& node)
439  {
440  XPETRA_MONITOR("MapFactory::Build");
441 
442 #ifdef HAVE_XPETRA_TPETRA
443  if (lib == UseTpetra)
444 #if ((defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_OPENMP) && defined(HAVE_TPETRA_INST_INT_INT))) || \
445  (!defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_SERIAL) && defined(HAVE_TPETRA_INST_INT_INT))))
446  return rcp (new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (Tpetra::createUniformContigMapWithNode<int,GlobalOrdinal,Node> (numElements, comm, node)));
447 #else
448  TEUCHOS_TEST_FOR_EXCEPTION(true, Xpetra::Exceptions::RuntimeError,
449  "Xpetra::MapFactory::createUniformContigMapWithNode: Cannot create Xpetra::TpetraMap, since Tpetra is not instantiated on EpetraNode (Serial or OpenMP, depending on configuration) and/or GO=int");
450 #endif
451 #endif
452 
453  if (lib == UseEpetra) {
454  Teuchos::RCP< EpetraMapT<int,Node> > map;
455  map = Teuchos::rcp( new EpetraMapT<int,Node>(numElements, // num elements, global and local
456  0, //index base is zero
457  comm, GloballyDistributed, node));
458  return map.getConst();
459  }
460 
461  XPETRA_FACTORY_END;
462  }
463 
464  static Teuchos::RCP< const Map<LocalOrdinal,GlobalOrdinal, Node> >
465  createUniformContigMap(UnderlyingLib lib, global_size_t numElements, const Teuchos::RCP< const Teuchos::Comm< int > > &comm) {
466  XPETRA_MONITOR("MapFactory::Build");
467 
468 #ifdef HAVE_XPETRA_TPETRA
469  if (lib == UseTpetra)
470 #if ((defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_OPENMP) && defined(HAVE_TPETRA_INST_INT_INT))) || \
471  (!defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_SERIAL) && defined(HAVE_TPETRA_INST_INT_INT))))
472  return rcp( new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (Tpetra::createUniformContigMapWithNode<LocalOrdinal,GlobalOrdinal, Node>(numElements, comm)));
473 #else
474  TEUCHOS_TEST_FOR_EXCEPTION(true, Xpetra::Exceptions::RuntimeError,
475  "Xpetra::MapFactory::createUniformContigMapWithNode: Cannot create Xpetra::TpetraMap, since Tpetra is not instantiated on EpetraNode (Serial or OpenMP, depending on configuration) and/or GO=int");
476 #endif
477 #endif
478 
479  if (lib == UseEpetra) {
480 
481  Teuchos::RCP< EpetraMapT<int,Node> > map;
482  map = Teuchos::rcp( new EpetraMapT<int,Node>(numElements, // num elements, global and local
483  0, //index base is zero
484  comm, GloballyDistributed));
485  return map.getConst();
486  }
487 
488  XPETRA_FACTORY_END;
489  }
490 
491  static Teuchos::RCP< const Map<LocalOrdinal,GlobalOrdinal, Node> >
492  createContigMap(UnderlyingLib lib, global_size_t numElements, size_t localNumElements, const Teuchos::RCP< const Teuchos::Comm< int > > &comm) {
493  XPETRA_MONITOR("MapFactory::Build");
494 
495 #ifdef HAVE_XPETRA_TPETRA
496  if (lib == UseTpetra)
497 #if ((defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_OPENMP) && defined(HAVE_TPETRA_INST_INT_INT))) || \
498  (!defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_SERIAL) && defined(HAVE_TPETRA_INST_INT_INT))))
499  return rcp( new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (Tpetra::createContigMapWithNode<int,GlobalOrdinal,Node>(numElements, localNumElements, comm)));
500 #else
501  TEUCHOS_TEST_FOR_EXCEPTION(true, Xpetra::Exceptions::RuntimeError,
502  "Xpetra::MapFactory::createContigMap: Cannot create Xpetra::TpetraMap, since Tpetra is not instantiated on EpetraNode (Serial or OpenMP, depending on configuration) and/or GO=int");
503 #endif
504 #endif
505 
506  if (lib == UseEpetra)
507  return MapFactory<int, GlobalOrdinal, Node>::createContigMapWithNode(lib, numElements, localNumElements, comm, defaultArgNode() );
508 
509  XPETRA_FACTORY_END;
510  }
511 
512  static Teuchos::RCP< const Map<LocalOrdinal,GlobalOrdinal, Node> >
513  createContigMapWithNode(UnderlyingLib lib, global_size_t numElements, size_t localNumElements,
514  const Teuchos::RCP< const Teuchos::Comm< int > > &comm, const Teuchos::RCP<Node> &node) {
515  XPETRA_MONITOR("MapFactory::Build");
516 
517 #ifdef HAVE_XPETRA_TPETRA
518  if (lib == UseTpetra)
519 #if ((defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_OPENMP) && defined(HAVE_TPETRA_INST_INT_INT))) || \
520  (!defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_SERIAL) && defined(HAVE_TPETRA_INST_INT_INT))))
521  return rcp( new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (Tpetra::createContigMapWithNode<int,GlobalOrdinal,Node>(numElements, localNumElements, comm, node)));
522 #else
523  TEUCHOS_TEST_FOR_EXCEPTION(true, Xpetra::Exceptions::RuntimeError,
524  "Xpetra::MapFactory::createContigMapWithNode: Cannot create Xpetra::TpetraMap, since Tpetra is not instantiated on EpetraNode (Serial or OpenMP, depending on configuration) and/or GO=int");
525 #endif
526 #endif
527 
528  if (lib == UseEpetra) {
529 
530  Teuchos::RCP< EpetraMapT<int, Node> > map;
531  map = Teuchos::rcp( new EpetraMapT<int, Node>(numElements,localNumElements,
532  0, // index base is zero
533  comm, node) );
534  return map.getConst();
535  }
536 
537  XPETRA_FACTORY_END;
538  }
539 
540  };
541 #endif
542 
543  // we need the Epetra specialization only if Epetra is enabled
544 #if (defined(HAVE_XPETRA_EPETRA) && !defined(XPETRA_EPETRA_NO_64BIT_GLOBAL_INDICES))
545  template <>
546  class MapFactory<int, long long, EpetraNode> {
547 
548  typedef int LocalOrdinal;
549  typedef long long GlobalOrdinal;
550  typedef EpetraNode Node;
551 
552  private:
554  MapFactory() {}
555 
556  public:
557 
558  static Teuchos::RCP<Node> defaultArgNode() {
559  // Workaround function for a deferred visual studio bug
560  //
561  // http://connect.microsoft.com/VisualStudio/feedback/details/719847/erroneous-error-c2783-could-not-deduce-template-argument
562  //
563  // Use this function for default arguments rather than calling
564  // what is the return value below. Also helps in reducing
565  // duplication in various constructors.
566  return KokkosClassic::Details::getNode<Node>();
567  }
568 
569  static RCP<Map<LocalOrdinal,GlobalOrdinal, Node> >
570  Build (UnderlyingLib lib,
571  global_size_t numGlobalElements,
572  int indexBase,
573  const Teuchos::RCP<const Teuchos::Comm<int> > &comm,
574  LocalGlobal lg=GloballyDistributed,
575  const Teuchos::RCP<Node>& node = defaultArgNode ()) {
576  XPETRA_MONITOR("MapFactory::Build");
577 
578 #ifdef HAVE_XPETRA_TPETRA
579  if (lib == UseTpetra)
580  return rcp( new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (numGlobalElements, indexBase, comm, lg, node) );
581 #endif
582 
583  if (lib == UseEpetra)
584  return rcp( new EpetraMapT<long long, Node>(numGlobalElements, indexBase, comm, lg, node) );
585 
586  XPETRA_FACTORY_END;
587  }
588 
589  static RCP<Map<LocalOrdinal,GlobalOrdinal, Node> >
590  Build (UnderlyingLib lib,
591  global_size_t numGlobalElements,
592  size_t numLocalElements,
593  int indexBase,
594  const Teuchos::RCP<const Teuchos::Comm<int> > &comm,
595  const Teuchos::RCP<Node>& node = defaultArgNode())
596  {
597  XPETRA_MONITOR("MapFactory::Build");
598 
599 #ifdef HAVE_XPETRA_TPETRA
600  if (lib == UseTpetra)
601  return rcp( new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (numGlobalElements, numLocalElements, indexBase, comm, node) );
602 #endif
603 
604  if (lib == UseEpetra)
605  return rcp( new EpetraMapT<long long, Node>(numGlobalElements, numLocalElements, indexBase, comm, node) );
606 
607  XPETRA_FACTORY_END;
608  }
609 
610  static RCP<Map<LocalOrdinal,GlobalOrdinal, Node> > Build(UnderlyingLib lib, global_size_t numGlobalElements, const Teuchos::ArrayView<const GlobalOrdinal> &elementList, int indexBase, const Teuchos::RCP<const Teuchos::Comm<int> > &comm, const Teuchos::RCP<Node>& node = defaultArgNode ()) {
611  XPETRA_MONITOR("MapFactory::Build");
612 
613 #ifdef HAVE_XPETRA_TPETRA
614  if (lib == UseTpetra)
615  return rcp( new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (numGlobalElements, elementList, indexBase, comm, node) );
616 #endif
617 
618  if (lib == UseEpetra)
619  return rcp( new EpetraMapT<long long, Node>(numGlobalElements, elementList, indexBase, comm, node) );
620 
621  XPETRA_FACTORY_END;
622  }
623 
626  static Teuchos::RCP<Map<LocalOrdinal,GlobalOrdinal, Node> > Build(const Teuchos::RCP<const Map<LocalOrdinal,GlobalOrdinal,Node> >& map, LocalOrdinal numDofPerNode) {
627  XPETRA_MONITOR("MapFactory::Build");
628 
629  LocalOrdinal N = map->getNodeNumElements();
630  Teuchos::ArrayView<const GlobalOrdinal> oldElements = map->getNodeElementList();
631  Teuchos::Array<GlobalOrdinal> newElements(map->getNodeNumElements()*numDofPerNode);
632  for (LocalOrdinal i = 0; i < N; i++)
633  for (LocalOrdinal j = 0; j < numDofPerNode; j++)
634  newElements[i*numDofPerNode + j] = oldElements[i]*numDofPerNode + j;
635 
636 #ifdef HAVE_XPETRA_TPETRA
637  if (map->lib() == UseTpetra)
638  return rcp( new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (map->getGlobalNumElements()*numDofPerNode, newElements, map->getIndexBase(), map->getComm(), map->getNode()) );
639 #endif
640 
641  if (map->lib() == UseEpetra)
642  return rcp( new EpetraMapT<long long, Node>(map->getGlobalNumElements()*numDofPerNode, newElements, map->getIndexBase(), map->getComm(), map->getNode()) );
643 
644  XPETRA_FACTORY_END;
645  }
646 
647  static Teuchos::RCP<const Map<LocalOrdinal,GlobalOrdinal, Node> >
648  createLocalMap(UnderlyingLib lib, size_t numElements, const Teuchos::RCP< const Teuchos::Comm< int > > &comm) {
649  XPETRA_MONITOR("MapFactory::Build");
650 
651 #ifdef HAVE_XPETRA_TPETRA
652  if (lib == UseTpetra)
653 #if ((defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_OPENMP) && defined(HAVE_TPETRA_INST_INT_LONG_LONG))) || \
654  (!defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_SERIAL) && defined(HAVE_TPETRA_INST_INT_LONG_LONG))))
655  return rcp( new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (Tpetra::createLocalMapWithNode<LocalOrdinal,GlobalOrdinal, Node>(numElements, comm)));
656 #else
657  TEUCHOS_TEST_FOR_EXCEPTION(true, Xpetra::Exceptions::RuntimeError,
658  "Xpetra::MapFactory::createLocalMap: Cannot create Xpetra::TpetraMap, since Tpetra is not instantiated on EpetraNode (Serial or OpenMP, depending on configuration) and/or GO=long long");
659 #endif
660 #endif
661 
662  if (lib == UseEpetra)
663  return MapFactory<int, GlobalOrdinal, Node>::createLocalMapWithNode (lib, numElements, comm,
664  defaultArgNode());
665 
666  XPETRA_FACTORY_END;
667  }
668 
669  static Teuchos::RCP< const Map<LocalOrdinal,GlobalOrdinal, Node> >
670  createLocalMapWithNode(UnderlyingLib lib, size_t numElements, const Teuchos::RCP< const Teuchos::Comm< int > > &comm, const Teuchos::RCP<Node> &node) {
671  XPETRA_MONITOR("MapFactory::Build");
672 
673 #ifdef HAVE_XPETRA_TPETRA
674  if (lib == UseTpetra)
675 #if ((defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_OPENMP) && defined(HAVE_TPETRA_INST_INT_LONG_LONG))) || \
676  (!defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_SERIAL) && defined(HAVE_TPETRA_INST_INT_LONG_LONG))))
677  return rcp (new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (Tpetra::createLocalMapWithNode<int, GlobalOrdinal, Node> (numElements, comm, node)));
678 #else
679  TEUCHOS_TEST_FOR_EXCEPTION(true, Xpetra::Exceptions::RuntimeError,
680  "Xpetra::MapFactory::createLocalMapWithNode: Cannot create Xpetra::TpetraMap, since Tpetra is not instantiated on EpetraNode (Serial or OpenMP, depending on configuration) and/or GO=long long");
681 #endif
682 #endif
683 
684  if (lib == UseEpetra) {
685  Teuchos::RCP< EpetraMapT<long long, Node> > map;
686  map = Teuchos::rcp( new EpetraMapT<long long, Node>((Xpetra::global_size_t)numElements, // num elements, global and local
687  0, // index base is zero
688  comm, LocallyReplicated, node));
689  return map.getConst();
690  }
691 
692  XPETRA_FACTORY_END;
693  }
694 
695  static Teuchos::RCP< const Map<LocalOrdinal,GlobalOrdinal, Node> >
696  createUniformContigMapWithNode (UnderlyingLib lib, global_size_t numElements,
697  const Teuchos::RCP< const Teuchos::Comm< int > > &comm,
698  const Teuchos::RCP<Node>& node)
699  {
700  XPETRA_MONITOR("MapFactory::Build");
701 
702 #ifdef HAVE_XPETRA_TPETRA
703  if (lib == UseTpetra)
704 #if ((defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_OPENMP) && defined(HAVE_TPETRA_INST_INT_LONG_LONG))) || \
705  (!defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_SERIAL) && defined(HAVE_TPETRA_INST_INT_LONG_LONG))))
706  return rcp (new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (Tpetra::createUniformContigMapWithNode<int,GlobalOrdinal,Node> (numElements, comm, node)));
707 #else
708  TEUCHOS_TEST_FOR_EXCEPTION(true, Xpetra::Exceptions::RuntimeError,
709  "Xpetra::MapFactory::createUniformContigMapWithNode: Cannot create Xpetra::TpetraMap, since Tpetra is not instantiated on EpetraNode (Serial or OpenMP, depending on configuration) and/or GO=long long");
710 #endif
711 #endif
712 
713  if (lib == UseEpetra) {
714  Teuchos::RCP< EpetraMapT<long long, Node> > map;
715  map = Teuchos::rcp( new EpetraMapT<long long, Node>(numElements, // num elements, global and local
716  0, //index base is zero
717  comm, GloballyDistributed, node));
718  return map.getConst();
719  }
720 
721  XPETRA_FACTORY_END;
722  }
723 
724  static Teuchos::RCP< const Map<LocalOrdinal,GlobalOrdinal, Node> >
725  createUniformContigMap(UnderlyingLib lib, global_size_t numElements, const Teuchos::RCP< const Teuchos::Comm< int > > &comm) {
726  XPETRA_MONITOR("MapFactory::Build");
727 
728 #ifdef HAVE_XPETRA_TPETRA
729  if (lib == UseTpetra)
730 #if ((defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_OPENMP) && defined(HAVE_TPETRA_INST_INT_LONG_LONG))) || \
731  (!defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_SERIAL) && defined(HAVE_TPETRA_INST_INT_LONG_LONG))))
732  return rcp( new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (Tpetra::createUniformContigMapWithNode<LocalOrdinal,GlobalOrdinal, Node>(numElements, comm)));
733 #else
734  TEUCHOS_TEST_FOR_EXCEPTION(true, Xpetra::Exceptions::RuntimeError,
735  "Xpetra::MapFactory::createUniformContigMap: Cannot create Xpetra::TpetraMap, since Tpetra is not instantiated on EpetraNode (Serial or OpenMP, depending on configuration) and/or GO=long long");
736 #endif
737 #endif
738 
739  if (lib == UseEpetra)
740  return MapFactory<int, GlobalOrdinal, Node>::createUniformContigMapWithNode (lib, numElements, comm,
741  defaultArgNode());
742 
743  XPETRA_FACTORY_END;
744  }
745 
746  static Teuchos::RCP< const Map<LocalOrdinal,GlobalOrdinal, Node> >
747  createContigMap(UnderlyingLib lib, global_size_t numElements, size_t localNumElements, const Teuchos::RCP< const Teuchos::Comm< int > > &comm) {
748  XPETRA_MONITOR("MapFactory::Build");
749 
750 #ifdef HAVE_XPETRA_TPETRA
751  if (lib == UseTpetra)
752 #if ((defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_OPENMP) && defined(HAVE_TPETRA_INST_INT_LONG_LONG))) || \
753  (!defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_SERIAL) && defined(HAVE_TPETRA_INST_INT_LONG_LONG))))
754  return rcp( new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (Tpetra::createContigMapWithNode<int,GlobalOrdinal,Node>(numElements, localNumElements, comm)));
755 #else
756  TEUCHOS_TEST_FOR_EXCEPTION(true, Xpetra::Exceptions::RuntimeError,
757  "Xpetra::MapFactory::createContigMap: Cannot create Xpetra::TpetraMap, since Tpetra is not instantiated on EpetraNode (Serial or OpenMP, depending on configuration) and/or GO=long long");
758 #endif
759 #endif
760 
761  if (lib == UseEpetra)
762  return MapFactory<int, GlobalOrdinal, Node>::createContigMapWithNode(lib, numElements, localNumElements, comm, defaultArgNode() );
763 
764  XPETRA_FACTORY_END;
765  }
766 
767  static Teuchos::RCP< const Map<LocalOrdinal,GlobalOrdinal, Node> >
768  createContigMapWithNode(UnderlyingLib lib, global_size_t numElements, size_t localNumElements,
769  const Teuchos::RCP< const Teuchos::Comm< int > > &comm, const Teuchos::RCP<Node> &node) {
770  XPETRA_MONITOR("MapFactory::Build");
771 
772 #ifdef HAVE_XPETRA_TPETRA
773  if (lib == UseTpetra)
774 #if ((defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_OPENMP) && defined(HAVE_TPETRA_INST_INT_LONG_LONG))) || \
775  (!defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_SERIAL) && defined(HAVE_TPETRA_INST_INT_LONG_LONG))))
776  return rcp( new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (Tpetra::createContigMapWithNode<int,GlobalOrdinal,Node>(numElements, localNumElements, comm, node)));
777 #else
778  TEUCHOS_TEST_FOR_EXCEPTION(true, Xpetra::Exceptions::RuntimeError,
779  "Xpetra::MapFactory::createContigMapWithNode: Cannot create Xpetra::TpetraMap, since Tpetra is not instantiated on EpetraNode (Serial or OpenMP, depending on configuration) and/or GO=long long");
780 #endif
781 #endif
782 
783  if (lib == UseEpetra) {
784  Teuchos::RCP< EpetraMapT<long long, Node> > map;
785  map = Teuchos::rcp( new EpetraMapT<long long, Node>(numElements,localNumElements,
786  0, // index base is zero
787  comm, node) );
788  return map.getConst();
789  }
790 
791  XPETRA_FACTORY_END;
792  }
793 
794  };
795 #endif
796 
797 }
798 
799 #define XPETRA_MAPFACTORY_SHORT
800 #endif
801 //TODO: removed unused methods
Xpetra::MapFactory< int, long long, EpetraNode >::Build
static RCP< Map< LocalOrdinal, GlobalOrdinal, Node > > Build(UnderlyingLib lib, global_size_t numGlobalElements, size_t numLocalElements, int indexBase, const Teuchos::RCP< const Teuchos::Comm< int > > &comm, const Teuchos::RCP< Node > &node=defaultArgNode())
Definition: Xpetra_MapFactory.hpp:590
Xpetra::MapFactory< int, int, EpetraNode >::Build
static Teuchos::RCP< Map< LocalOrdinal, GlobalOrdinal, Node > > Build(const Teuchos::RCP< const Map< LocalOrdinal, GlobalOrdinal, Node > > &map, LocalOrdinal numDofPerNode)
Definition: Xpetra_MapFactory.hpp:360
Xpetra::MapFactory::createContigMapWithNode
static Teuchos::RCP< const Map< LocalOrdinal, GlobalOrdinal, Node > > createContigMapWithNode(UnderlyingLib lib, global_size_t numElements, size_t localNumElements, const Teuchos::RCP< const Teuchos::Comm< int > > &comm, const Teuchos::RCP< Node > &node)
Create a (potentially) non-uniform, contiguous Map with a user-specified node.
Definition: Xpetra_MapFactory.hpp:261
Xpetra::MapFactory::Build
static Teuchos::RCP< Map< LocalOrdinal, GlobalOrdinal, Node > > Build(UnderlyingLib lib, global_size_t numGlobalElements, GlobalOrdinal indexBase, const Teuchos::RCP< const Teuchos::Comm< int > > &comm, LocalGlobal lg=Xpetra::GloballyDistributed, const Teuchos::RCP< Node > &node=defaultArgNode())
Map constructor with Xpetra-defined contiguous uniform distribution.
Definition: Xpetra_MapFactory.hpp:90
Xpetra::MapFactory< int, int, EpetraNode >::Build
static RCP< Map< LocalOrdinal, GlobalOrdinal, Node > > Build(UnderlyingLib lib, global_size_t numGlobalElements, int indexBase, const Teuchos::RCP< const Teuchos::Comm< int > > &comm, LocalGlobal lg=GloballyDistributed, const Teuchos::RCP< Node > &node=defaultArgNode())
Definition: Xpetra_MapFactory.hpp:306
Xpetra::MapFactory::createUniformContigMap
static Teuchos::RCP< const Map< LocalOrdinal, GlobalOrdinal, Node > > createUniformContigMap(UnderlyingLib lib, global_size_t numElements, const Teuchos::RCP< const Teuchos::Comm< int > > &comm)
Create a uniform, contiguous Map with the default node.
Definition: Xpetra_MapFactory.hpp:226
Xpetra::Map::global_ordinal_type
GlobalOrdinal global_ordinal_type
Definition: Xpetra_Map.hpp:86
Xpetra_TpetraMap.hpp
Xpetra::MapFactory::createUniformContigMapWithNode
static Teuchos::RCP< const Map< LocalOrdinal, GlobalOrdinal, Node > > createUniformContigMapWithNode(UnderlyingLib lib, global_size_t numElements, const Teuchos::RCP< const Teuchos::Comm< int > > &comm, const Teuchos::RCP< Node > &node)
Create a uniform, contiguous Map with a user-specified node.
Definition: Xpetra_MapFactory.hpp:208
Xpetra::MapFactory< int, long long, EpetraNode >::createContigMap
static Teuchos::RCP< const Map< LocalOrdinal, GlobalOrdinal, Node > > createContigMap(UnderlyingLib lib, global_size_t numElements, size_t localNumElements, const Teuchos::RCP< const Teuchos::Comm< int > > &comm)
Definition: Xpetra_MapFactory.hpp:747
Xpetra::MapFactory< int, long long, EpetraNode >::createUniformContigMapWithNode
static Teuchos::RCP< const Map< LocalOrdinal, GlobalOrdinal, Node > > createUniformContigMapWithNode(UnderlyingLib lib, global_size_t numElements, const Teuchos::RCP< const Teuchos::Comm< int > > &comm, const Teuchos::RCP< Node > &node)
Definition: Xpetra_MapFactory.hpp:696
Xpetra::MapFactory::Build
static Teuchos::RCP< Map< LocalOrdinal, GlobalOrdinal, Node > > Build(const Teuchos::RCP< const Map< LocalOrdinal, GlobalOrdinal, Node > > &map, LocalOrdinal numDofPerNode)
Definition: Xpetra_MapFactory.hpp:151
Xpetra::MapFactory< int, long long, EpetraNode >::createContigMapWithNode
static Teuchos::RCP< const Map< LocalOrdinal, GlobalOrdinal, Node > > createContigMapWithNode(UnderlyingLib lib, global_size_t numElements, size_t localNumElements, const Teuchos::RCP< const Teuchos::Comm< int > > &comm, const Teuchos::RCP< Node > &node)
Definition: Xpetra_MapFactory.hpp:768
Xpetra::MapFactory< int, int, EpetraNode >::createLocalMap
static Teuchos::RCP< const Map< LocalOrdinal, GlobalOrdinal, Node > > createLocalMap(UnderlyingLib lib, size_t numElements, const Teuchos::RCP< const Teuchos::Comm< int > > &comm)
Definition: Xpetra_MapFactory.hpp:382
Xpetra::Map::node_type
Node node_type
Definition: Xpetra_Map.hpp:87
Xpetra::MapFactory< int, long long, EpetraNode >::Build
static Teuchos::RCP< Map< LocalOrdinal, GlobalOrdinal, Node > > Build(const Teuchos::RCP< const Map< LocalOrdinal, GlobalOrdinal, Node > > &map, LocalOrdinal numDofPerNode)
Definition: Xpetra_MapFactory.hpp:626
TEUCHOS_TEST_FOR_EXCEPTION
#define TEUCHOS_TEST_FOR_EXCEPTION(throw_exception_test, Exception, msg)
Xpetra
Xpetra namespace
Definition: Xpetra_CrsGraph.hpp:63
Xpetra::MapFactory< int, long long, EpetraNode >::MapFactory
MapFactory()
Private constructor. This is a static class.
Definition: Xpetra_MapFactory.hpp:554
Xpetra::Exceptions::RuntimeError
Exception throws to report errors in the internal logical of the program.
Definition: Xpetra_Exceptions.hpp:101
XPETRA_FACTORY_ERROR_IF_EPETRA
#define XPETRA_FACTORY_ERROR_IF_EPETRA(lib)
Definition: Xpetra_Exceptions.hpp:70
Xpetra::MapFactory::createLocalMap
static Teuchos::RCP< const Map< LocalOrdinal, GlobalOrdinal, Node > > createLocalMap(UnderlyingLib lib, size_t numElements, const Teuchos::RCP< const Teuchos::Comm< int > > &comm)
Create a locally replicated Map with the default node.
Definition: Xpetra_MapFactory.hpp:173
Xpetra::MapFactory< int, int, EpetraNode >::defaultArgNode
static Teuchos::RCP< Node > defaultArgNode()
Definition: Xpetra_MapFactory.hpp:294
Xpetra::MapFactory::createContigMap
static Teuchos::RCP< const Map< LocalOrdinal, GlobalOrdinal, Node > > createContigMap(UnderlyingLib lib, global_size_t numElements, size_t localNumElements, const Teuchos::RCP< const Teuchos::Comm< int > > &comm)
Create a (potentially) non-uniform, contiguous Map with the default node.
Definition: Xpetra_MapFactory.hpp:243
Xpetra::MapFactory< int, long long, EpetraNode >::createLocalMapWithNode
static Teuchos::RCP< const Map< LocalOrdinal, GlobalOrdinal, Node > > createLocalMapWithNode(UnderlyingLib lib, size_t numElements, const Teuchos::RCP< const Teuchos::Comm< int > > &comm, const Teuchos::RCP< Node > &node)
Definition: Xpetra_MapFactory.hpp:670
Xpetra::MapFactory::MapFactory
MapFactory()
Private constructor. This is a static class.
Definition: Xpetra_MapFactory.hpp:74
Xpetra::MapFactory::Build
static Teuchos::RCP< Map< LocalOrdinal, GlobalOrdinal, Node > > Build(UnderlyingLib lib, global_size_t numGlobalElements, size_t numLocalElements, GlobalOrdinal indexBase, const Teuchos::RCP< const Teuchos::Comm< int > > &comm, const Teuchos::RCP< Node > &node=defaultArgNode())
Map constructor with a user-defined contiguous distribution.
Definition: Xpetra_MapFactory.hpp:110
Teuchos::rcp
TEUCHOS_DEPRECATED RCP< T > rcp(T *p, Dealloc_T dealloc, bool owns_mem)
Xpetra::MapFactory< int, long long, EpetraNode >::createLocalMap
static Teuchos::RCP< const Map< LocalOrdinal, GlobalOrdinal, Node > > createLocalMap(UnderlyingLib lib, size_t numElements, const Teuchos::RCP< const Teuchos::Comm< int > > &comm)
Definition: Xpetra_MapFactory.hpp:648
Xpetra::MapFactory< int, int, EpetraNode >::Build
static RCP< Map< LocalOrdinal, GlobalOrdinal, Node > > Build(UnderlyingLib lib, global_size_t numGlobalElements, const Teuchos::ArrayView< const GlobalOrdinal > &elementList, int indexBase, const Teuchos::RCP< const Teuchos::Comm< int > > &comm, const Teuchos::RCP< Node > &node=defaultArgNode())
Definition: Xpetra_MapFactory.hpp:345
Xpetra::MapFactory< int, int, EpetraNode >::createContigMapWithNode
static Teuchos::RCP< const Map< LocalOrdinal, GlobalOrdinal, Node > > createContigMapWithNode(UnderlyingLib lib, global_size_t numElements, size_t localNumElements, const Teuchos::RCP< const Teuchos::Comm< int > > &comm, const Teuchos::RCP< Node > &node)
Definition: Xpetra_MapFactory.hpp:513
Xpetra::MapFactory< int, int, EpetraNode >::createUniformContigMap
static Teuchos::RCP< const Map< LocalOrdinal, GlobalOrdinal, Node > > createUniformContigMap(UnderlyingLib lib, global_size_t numElements, const Teuchos::RCP< const Teuchos::Comm< int > > &comm)
Definition: Xpetra_MapFactory.hpp:465
XPETRA_FACTORY_END
#define XPETRA_FACTORY_END
Definition: Xpetra_Exceptions.hpp:77
Xpetra_Exceptions.hpp
Xpetra::MapFactory< int, int, EpetraNode >::createContigMap
static Teuchos::RCP< const Map< LocalOrdinal, GlobalOrdinal, Node > > createContigMap(UnderlyingLib lib, global_size_t numElements, size_t localNumElements, const Teuchos::RCP< const Teuchos::Comm< int > > &comm)
Definition: Xpetra_MapFactory.hpp:492
Xpetra::MapFactory::defaultArgNode
static Teuchos::RCP< Node > defaultArgNode()
Definition: Xpetra_MapFactory.hpp:77
Xpetra::global_size_t
size_t global_size_t
Global size_t object.
Definition: Xpetra_ConfigDefs.hpp:170
Xpetra_EpetraMap.hpp
Xpetra::MapFactory::createLocalMapWithNode
static Teuchos::RCP< const Map< LocalOrdinal, GlobalOrdinal, Node > > createLocalMapWithNode(UnderlyingLib lib, size_t numElements, const Teuchos::RCP< const Teuchos::Comm< int > > &comm, const Teuchos::RCP< Node > &node)
Create a locally replicated Map with a specified node.
Definition: Xpetra_MapFactory.hpp:190
Xpetra::MapFactory< int, int, EpetraNode >::createLocalMapWithNode
static Teuchos::RCP< const Map< LocalOrdinal, GlobalOrdinal, Node > > createLocalMapWithNode(UnderlyingLib lib, size_t numElements, const Teuchos::RCP< const Teuchos::Comm< int > > &comm, const Teuchos::RCP< Node > &node)
Definition: Xpetra_MapFactory.hpp:409
Xpetra::MapFactory< int, int, EpetraNode >::Build
static RCP< Map< LocalOrdinal, GlobalOrdinal, Node > > Build(UnderlyingLib lib, global_size_t numGlobalElements, size_t numLocalElements, int indexBase, const Teuchos::RCP< const Teuchos::Comm< int > > &comm, const Teuchos::RCP< Node > &node=defaultArgNode())
Definition: Xpetra_MapFactory.hpp:326
Xpetra_ConfigDefs.hpp
Xpetra::MapFactory
Create an Xpetra::Map instance.
Definition: Xpetra_MapFactory.hpp:70
Xpetra::MapFactory< int, long long, EpetraNode >::createUniformContigMap
static Teuchos::RCP< const Map< LocalOrdinal, GlobalOrdinal, Node > > createUniformContigMap(UnderlyingLib lib, global_size_t numElements, const Teuchos::RCP< const Teuchos::Comm< int > > &comm)
Definition: Xpetra_MapFactory.hpp:725
XPETRA_MONITOR
#define XPETRA_MONITOR(funcName)
Definition: Xpetra_ConfigDefs.hpp:128
Xpetra_Map.hpp
Xpetra::MapFactory< int, int, EpetraNode >::createUniformContigMapWithNode
static Teuchos::RCP< const Map< LocalOrdinal, GlobalOrdinal, Node > > createUniformContigMapWithNode(UnderlyingLib lib, global_size_t numElements, const Teuchos::RCP< const Teuchos::Comm< int > > &comm, const Teuchos::RCP< Node > &node)
Definition: Xpetra_MapFactory.hpp:436
Teuchos::RCP::getConst
RCP< const T > getConst() const
Xpetra::MapFactory< int, long long, EpetraNode >::Build
static RCP< Map< LocalOrdinal, GlobalOrdinal, Node > > Build(UnderlyingLib lib, global_size_t numGlobalElements, const Teuchos::ArrayView< const GlobalOrdinal > &elementList, int indexBase, const Teuchos::RCP< const Teuchos::Comm< int > > &comm, const Teuchos::RCP< Node > &node=defaultArgNode())
Definition: Xpetra_MapFactory.hpp:610
Xpetra::MapFactory::Build
static Teuchos::RCP< Map< LocalOrdinal, GlobalOrdinal, Node > > Build(UnderlyingLib lib, 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=defaultArgNode())
Map constructor with user-defined non-contiguous (arbitrary) distribution.
Definition: Xpetra_MapFactory.hpp:130
Xpetra::MapFactory< int, long long, EpetraNode >::Build
static RCP< Map< LocalOrdinal, GlobalOrdinal, Node > > Build(UnderlyingLib lib, global_size_t numGlobalElements, int indexBase, const Teuchos::RCP< const Teuchos::Comm< int > > &comm, LocalGlobal lg=GloballyDistributed, const Teuchos::RCP< Node > &node=defaultArgNode())
Definition: Xpetra_MapFactory.hpp:570
Xpetra::MapFactory< int, int, EpetraNode >::MapFactory
MapFactory()
Private constructor. This is a static class.
Definition: Xpetra_MapFactory.hpp:290
Generated by   doxygen 1.8.13