Xpetra Version of the Day
Xpetra_EpetraMapFactory.cpp
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#include "Xpetra_MapFactory.hpp"
47
48#include "Xpetra_BlockedMap.hpp"
49#include "Xpetra_EpetraMap.hpp"
50#ifdef HAVE_XPETRA_TPETRA
51#include "Xpetra_TpetraMap.hpp"
52#endif
53
54namespace Xpetra {
55
56#if defined(HAVE_XPETRA_EPETRA)
57
58
59#if !defined(XPETRA_EPETRA_NO_32BIT_GLOBAL_INDICES)
60
61
62 MapFactory<int, int, EpetraNode>::
63 MapFactory()
64 {
65 }
66
67
68
69
70 RCP<Map<int, int, EpetraNode>>
71 MapFactory<int, int, EpetraNode>::
72 Build (UnderlyingLib lib,
73 global_size_t numGlobalElements,
74 int indexBase,
75 const Teuchos::RCP<const Teuchos::Comm<int> > &comm,
76 LocalGlobal lg)
77 {
78 XPETRA_MONITOR("MapFactory::Build");
79
80#ifdef HAVE_XPETRA_TPETRA
81 if (lib == UseTpetra)
82 return rcp( new Xpetra::TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (numGlobalElements, indexBase, comm, lg) );
83#endif
84
85 if (lib == UseEpetra)
86 return rcp( new EpetraMapT<int, Node>(numGlobalElements, indexBase, comm, lg) );
87
88 XPETRA_FACTORY_END;
89 }
90
91
92
93
94 RCP<Map<int, int, EpetraNode> >
95 MapFactory<int, int, EpetraNode>::
96 Build (UnderlyingLib lib,
97 global_size_t numGlobalElements,
98 size_t numLocalElements,
99 int indexBase,
100 const Teuchos::RCP<const Teuchos::Comm<int> > &comm)
101 {
102 XPETRA_MONITOR("MapFactory::Build");
103
104#ifdef HAVE_XPETRA_TPETRA
105 if (lib == UseTpetra)
106 return rcp( new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (numGlobalElements, numLocalElements, indexBase, comm) );
107#endif
108
109 if (lib == UseEpetra)
110 return rcp( new EpetraMapT<int, Node>(numGlobalElements, numLocalElements, indexBase, comm) );
111
112 XPETRA_FACTORY_END;
113 }
114
115
116
117
118 RCP<Map<int, int, EpetraNode> >
119 MapFactory<int, int, EpetraNode>::
120 Build(UnderlyingLib lib,
121 global_size_t numGlobalElements,
122 const Teuchos::ArrayView<const int> &elementList,
123 int indexBase,
124 const Teuchos::RCP<const Teuchos::Comm<int> > &comm)
125 {
126
127 XPETRA_MONITOR("MapFactory::Build");
128#ifdef HAVE_XPETRA_TPETRA
129 if (lib == UseTpetra)
130 return rcp( new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (numGlobalElements, elementList, indexBase, comm) );
131#endif // HAVE_XPETRA_TPETRA
132
133 if (lib == UseEpetra)
134 return rcp( new EpetraMapT<int, Node>(numGlobalElements, elementList, indexBase, comm) );
135
136 XPETRA_FACTORY_END;
137 }
138
139
142 Teuchos::RCP<Map<int, int, EpetraNode> >
143 MapFactory<int, int, EpetraNode>::
144 Build(const Teuchos::RCP<const Map<int, int, EpetraNode> >& map,
145 const int numDofPerNode, const int gidOffset)
146 {
147 XPETRA_MONITOR("MapFactory::Build");
148
149 RCP<const BlockedMap<LocalOrdinal, GlobalOrdinal, Node> > bmap = Teuchos::rcp_dynamic_cast<const BlockedMap<LocalOrdinal, GlobalOrdinal, Node> >(map);
150 if(!bmap.is_null())
151 {
152 TEUCHOS_TEST_FOR_EXCEPTION(numDofPerNode!=1, Xpetra::Exceptions::RuntimeError,
153 "Xpetra::MapFactory::Build: When provided a BlockedMap numDofPerNode must set to be one. It is set to " << numDofPerNode << ".");
154 return rcp(new BlockedMap<LocalOrdinal, GlobalOrdinal, Node>(*bmap));
155 }
156
157 LocalOrdinal N = Teuchos::as<LocalOrdinal>(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 {
162 for (LocalOrdinal j = 0; j < numDofPerNode; j++)
163 {
164 newElements[i*numDofPerNode + j] = oldElements[i]*numDofPerNode + j + gidOffset;
165 }
166 }
167
168#ifdef HAVE_XPETRA_TPETRA
169 if (map->lib() == UseTpetra)
170 {
171 return rcp( new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (map->getGlobalNumElements()*numDofPerNode, newElements, map->getIndexBase(), map->getComm()) );
172 }
173#endif // HAVE_XPETRA_TPETRA
174
175 if (map->lib() == UseEpetra)
176 {
177 return rcp( new EpetraMapT<int, Node>(map->getGlobalNumElements()*numDofPerNode, newElements, map->getIndexBase(), map->getComm()) );
178 }
179
180 XPETRA_FACTORY_END;
181 }
182
183
184 Teuchos::RCP<const Map<int, int, EpetraNode> >
185 MapFactory<int, int, EpetraNode>::
186 createLocalMap(UnderlyingLib lib,
187 size_t numElements,
188 const Teuchos::RCP< const Teuchos::Comm< int > > &comm)
189 {
190 XPETRA_MONITOR("MapFactory::Build");
191
192#ifdef HAVE_XPETRA_TPETRA
193 if (lib == UseTpetra)
194#if ((defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_OPENMP) && defined(HAVE_TPETRA_INST_INT_INT))) || \
195 (!defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_SERIAL) && defined(HAVE_TPETRA_INST_INT_INT))))
196 return rcp( new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (Tpetra::createLocalMapWithNode<LocalOrdinal,GlobalOrdinal, Node>(numElements, comm)));
197#else
198 TEUCHOS_TEST_FOR_EXCEPTION(true, Xpetra::Exceptions::RuntimeError,
199 "Xpetra::MapFactory::createLocalMap: Cannot create Xpetra::TpetraMap, since Tpetra is not instantiated on EpetraNode (Serial or OpenMP, depending on configuration) and/or GO=int");
200#endif
201#endif // HAVE_XPETRA_TPETRA
202
203 if (lib == UseEpetra) {
204 Teuchos::RCP< EpetraMapT<int, Node> > map;
205 map = Teuchos::rcp( new EpetraMapT<int, Node>( (Xpetra::global_size_t)numElements, // num elements, global and local
206 0, // index base is zero
207 comm, LocallyReplicated)
208 );
209 return map.getConst();
210 }
211
212 XPETRA_FACTORY_END;
213 }
214
215
216 // TODO remove this
217
218
219
220 Teuchos::RCP< const Map<int, int, EpetraNode> >
221 MapFactory<int, int, EpetraNode>::
222 createLocalMapWithNode(UnderlyingLib lib,
223 size_t numElements,
224 const Teuchos::RCP< const Teuchos::Comm< int > > &comm)
225 {
226 XPETRA_MONITOR("MapFactory::Build");
227
228#ifdef HAVE_XPETRA_TPETRA
229 if (lib == UseTpetra)
230#if ((defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_OPENMP) && defined(HAVE_TPETRA_INST_INT_INT))) || \
231 (!defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_SERIAL) && defined(HAVE_TPETRA_INST_INT_INT))))
232 return rcp (new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (Tpetra::createLocalMapWithNode<int, GlobalOrdinal, Node> (numElements, comm)));
233#else
234 TEUCHOS_TEST_FOR_EXCEPTION(true, Xpetra::Exceptions::RuntimeError,
235 "Xpetra::MapFactory::createLocalMapWithNode: Cannot create Xpetra::TpetraMap, since Tpetra is not instantiated on EpetraNode (Serial or OpenMP, depending on configuration) and/or GO=int");
236#endif
237#endif // HAVE_XPETRA_TPETRA
238
239 if (lib == UseEpetra) {
240 Teuchos::RCP< EpetraMapT<int, Node> > map;
241 map = Teuchos::rcp( new EpetraMapT<int, Node>((Xpetra::global_size_t)numElements, // num elements, global and local
242 0, // index base is zero
243 comm, LocallyReplicated));
244 return map.getConst();
245 }
246
247 XPETRA_FACTORY_END;
248 }
249
250
251
252 // TODO remove this
253
254
255
256 Teuchos::RCP< const Map<int, int, EpetraNode> >
257 MapFactory<int, int, EpetraNode>::
258 createUniformContigMapWithNode (UnderlyingLib lib,
259 global_size_t numElements,
260 const Teuchos::RCP< const Teuchos::Comm< int > > &comm)
261 {
262 XPETRA_MONITOR("MapFactory::Build");
263
264#ifdef HAVE_XPETRA_TPETRA
265 if (lib == UseTpetra)
266#if ((defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_OPENMP) && defined(HAVE_TPETRA_INST_INT_INT))) || \
267 (!defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_SERIAL) && defined(HAVE_TPETRA_INST_INT_INT))))
268 return rcp (new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (Tpetra::createUniformContigMapWithNode<int,GlobalOrdinal,Node> (numElements, comm)));
269#else
270 TEUCHOS_TEST_FOR_EXCEPTION(true, Xpetra::Exceptions::RuntimeError,
271 "Xpetra::MapFactory::createUniformContigMapWithNode: Cannot create Xpetra::TpetraMap, since Tpetra is not instantiated on EpetraNode (Serial or OpenMP, depending on configuration) and/or GO=int");
272#endif
273#endif // HAVE_XPETRA_TPETRA
274
275 if (lib == UseEpetra) {
276 Teuchos::RCP< EpetraMapT<int,Node> > map;
277 map = Teuchos::rcp( new EpetraMapT<int,Node>(numElements, // num elements, global and local
278 0, //index base is zero
279 comm, GloballyDistributed));
280 return map.getConst();
281 }
282
283 XPETRA_FACTORY_END;
284 }
285
286
287 Teuchos::RCP< const Map<int, int, EpetraNode> >
288 MapFactory<int, int, EpetraNode>::
289 createUniformContigMap(UnderlyingLib lib,
290 global_size_t numElements,
291 const Teuchos::RCP< const Teuchos::Comm< int > > &comm)
292 {
293 XPETRA_MONITOR("MapFactory::Build");
294
295#ifdef HAVE_XPETRA_TPETRA
296 if (lib == UseTpetra)
297#if ((defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_OPENMP) && defined(HAVE_TPETRA_INST_INT_INT))) || \
298 (!defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_SERIAL) && defined(HAVE_TPETRA_INST_INT_INT))))
299 return rcp( new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (Tpetra::createUniformContigMapWithNode<LocalOrdinal,GlobalOrdinal, Node>(numElements, comm)));
300#else
301 TEUCHOS_TEST_FOR_EXCEPTION(true, Xpetra::Exceptions::RuntimeError,
302 "Xpetra::MapFactory::createUniformContigMapWithNode: Cannot create Xpetra::TpetraMap, since Tpetra is not instantiated on EpetraNode (Serial or OpenMP, depending on configuration) and/or GO=int");
303#endif
304#endif // HAVE_XPETRA_TPETRA
305
306 if (lib == UseEpetra)
307 {
308 Teuchos::RCP< EpetraMapT<int,Node> > map;
309 map = Teuchos::rcp( new EpetraMapT<int,Node>(numElements, // num elements, global and local
310 0, //index base is zero
311 comm, GloballyDistributed));
312 return map.getConst();
313 }
314 XPETRA_FACTORY_END;
315 }
316
317
318 Teuchos::RCP< const Map<int, int, EpetraNode> >
319 MapFactory<int, int, EpetraNode>::
320 createContigMap(UnderlyingLib lib,
321 global_size_t numElements,
322 size_t localNumElements,
323 const Teuchos::RCP< const Teuchos::Comm< int > > &comm)
324 {
325 XPETRA_MONITOR("MapFactory::Build");
326
327 #ifdef HAVE_XPETRA_TPETRA
328 if (lib == UseTpetra)
329 #if ((defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_OPENMP) && defined(HAVE_TPETRA_INST_INT_INT))) || \
330 (!defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_SERIAL) && defined(HAVE_TPETRA_INST_INT_INT))))
331 return rcp( new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (Tpetra::createContigMapWithNode<int,GlobalOrdinal,Node>(numElements, localNumElements, comm)));
332 #else
333 TEUCHOS_TEST_FOR_EXCEPTION(true, Xpetra::Exceptions::RuntimeError,
334 "Xpetra::MapFactory::createContigMap: Cannot create Xpetra::TpetraMap, since Tpetra is not instantiated on EpetraNode (Serial or OpenMP, depending on configuration) and/or GO=int");
335 #endif
336 #endif
337
338 if (lib == UseEpetra)
339 {
340 return MapFactory<int, GlobalOrdinal, Node>::createContigMapWithNode(lib, numElements, localNumElements, comm);
341 }
342
343 XPETRA_FACTORY_END;
344 }
345
346
347
348
349 Teuchos::RCP< const Map<int, int, EpetraNode> >
350 MapFactory<int, int, EpetraNode>::
351 createContigMapWithNode(UnderlyingLib lib,
352 global_size_t numElements,
353 size_t localNumElements,
354 const Teuchos::RCP< const Teuchos::Comm< int > > &comm)
355 {
356 XPETRA_MONITOR("MapFactory::Build");
357
358#ifdef HAVE_XPETRA_TPETRA
359 if (lib == UseTpetra)
360#if ((defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_OPENMP) && defined(HAVE_TPETRA_INST_INT_INT))) || \
361 (!defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_SERIAL) && defined(HAVE_TPETRA_INST_INT_INT))))
362 return rcp( new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (Tpetra::createContigMapWithNode<int,GlobalOrdinal,Node>(numElements, localNumElements, comm)));
363#else
364 TEUCHOS_TEST_FOR_EXCEPTION(true, Xpetra::Exceptions::RuntimeError,
365 "Xpetra::MapFactory::createContigMapWithNode: Cannot create Xpetra::TpetraMap, since Tpetra is not instantiated on EpetraNode (Serial or OpenMP, depending on configuration) and/or GO=int");
366#endif
367#endif
368
369 if (lib == UseEpetra)
370 {
371 Teuchos::RCP< EpetraMapT<int, Node> > map;
372 map = Teuchos::rcp( new EpetraMapT<int, Node>(numElements,localNumElements,
373 0, // index base is zero
374 comm) );
375 return map.getConst();
376 }
377 XPETRA_FACTORY_END;
378 }
379
380
381
382#endif // #if !defined(XPETRA_EPETRA_NO_32BIT_GLOBAL_INDICES)
383
384
385
386
387
388
389
390
391// we need the Epetra specialization only if Epetra is enabled
392#if !defined(XPETRA_EPETRA_NO_64BIT_GLOBAL_INDICES)
393
394
395
397 MapFactory<int, long long, EpetraNode>::
398 MapFactory()
399 {
400 }
401
402
403
404
405 RCP<Map<int, long long, EpetraNode>>
406 MapFactory<int, long long, EpetraNode>::
407 Build (UnderlyingLib lib,
408 global_size_t numGlobalElements,
409 int indexBase,
410 const Teuchos::RCP<const Teuchos::Comm<int> > &comm,
411 LocalGlobal lg)
412 {
413 XPETRA_MONITOR("MapFactory::Build");
414
415#ifdef HAVE_XPETRA_TPETRA
416 if (lib == UseTpetra)
417 return rcp( new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (numGlobalElements, indexBase, comm, lg) );
418#endif
419
420 if (lib == UseEpetra)
421 return rcp( new EpetraMapT<long long, Node>(numGlobalElements, indexBase, comm, lg) );
422
423 XPETRA_FACTORY_END;
424 }
425
426
427
428
429 RCP<Map<int, long long, EpetraNode> >
430 MapFactory<int, long long, EpetraNode>::
431 Build (UnderlyingLib lib,
432 global_size_t numGlobalElements,
433 size_t numLocalElements,
434 int indexBase,
435 const Teuchos::RCP<const Teuchos::Comm<int> > &comm)
436 {
437 XPETRA_MONITOR("MapFactory::Build");
438
439#ifdef HAVE_XPETRA_TPETRA
440 if (lib == UseTpetra)
441 return rcp( new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (numGlobalElements, numLocalElements, indexBase, comm) );
442#endif
443
444 if (lib == UseEpetra)
445 return rcp( new EpetraMapT<long long, Node>(numGlobalElements, numLocalElements, indexBase, comm) );
446
447 XPETRA_FACTORY_END;
448 }
449
450
451
452
453 RCP<Map<int, long long, EpetraNode> >
454 MapFactory<int, long long, EpetraNode>::
455 Build(UnderlyingLib lib,
456 global_size_t numGlobalElements,
457 const Teuchos::ArrayView<const long long> &elementList,
458 int indexBase,
459 const Teuchos::RCP<const Teuchos::Comm<int> > &comm)
460 {
461 XPETRA_MONITOR("MapFactory::Build");
462
463#ifdef HAVE_XPETRA_TPETRA
464 if (lib == UseTpetra)
465 return rcp( new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (numGlobalElements, elementList, indexBase, comm) );
466#endif
467
468 if (lib == UseEpetra)
469 return rcp( new EpetraMapT<long long, Node>(numGlobalElements, elementList, indexBase, comm) );
470
471 XPETRA_FACTORY_END;
472 }
473
476 Teuchos::RCP<Map<int, long long, EpetraNode> >
477 MapFactory<int, long long, EpetraNode>::
478 Build(const Teuchos::RCP<const Map<int, long long, EpetraNode> >& map,
479 int numDofPerNode)
480 {
481 XPETRA_MONITOR("MapFactory::Build");
482
483 RCP<const BlockedMap<LocalOrdinal, GlobalOrdinal, Node> > bmap = Teuchos::rcp_dynamic_cast<const BlockedMap<LocalOrdinal, GlobalOrdinal, Node> >(map);
484 if(!bmap.is_null()) {
485 TEUCHOS_TEST_FOR_EXCEPTION(numDofPerNode!=1, Xpetra::Exceptions::RuntimeError,
486 "Xpetra::MapFactory::Build: When provided a BlockedMap numDofPerNode must set to be one. It is set to " << numDofPerNode << ".");
487 return rcp(new Xpetra::BlockedMap<LocalOrdinal, GlobalOrdinal, Node>(*bmap));
488 }
489
490 LocalOrdinal N = map->getNodeNumElements();
491 Teuchos::ArrayView<const GlobalOrdinal> oldElements = map->getNodeElementList();
492 Teuchos::Array<GlobalOrdinal> newElements(map->getNodeNumElements()*numDofPerNode);
493 for (LocalOrdinal i = 0; i < N; i++)
494 for (LocalOrdinal j = 0; j < numDofPerNode; j++)
495 newElements[i*numDofPerNode + j] = oldElements[i]*numDofPerNode + j;
496
497#ifdef HAVE_XPETRA_TPETRA
498 if (map->lib() == UseTpetra)
499 return rcp( new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (map->getGlobalNumElements()*numDofPerNode, newElements, map->getIndexBase(), map->getComm()) );
500#endif
501
502 if (map->lib() == UseEpetra)
503 return rcp( new EpetraMapT<long long, Node>(map->getGlobalNumElements()*numDofPerNode, newElements, map->getIndexBase(), map->getComm()) );
504
505 XPETRA_FACTORY_END;
506 }
507
508
509 Teuchos::RCP<const Map<int, long long, EpetraNode> >
510 MapFactory<int, long long, EpetraNode>::
511 createLocalMap(UnderlyingLib lib,
512 size_t numElements,
513 const Teuchos::RCP< const Teuchos::Comm< int > > &comm)
514 {
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_LONG_LONG))) || \
520 (!defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_SERIAL) && defined(HAVE_TPETRA_INST_INT_LONG_LONG))))
521 return rcp( new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (Tpetra::createLocalMapWithNode<LocalOrdinal,GlobalOrdinal, Node>(numElements, comm)));
522#else
523 TEUCHOS_TEST_FOR_EXCEPTION(true, Xpetra::Exceptions::RuntimeError,
524 "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");
525#endif
526#endif
527
528 if (lib == UseEpetra)
529 return MapFactory<int, GlobalOrdinal, Node>::createLocalMapWithNode (lib, numElements, comm);
530
531 XPETRA_FACTORY_END;
532 }
533
534
535
536
537 Teuchos::RCP< const Map<int, long long, EpetraNode> >
538 MapFactory<int, long long, EpetraNode>::
539 createLocalMapWithNode(UnderlyingLib lib,
540 size_t numElements,
541 const Teuchos::RCP< const Teuchos::Comm< int > > &comm)
542 {
543 XPETRA_MONITOR("MapFactory::Build");
544
545#ifdef HAVE_XPETRA_TPETRA
546 if (lib == UseTpetra)
547#if ((defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_OPENMP) && defined(HAVE_TPETRA_INST_INT_LONG_LONG))) || \
548 (!defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_SERIAL) && defined(HAVE_TPETRA_INST_INT_LONG_LONG))))
549 return rcp (new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (Tpetra::createLocalMapWithNode<int, GlobalOrdinal, Node> (numElements, comm)));
550#else
551 TEUCHOS_TEST_FOR_EXCEPTION(true, Xpetra::Exceptions::RuntimeError,
552 "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");
553#endif
554#endif
555
556 if (lib == UseEpetra)
557 {
558 Teuchos::RCP< EpetraMapT<long long, Node> > map;
559 map = Teuchos::rcp( new EpetraMapT<long long, Node>((Xpetra::global_size_t)numElements, // num elements, global and local
560 0, // index base is zero
561 comm, LocallyReplicated));
562 return map.getConst();
563 }
564 XPETRA_FACTORY_END;
565 }
566
567
568
569
570 Teuchos::RCP< const Map<int, long long, EpetraNode> >
571 MapFactory<int, long long, EpetraNode>::
572 createUniformContigMapWithNode (UnderlyingLib lib,
573 global_size_t numElements,
574 const Teuchos::RCP< const Teuchos::Comm< int > > &comm)
575 {
576 XPETRA_MONITOR("MapFactory::Build");
577
578#ifdef HAVE_XPETRA_TPETRA
579 if (lib == UseTpetra)
580#if ((defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_OPENMP) && defined(HAVE_TPETRA_INST_INT_LONG_LONG))) || \
581 (!defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_SERIAL) && defined(HAVE_TPETRA_INST_INT_LONG_LONG))))
582 return rcp (new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (Tpetra::createUniformContigMapWithNode<int,GlobalOrdinal,Node> (numElements, comm)));
583#else
584 TEUCHOS_TEST_FOR_EXCEPTION(true, Xpetra::Exceptions::RuntimeError,
585 "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");
586#endif
587#endif
588
589 if (lib == UseEpetra)
590 {
591 Teuchos::RCP< EpetraMapT<long long, Node> > map;
592 map = Teuchos::rcp( new EpetraMapT<long long, Node>(numElements, // num elements, global and local
593 0, //index base is zero
594 comm, GloballyDistributed));
595 return map.getConst();
596 }
597 XPETRA_FACTORY_END;
598 }
599
600
601 Teuchos::RCP< const Map<int, long long, EpetraNode> >
602 MapFactory<int, long long, EpetraNode>::
603 createUniformContigMap(UnderlyingLib lib,
604 global_size_t numElements,
605 const Teuchos::RCP< const Teuchos::Comm< int > > &comm)
606 {
607 XPETRA_MONITOR("MapFactory::Build");
608
609#ifdef HAVE_XPETRA_TPETRA
610 if (lib == UseTpetra)
611#if ((defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_OPENMP) && defined(HAVE_TPETRA_INST_INT_LONG_LONG))) || \
612 (!defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_SERIAL) && defined(HAVE_TPETRA_INST_INT_LONG_LONG))))
613 return rcp( new TpetraMap<LocalOrdinal,GlobalOrdinal, Node> (Tpetra::createUniformContigMapWithNode<LocalOrdinal,GlobalOrdinal, Node>(numElements, comm)));
614#else
615 TEUCHOS_TEST_FOR_EXCEPTION(true, Xpetra::Exceptions::RuntimeError,
616 "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");
617#endif
618#endif
619
620 if (lib == UseEpetra)
621 return MapFactory<int, GlobalOrdinal, Node>::createUniformContigMapWithNode (lib, numElements, comm);
622
623 XPETRA_FACTORY_END;
624 }
625
626
627 Teuchos::RCP<const Map<int, long long, EpetraNode>>
628 MapFactory<int, long long, EpetraNode>::createContigMap(UnderlyingLib lib,
629 global_size_t numElements,
630 size_t localNumElements,
631 const Teuchos::RCP<const Teuchos::Comm<int>>& comm)
632 {
633 XPETRA_MONITOR("MapFactory::Build");
634
635#ifdef HAVE_XPETRA_TPETRA
636 if(lib == UseTpetra)
637#if((defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_OPENMP) && defined(HAVE_TPETRA_INST_INT_LONG_LONG))) \
638 || (!defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_SERIAL) && defined(HAVE_TPETRA_INST_INT_LONG_LONG))))
639 return rcp(new TpetraMap<LocalOrdinal, GlobalOrdinal, Node>(
640 Tpetra::createContigMapWithNode<int, GlobalOrdinal, Node>(numElements, localNumElements, comm)));
641#else
642 TEUCHOS_TEST_FOR_EXCEPTION(true,
643 Xpetra::Exceptions::RuntimeError,
644 "Xpetra::MapFactory::createContigMap: Cannot create Xpetra::TpetraMap, since Tpetra is not instantiated on "
645 "EpetraNode (Serial or OpenMP, depending on configuration) and/or GO=long long");
646#endif
647#endif
648
649 if(lib == UseEpetra)
650 return MapFactory<int, GlobalOrdinal, Node>::createContigMapWithNode(lib, numElements, localNumElements, comm);
651
652 XPETRA_FACTORY_END;
653 }
654
655
656
657
658 Teuchos::RCP<const Map<int, long long, EpetraNode>>
659 MapFactory<int, long long, EpetraNode>::
660 createContigMapWithNode(UnderlyingLib lib,
661 global_size_t numElements,
662 size_t localNumElements,
663 const Teuchos::RCP<const Teuchos::Comm<int>>& comm)
664 {
665 XPETRA_MONITOR("MapFactory::Build");
666
667#ifdef HAVE_XPETRA_TPETRA
668 if(lib == UseTpetra)
669#if((defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_OPENMP) && defined(HAVE_TPETRA_INST_INT_LONG_LONG))) \
670 || (!defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_SERIAL) && defined(HAVE_TPETRA_INST_INT_LONG_LONG))))
671 return rcp(new TpetraMap<LocalOrdinal, GlobalOrdinal, Node>(
672 Tpetra::createContigMapWithNode<int, GlobalOrdinal, Node>(numElements, localNumElements, comm)));
673#else
674 TEUCHOS_TEST_FOR_EXCEPTION(true,
675 Xpetra::Exceptions::RuntimeError,
676 "Xpetra::MapFactory::createContigMapWithNode: Cannot create Xpetra::TpetraMap, since Tpetra is not "
677 "instantiated on EpetraNode (Serial or OpenMP, depending on configuration) and/or GO=long long");
678#endif
679#endif // HAVE_XPETRA_TPETRA
680
681 if(lib == UseEpetra)
682 {
683 Teuchos::RCP<EpetraMapT<long long, Node>> map;
684 map = Teuchos::rcp(new EpetraMapT<long long, Node>(numElements,
685 localNumElements,
686 0, // index base is zero
687 comm));
688 return map.getConst();
689 }
690
691 XPETRA_FACTORY_END;
692 }
693
694
695
696#endif // #if !defined(XPETRA_EPETRA_NO_64BIT_GLOBAL_INDICES)
697
698
699#endif // #if defined(HAVE_XPETRA_EPETRA)
700
701
702
703} // namespace Xpetra
704
705// EOF
XPETRA_MONITOR
#define XPETRA_MONITOR(funcName)
Definition: Xpetra_ConfigDefs.hpp:132
Xpetra_EpetraMap.hpp
XPETRA_FACTORY_END
#define XPETRA_FACTORY_END
Definition: Xpetra_Exceptions.hpp:77
Teuchos::RCP::getConst
RCP< const T > getConst() const
Teuchos::RCP::is_null
bool is_null() const
Xpetra::Exceptions::RuntimeError
Exception throws to report errors in the internal logical of the program.
Definition: Xpetra_Exceptions.hpp:102
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_EpetraMapFactory.cpp:628
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)
Create a uniform, contiguous Map with a user-specified node.
Definition: Xpetra_EpetraMapFactory.cpp:572
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)
Create a (potentially) non-uniform, contiguous Map with a user-specified node.
Definition: Xpetra_EpetraMapFactory.cpp:660
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)
Create a locally replicated Map with a specified node.
Definition: Xpetra_EpetraMapFactory.cpp:539
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_EpetraMapFactory.cpp:511
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)
Map constructor with Xpetra-defined contiguous uniform distribution.
Definition: Xpetra_MapFactory_def.hpp:78
Xpetra::MapFactory::MapFactory
MapFactory()
Private constructor. This is a static class.
Definition: Xpetra_MapFactory_decl.hpp:72
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_EpetraMapFactory.cpp:603
TEUCHOS_TEST_FOR_EXCEPTION
#define TEUCHOS_TEST_FOR_EXCEPTION(throw_exception_test, Exception, msg)
rcp
TEUCHOS_DEPRECATED RCP< T > rcp(T *p, Dealloc_T dealloc, bool owns_mem)
Xpetra
Xpetra namespace
Definition: Xpetra_BlockedCrsMatrix.hpp:89
Xpetra::global_size_t
size_t global_size_t
Global size_t object.
Definition: Xpetra_ConfigDefs.hpp:174