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:
75 
76  public:
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 
91  global_size_t numGlobalElements,
92  GlobalOrdinal indexBase,
93  const Teuchos::RCP<const Teuchos::Comm<int> > &comm,
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 
106  }
107 
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 
126  }
127 
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 
146  }
147 
151  LocalOrdinal numDofPerNode)
152  {
153  XPETRA_MONITOR("MapFactory::Build");
154 
155 #ifdef HAVE_XPETRA_TPETRA
156  LocalOrdinal N = map->getNodeNumElements();
157  Teuchos::ArrayView<const GlobalOrdinal> oldElements = map->getNodeElementList();
158  Teuchos::Array<GlobalOrdinal> newElements(map->getNodeNumElements()*numDofPerNode);
159  for (LocalOrdinal i = 0; i < N; i++)
160  for (LocalOrdinal j = 0; j < numDofPerNode; j++)
161  newElements[i*numDofPerNode + j] = oldElements[i]*numDofPerNode + j;
162  if (map->lib() == UseTpetra)
163  return rcp( new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (map->getGlobalNumElements()*numDofPerNode, newElements, map->getIndexBase(), map->getComm(), map->getNode()) );
164 #endif
165 
166  XPETRA_FACTORY_ERROR_IF_EPETRA(map->lib());
168  }
169 
173  size_t numElements,
174  const Teuchos::RCP< const Teuchos::Comm< int > > &comm)
175  {
176  XPETRA_MONITOR("MapFactory::Build");
177 
178 #ifdef HAVE_XPETRA_TPETRA
179  if (lib == UseTpetra)
180  return rcp(new Xpetra::TpetraMap<LocalOrdinal,GlobalOrdinal,Node>(Tpetra::createLocalMap<LocalOrdinal,GlobalOrdinal,Node>(numElements, comm)));
181 #endif
182 
185  }
186 
190  size_t numElements,
191  const Teuchos::RCP< const Teuchos::Comm< int > > &comm,
192  const Teuchos::RCP< Node > &node)
193  {
194  XPETRA_MONITOR("MapFactory::Build");
195 
196 #ifdef HAVE_XPETRA_TPETRA
197  if (lib == UseTpetra)
198  return rcp(new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (Tpetra::createLocalMapWithNode<LocalOrdinal,GlobalOrdinal,Node>(numElements, comm, node)));
199 #endif
200 
203  }
204 
208  global_size_t numElements,
209  const Teuchos::RCP< const Teuchos::Comm< int > > &comm,
210  const Teuchos::RCP< Node > &node)
211  {
212  XPETRA_MONITOR("MapFactory::Build");
213 
214 #ifdef HAVE_XPETRA_TPETRA
215  if (lib == UseTpetra)
216  return rcp(new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (Tpetra::createUniformContigMapWithNode<LocalOrdinal,GlobalOrdinal,Node>(numElements, comm, node)));
217 #endif
218 
221  }
222 
226  global_size_t numElements,
227  const Teuchos::RCP< const Teuchos::Comm< int > > &comm)
228  {
229  XPETRA_MONITOR("MapFactory::Build");
230 
231 #ifdef HAVE_XPETRA_TPETRA
232  if (lib == UseTpetra)
233  return rcp(new Xpetra::TpetraMap<LocalOrdinal,GlobalOrdinal,Node>(Tpetra::createUniformContigMapWithNode<LocalOrdinal,GlobalOrdinal,Node>(numElements, comm)));
234 #endif
235 
238  }
239 
243  global_size_t numElements,
244  size_t localNumElements,
245  const Teuchos::RCP< const Teuchos::Comm< int > > &comm)
246  {
247  XPETRA_MONITOR("MapFactory::Build");
248 
249 #ifdef HAVE_XPETRA_TPETRA
250  if (lib == UseTpetra)
251  return rcp(new Xpetra::TpetraMap<LocalOrdinal,GlobalOrdinal,Node>(Tpetra::createContigMapWithNode<LocalOrdinal,GlobalOrdinal,Node>(numElements, localNumElements, comm)));
252 #endif
253 
256  }
257 
261  global_size_t numElements,
262  size_t localNumElements,
263  const Teuchos::RCP< const Teuchos::Comm< int > > &comm,
264  const Teuchos::RCP< Node > &node)
265  {
266  XPETRA_MONITOR("MapFactory::Build");
267 
268 #ifdef HAVE_XPETRA_TPETRA
269  if (lib == UseTpetra)
270  return rcp(new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (Tpetra::createContigMapWithNode<LocalOrdinal,GlobalOrdinal,Node>(numElements, localNumElements, comm, node)));
271 #endif
272 
275  }
276  };
277 
278 // we need the Epetra specialization only if Epetra is enabled
279 #if (defined(HAVE_XPETRA_EPETRA) && !defined(XPETRA_EPETRA_NO_32BIT_GLOBAL_INDICES))
280  template <>
281  class MapFactory<int, int, EpetraNode> {
282 
283  typedef int LocalOrdinal;
284  typedef int GlobalOrdinal;
285  typedef EpetraNode Node;
286 
287  private:
290 
291  public:
292 
294  // Workaround function for a deferred visual studio bug
295  //
296  // http://connect.microsoft.com/VisualStudio/feedback/details/719847/erroneous-error-c2783-could-not-deduce-template-argument
297  //
298  // Use this function for default arguments rather than calling
299  // what is the return value below. Also helps in reducing
300  // duplication in various constructors.
301  return KokkosClassic::Details::getNode<Node>();
302  }
303 
306  global_size_t numGlobalElements,
307  int indexBase,
308  const Teuchos::RCP<const Teuchos::Comm<int> > &comm,
310  const Teuchos::RCP<Node>& node = defaultArgNode ()) {
311  XPETRA_MONITOR("MapFactory::Build");
312 
313 #ifdef HAVE_XPETRA_TPETRA
314  if (lib == UseTpetra)
315  return rcp( new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (numGlobalElements, indexBase, comm, lg, node) );
316 #endif
317 
318  if (lib == UseEpetra)
319  return rcp( new EpetraMapT<int, Node>(numGlobalElements, indexBase, comm, lg, node) );
320 
322  }
323 
326  global_size_t numGlobalElements,
327  size_t numLocalElements,
328  int indexBase,
329  const Teuchos::RCP<const Teuchos::Comm<int> > &comm,
330  const Teuchos::RCP<Node>& node = defaultArgNode())
331  {
332  XPETRA_MONITOR("MapFactory::Build");
333 #ifdef HAVE_XPETRA_TPETRA
334  if (lib == UseTpetra)
335  return rcp( new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (numGlobalElements, numLocalElements, indexBase, comm, node) );
336 #endif
337 
338  if (lib == UseEpetra)
339  return rcp( new EpetraMapT<int, Node>(numGlobalElements, numLocalElements, indexBase, comm, node) );
340 
342  }
343 
344  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 ()) {
345  XPETRA_MONITOR("MapFactory::Build");
346 #ifdef HAVE_XPETRA_TPETRA
347  if (lib == UseTpetra)
348  return rcp( new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (numGlobalElements, elementList, indexBase, comm, node) );
349 #endif
350 
351  if (lib == UseEpetra)
352  return rcp( new EpetraMapT<int, Node>(numGlobalElements, elementList, indexBase, comm, node) );
353 
355  }
356 
359  XPETRA_MONITOR("MapFactory::Build");
360 
361  LocalOrdinal N = map->getNodeNumElements();
362  Teuchos::ArrayView<const GlobalOrdinal> oldElements = map->getNodeElementList();
363  Teuchos::Array<GlobalOrdinal> newElements(map->getNodeNumElements()*numDofPerNode);
364  for (LocalOrdinal i = 0; i < N; i++)
365  for (LocalOrdinal j = 0; j < numDofPerNode; j++)
366  newElements[i*numDofPerNode + j] = oldElements[i]*numDofPerNode + j;
367 
368 #ifdef HAVE_XPETRA_TPETRA
369  if (map->lib() == UseTpetra)
370  return rcp( new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (map->getGlobalNumElements()*numDofPerNode, newElements, map->getIndexBase(), map->getComm(), map->getNode()) );
371 #endif
372 
373  if (map->lib() == UseEpetra)
374  return rcp( new EpetraMapT<int, Node>(map->getGlobalNumElements()*numDofPerNode, newElements, map->getIndexBase(), map->getComm(), map->getNode()) );
375 
377  }
378 
380  createLocalMap(UnderlyingLib lib, size_t numElements, const Teuchos::RCP< const Teuchos::Comm< int > > &comm) {
381  XPETRA_MONITOR("MapFactory::Build");
382 
383 #ifdef HAVE_XPETRA_TPETRA
384  if (lib == UseTpetra)
385  return rcp( new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (Tpetra::createLocalMapWithNode<LocalOrdinal,GlobalOrdinal, Node>(numElements, comm)));
386 #endif
387 
388  if (lib == UseEpetra) {
390  map = Teuchos::rcp( new EpetraMapT<int, Node>((Xpetra::global_size_t)numElements, // num elements, global and local
391  0, // index base is zero
392  comm, LocallyReplicated));
393  return map.getConst();
394  }
395 
397  }
398 
399  // TODO remove this
401  createLocalMapWithNode(UnderlyingLib lib, size_t numElements, const Teuchos::RCP< const Teuchos::Comm< int > > &comm, const Teuchos::RCP<Node> &node) {
402  XPETRA_MONITOR("MapFactory::Build");
403 
404 #ifdef HAVE_XPETRA_TPETRA
405  if (lib == UseTpetra)
406  return rcp (new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (Tpetra::createLocalMapWithNode<int, GlobalOrdinal, Node> (numElements, comm, node)));
407 #endif
408 
409  if (lib == UseEpetra) {
411  map = Teuchos::rcp( new EpetraMapT<int, Node>((Xpetra::global_size_t)numElements, // num elements, global and local
412  0, // index base is zero
413  comm, LocallyReplicated, node));
414  return map.getConst();
415  }
416 
418  }
419 
420  // TODO remove this
423  const Teuchos::RCP< const Teuchos::Comm< int > > &comm,
424  const Teuchos::RCP<Node>& node)
425  {
426  XPETRA_MONITOR("MapFactory::Build");
427 
428 #ifdef HAVE_XPETRA_TPETRA
429  if (lib == UseTpetra)
430  return rcp (new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (Tpetra::createUniformContigMapWithNode<int,GlobalOrdinal,Node> (numElements, comm, node)));
431 #endif
432 
433  if (lib == UseEpetra) {
435  map = Teuchos::rcp( new EpetraMapT<int,Node>(numElements, // num elements, global and local
436  0, //index base is zero
437  comm, GloballyDistributed, node));
438  return map.getConst();
439  }
440 
442  }
443 
446  XPETRA_MONITOR("MapFactory::Build");
447 
448 #ifdef HAVE_XPETRA_TPETRA
449  if (lib == UseTpetra)
450  return rcp( new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (Tpetra::createUniformContigMapWithNode<LocalOrdinal,GlobalOrdinal, Node>(numElements, comm)));
451 #endif
452 
453  if (lib == UseEpetra) {
454 
456  map = Teuchos::rcp( new EpetraMapT<int,Node>(numElements, // num elements, global and local
457  0, //index base is zero
458  comm, GloballyDistributed));
459  return map.getConst();
460  }
461 
463  }
464 
466  createContigMap(UnderlyingLib lib, global_size_t numElements, size_t localNumElements, const Teuchos::RCP< const Teuchos::Comm< int > > &comm) {
467  XPETRA_MONITOR("MapFactory::Build");
468 
469 #ifdef HAVE_XPETRA_TPETRA
470  if (lib == UseTpetra)
471  return rcp( new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (Tpetra::createContigMapWithNode<int,GlobalOrdinal,Node>(numElements, localNumElements, comm)));
472 #endif
473 
474  if (lib == UseEpetra)
475  return MapFactory<int, GlobalOrdinal, Node>::createContigMapWithNode(lib, numElements, localNumElements, comm, defaultArgNode() );
476 
478  }
479 
481  createContigMapWithNode(UnderlyingLib lib, global_size_t numElements, size_t localNumElements,
482  const Teuchos::RCP< const Teuchos::Comm< int > > &comm, const Teuchos::RCP<Node> &node) {
483  XPETRA_MONITOR("MapFactory::Build");
484 
485 #ifdef HAVE_XPETRA_TPETRA
486  if (lib == UseTpetra)
487  return rcp( new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (Tpetra::createContigMapWithNode<int,GlobalOrdinal,Node>(numElements, localNumElements, comm, node)));
488 #endif
489 
490  if (lib == UseEpetra) {
491 
493  map = Teuchos::rcp( new EpetraMapT<int, Node>(numElements,localNumElements,
494  0, // index base is zero
495  comm, node) );
496  return map.getConst();
497  }
498 
500  }
501 
502  };
503 #endif
504 
505  // we need the Epetra specialization only if Epetra is enabled
506 #if (defined(HAVE_XPETRA_EPETRA) && !defined(XPETRA_EPETRA_NO_64BIT_GLOBAL_INDICES))
507  template <>
508  class MapFactory<int, long long, EpetraNode> {
509 
510  typedef int LocalOrdinal;
511  typedef long long GlobalOrdinal;
512  typedef EpetraNode Node;
513 
514  private:
517 
518  public:
519 
521  // Workaround function for a deferred visual studio bug
522  //
523  // http://connect.microsoft.com/VisualStudio/feedback/details/719847/erroneous-error-c2783-could-not-deduce-template-argument
524  //
525  // Use this function for default arguments rather than calling
526  // what is the return value below. Also helps in reducing
527  // duplication in various constructors.
528  return KokkosClassic::Details::getNode<Node>();
529  }
530 
533  global_size_t numGlobalElements,
534  int indexBase,
535  const Teuchos::RCP<const Teuchos::Comm<int> > &comm,
537  const Teuchos::RCP<Node>& node = defaultArgNode ()) {
538  XPETRA_MONITOR("MapFactory::Build");
539 
540 #ifdef HAVE_XPETRA_TPETRA
541  if (lib == UseTpetra)
542  return rcp( new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (numGlobalElements, indexBase, comm, lg, node) );
543 #endif
544 
545  if (lib == UseEpetra)
546  return rcp( new EpetraMapT<long long, Node>(numGlobalElements, indexBase, comm, lg, node) );
547 
549  }
550 
553  global_size_t numGlobalElements,
554  size_t numLocalElements,
555  int indexBase,
556  const Teuchos::RCP<const Teuchos::Comm<int> > &comm,
557  const Teuchos::RCP<Node>& node = defaultArgNode())
558  {
559  XPETRA_MONITOR("MapFactory::Build");
560 
561 #ifdef HAVE_XPETRA_TPETRA
562  if (lib == UseTpetra)
563  return rcp( new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (numGlobalElements, numLocalElements, indexBase, comm, node) );
564 #endif
565 
566  if (lib == UseEpetra)
567  return rcp( new EpetraMapT<long long, Node>(numGlobalElements, numLocalElements, indexBase, comm, node) );
568 
570  }
571 
572  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 ()) {
573  XPETRA_MONITOR("MapFactory::Build");
574 
575 #ifdef HAVE_XPETRA_TPETRA
576  if (lib == UseTpetra)
577  return rcp( new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (numGlobalElements, elementList, indexBase, comm, node) );
578 #endif
579 
580  if (lib == UseEpetra)
581  return rcp( new EpetraMapT<long long, Node>(numGlobalElements, elementList, indexBase, comm, node) );
582 
584  }
585 
588  XPETRA_MONITOR("MapFactory::Build");
589 
590  LocalOrdinal N = map->getNodeNumElements();
591  Teuchos::ArrayView<const GlobalOrdinal> oldElements = map->getNodeElementList();
592  Teuchos::Array<GlobalOrdinal> newElements(map->getNodeNumElements()*numDofPerNode);
593  for (LocalOrdinal i = 0; i < N; i++)
594  for (LocalOrdinal j = 0; j < numDofPerNode; j++)
595  newElements[i*numDofPerNode + j] = oldElements[i]*numDofPerNode + j;
596 
597 #ifdef HAVE_XPETRA_TPETRA
598  if (map->lib() == UseTpetra)
599  return rcp( new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (map->getGlobalNumElements()*numDofPerNode, newElements, map->getIndexBase(), map->getComm(), map->getNode()) );
600 #endif
601 
602  if (map->lib() == UseEpetra)
603  return rcp( new EpetraMapT<long long, Node>(map->getGlobalNumElements()*numDofPerNode, newElements, map->getIndexBase(), map->getComm(), map->getNode()) );
604 
606  }
607 
609  createLocalMap(UnderlyingLib lib, size_t numElements, const Teuchos::RCP< const Teuchos::Comm< int > > &comm) {
610  XPETRA_MONITOR("MapFactory::Build");
611 
612 #ifdef HAVE_XPETRA_TPETRA
613  if (lib == UseTpetra)
614  return rcp( new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (Tpetra::createLocalMapWithNode<LocalOrdinal,GlobalOrdinal, Node>(numElements, comm)));
615 #endif
616 
617  if (lib == UseEpetra)
619  defaultArgNode());
620 
622  }
623 
625  createLocalMapWithNode(UnderlyingLib lib, size_t numElements, const Teuchos::RCP< const Teuchos::Comm< int > > &comm, const Teuchos::RCP<Node> &node) {
626  XPETRA_MONITOR("MapFactory::Build");
627 
628 #ifdef HAVE_XPETRA_TPETRA
629  if (lib == UseTpetra)
630  return rcp (new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (Tpetra::createLocalMapWithNode<int, GlobalOrdinal, Node> (numElements, comm, node)));
631 #endif
632 
633  if (lib == UseEpetra) {
635  map = Teuchos::rcp( new EpetraMapT<long long, Node>((Xpetra::global_size_t)numElements, // num elements, global and local
636  0, // index base is zero
637  comm, LocallyReplicated, node));
638  return map.getConst();
639  }
640 
642  }
643 
646  const Teuchos::RCP< const Teuchos::Comm< int > > &comm,
647  const Teuchos::RCP<Node>& node)
648  {
649  XPETRA_MONITOR("MapFactory::Build");
650 
651 #ifdef HAVE_XPETRA_TPETRA
652  if (lib == UseTpetra)
653  return rcp (new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (Tpetra::createUniformContigMapWithNode<int,GlobalOrdinal,Node> (numElements, comm, node)));
654 #endif
655 
656  if (lib == UseEpetra) {
658  map = Teuchos::rcp( new EpetraMapT<long long, Node>(numElements, // num elements, global and local
659  0, //index base is zero
660  comm, GloballyDistributed, node));
661  return map.getConst();
662  }
663 
665  }
666 
669  XPETRA_MONITOR("MapFactory::Build");
670 
671 #ifdef HAVE_XPETRA_TPETRA
672  if (lib == UseTpetra)
673  return rcp( new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (Tpetra::createUniformContigMapWithNode<LocalOrdinal,GlobalOrdinal, Node>(numElements, comm)));
674 #endif
675 
676  if (lib == UseEpetra)
678  defaultArgNode());
679 
681  }
682 
684  createContigMap(UnderlyingLib lib, global_size_t numElements, size_t localNumElements, const Teuchos::RCP< const Teuchos::Comm< int > > &comm) {
685  XPETRA_MONITOR("MapFactory::Build");
686 
687 #ifdef HAVE_XPETRA_TPETRA
688  if (lib == UseTpetra)
689  return rcp( new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (Tpetra::createContigMapWithNode<int,GlobalOrdinal,Node>(numElements, localNumElements, comm)));
690 #endif
691 
692  if (lib == UseEpetra)
693  return MapFactory<int, GlobalOrdinal, Node>::createContigMapWithNode(lib, numElements, localNumElements, comm, defaultArgNode() );
694 
696  }
697 
699  createContigMapWithNode(UnderlyingLib lib, global_size_t numElements, size_t localNumElements,
700  const Teuchos::RCP< const Teuchos::Comm< int > > &comm, const Teuchos::RCP<Node> &node) {
701  XPETRA_MONITOR("MapFactory::Build");
702 
703 #ifdef HAVE_XPETRA_TPETRA
704  if (lib == UseTpetra)
705  return rcp( new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (Tpetra::createContigMapWithNode<int,GlobalOrdinal,Node>(numElements, localNumElements, comm, node)));
706 #endif
707 
708  if (lib == UseEpetra) {
710  map = Teuchos::rcp( new EpetraMapT<long long, Node>(numElements,localNumElements,
711  0, // index base is zero
712  comm, node) );
713  return map.getConst();
714  }
715 
717  }
718 
719  };
720 #endif
721 
722 }
723 
724 #define XPETRA_MAPFACTORY_SHORT
725 #endif
726 //TODO: removed unused methods
RCP< const T > getConst() const
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())
static Teuchos::RCP< Map< LocalOrdinal, GlobalOrdinal, Node > > Build(const Teuchos::RCP< const Map< LocalOrdinal, GlobalOrdinal, Node > > &map, LocalOrdinal numDofPerNode)
Map constructor transforming degrees of freedom.
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.
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.
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())
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.
GlobalOrdinal global_ordinal_type
Definition: Xpetra_Map.hpp:86
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.
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)
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)
static Teuchos::RCP< Map< LocalOrdinal, GlobalOrdinal, Node > > Build(const Teuchos::RCP< const Map< LocalOrdinal, GlobalOrdinal, Node > > &map, LocalOrdinal numDofPerNode)
Map constructor transforming degrees of freedom.
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)
static Teuchos::RCP< const Map< LocalOrdinal, GlobalOrdinal, Node > > createLocalMap(UnderlyingLib lib, size_t numElements, const Teuchos::RCP< const Teuchos::Comm< int > > &comm)
Node node_type
Definition: Xpetra_Map.hpp:87
static Teuchos::RCP< Map< LocalOrdinal, GlobalOrdinal, Node > > Build(const Teuchos::RCP< const Map< LocalOrdinal, GlobalOrdinal, Node > > &map, LocalOrdinal numDofPerNode)
Map constructor transforming degrees of freedom.
Xpetra namespace
MapFactory()
Private constructor. This is a static class.
#define XPETRA_FACTORY_ERROR_IF_EPETRA(lib)
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.
static Teuchos::RCP< Node > defaultArgNode()
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.
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)
MapFactory()
Private constructor. This is a static class.
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.
TEUCHOS_DEPRECATED RCP< T > rcp(T *p, Dealloc_T dealloc, bool owns_mem)
static Teuchos::RCP< const Map< LocalOrdinal, GlobalOrdinal, Node > > createLocalMap(UnderlyingLib lib, size_t numElements, const Teuchos::RCP< const Teuchos::Comm< int > > &comm)
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())
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)
static Teuchos::RCP< const Map< LocalOrdinal, GlobalOrdinal, Node > > createUniformContigMap(UnderlyingLib lib, global_size_t numElements, const Teuchos::RCP< const Teuchos::Comm< int > > &comm)
#define XPETRA_FACTORY_END
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)
static Teuchos::RCP< Node > defaultArgNode()
size_t global_size_t
Global size_t object.
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.
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)
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())
Create an Xpetra::Map instance.
static Teuchos::RCP< const Map< LocalOrdinal, GlobalOrdinal, Node > > createUniformContigMap(UnderlyingLib lib, global_size_t numElements, const Teuchos::RCP< const Teuchos::Comm< int > > &comm)
#define XPETRA_MONITOR(funcName)
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)
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())
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.
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())
MapFactory()
Private constructor. This is a static class.