MueLu  Version of the Day
BelosXpetraAdapterMultiVector.hpp
Go to the documentation of this file.
1 // @HEADER
2 //
3 // ***********************************************************************
4 //
5 // MueLu: A package for multigrid based preconditioning
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 BELOS_XPETRA_ADAPTER_MULTIVECTOR_HPP
47 #define BELOS_XPETRA_ADAPTER_MULTIVECTOR_HPP
48 
49 #include <Xpetra_ConfigDefs.hpp>
50 #include <Xpetra_Exceptions.hpp>
51 #include <Xpetra_MultiVector.hpp>
52 
53 #ifdef HAVE_XPETRA_EPETRA
55 #endif
56 
57 #ifdef HAVE_XPETRA_TPETRA
59 #endif
60 
61 #include <BelosConfigDefs.hpp>
62 #include <BelosTypes.hpp>
63 #include <BelosMultiVecTraits.hpp>
64 #include <BelosOperatorTraits.hpp>
65 
66 #ifdef HAVE_XPETRA_EPETRA
67 #include <BelosEpetraAdapter.hpp>
68 #endif
69 
70 #ifdef HAVE_XPETRA_TPETRA
71 #include <BelosTpetraAdapter.hpp>
72 #include <TpetraCore_config.h>
73 #endif
74 
75 namespace Belos { // should be moved to Belos or Xpetra?
76 
77  using Teuchos::RCP;
78  using Teuchos::rcp;
79 
81  //
82  // Implementation of the Belos::MultiVecTraits for Xpetra::MultiVector.
83  //
85 
90  template<class Scalar, class LO, class GO, class Node>
91  class MultiVecTraits<Scalar, Xpetra::MultiVector<Scalar,LO,GO,Node> > {
92  private:
93 #ifdef HAVE_XPETRA_TPETRA
94  typedef Xpetra::TpetraMultiVector<Scalar,LO,GO,Node> TpetraMultiVector;
95  typedef MultiVecTraits<Scalar,Tpetra::MultiVector<Scalar,LO,GO,Node> > MultiVecTraitsTpetra;
96 #endif
97 
98  public:
99 
100 #ifdef HAVE_BELOS_XPETRA_TIMERS
101  static RCP<Teuchos::Time> mvTimesMatAddMvTimer_, mvTransMvTimer_;
102 #endif
103 
105  {
106 
107 #ifdef HAVE_XPETRA_TPETRA
108  if (mv.getMap()->lib() == Xpetra::UseTpetra)
109  return rcp(new TpetraMultiVector(MultiVecTraitsTpetra::Clone(toTpetra(mv), numvecs)));
110 #endif
111 
114  }
115 
117  {
118 
119 #ifdef HAVE_XPETRA_TPETRA
120  if (mv.getMap()->lib() == Xpetra::UseTpetra)
121  return rcp(new TpetraMultiVector(MultiVecTraitsTpetra::CloneCopy(toTpetra(mv))));
122 #endif
123 
126  }
127 
129  {
130 
131 #ifdef HAVE_XPETRA_TPETRA
132  if (mv.getMap()->lib() == Xpetra::UseTpetra)
133  return rcp(new TpetraMultiVector(MultiVecTraitsTpetra::CloneCopy(toTpetra(mv), index)));
134 #endif
135 
138  }
139 
142  const Teuchos::Range1D& index)
143  {
144 
145 #ifdef HAVE_XPETRA_TPETRA
146  if (mv.getMap()->lib() == Xpetra::UseTpetra)
147  return rcp(new TpetraMultiVector(MultiVecTraitsTpetra::CloneCopy(toTpetra(mv), index)));
148 #endif
149 
152  }
153 
155  {
156 
157 #ifdef HAVE_XPETRA_TPETRA
158  if (mv.getMap()->lib() == Xpetra::UseTpetra)
159  return rcp(new TpetraMultiVector(MultiVecTraitsTpetra::CloneViewNonConst(toTpetra(mv), index)));
160 #endif
161 
164  }
165 
168  const Teuchos::Range1D& index)
169  {
170 
171 #ifdef HAVE_XPETRA_TPETRA
172  if (mv.getMap()->lib() == Xpetra::UseTpetra)
173  return rcp(new TpetraMultiVector(MultiVecTraitsTpetra::CloneViewNonConst(toTpetra(mv), index)));
174 #endif
175 
178  }
179 
181  {
182 
183 #ifdef HAVE_XPETRA_TPETRA
184  if (mv.getMap()->lib() == Xpetra::UseTpetra) {
185  //TODO: double check if the const_cast is safe here.
186  RCP<const Tpetra::MultiVector<Scalar,LO,GO,Node> > r = MultiVecTraitsTpetra::CloneView(toTpetra(mv), index);
187  return rcp(new TpetraMultiVector(Teuchos::rcp_const_cast<Tpetra::MultiVector<Scalar,LO,GO,Node> >(r)));
188  }
189 #endif
190 
193  }
194 
197  const Teuchos::Range1D& index)
198  {
199 
200 #ifdef HAVE_XPETRA_TPETRA
201  if (mv.getMap()->lib() == Xpetra::UseTpetra) {
202  //TODO: double check if the const_cast is safe here.
203  RCP<const Tpetra::MultiVector<Scalar,LO,GO,Node> > r = MultiVecTraitsTpetra::CloneView(toTpetra(mv), index);
204  return rcp(new TpetraMultiVector(Teuchos::rcp_const_cast<Tpetra::MultiVector<Scalar,LO,GO,Node> >(r)));
205  }
206 #endif
207 
210  }
211 
213  {
214 
215 #ifdef HAVE_XPETRA_TPETRA
216  if (mv.getMap()->lib() == Xpetra::UseTpetra)
217  return MultiVecTraitsTpetra::GetGlobalLength(toTpetra(mv));
218 #endif
219 
222  }
223 
225  {
226 
227 #ifdef HAVE_XPETRA_TPETRA
228  if (mv.getMap()->lib() == Xpetra::UseTpetra)
229  return MultiVecTraitsTpetra::GetNumberVecs(toTpetra(mv));
230 #endif
231 
234  }
235 
237  {
238 
239 #ifdef HAVE_XPETRA_TPETRA
240  if (mv.getMap()->lib() == Xpetra::UseTpetra)
241  return MultiVecTraitsTpetra::HasConstantStride(toTpetra(mv));
242 #endif
243 
246  }
247 
248  static void MvTimesMatAddMv( Scalar alpha, const Xpetra::MultiVector<Scalar,LO,GO,Node>& A,
250  Scalar beta, Xpetra::MultiVector<Scalar,LO,GO,Node>& mv )
251  {
252 
253 #ifdef HAVE_BELOS_XPETRA_TIMERS
254  Teuchos::TimeMonitor lcltimer(*mvTimesMatAddMvTimer_);
255 #endif
256 
257 
258 #ifdef HAVE_XPETRA_TPETRA
259  if (mv.getMap()->lib() == Xpetra::UseTpetra) {
260  MultiVecTraitsTpetra::MvTimesMatAddMv(alpha, toTpetra(A), B, beta, toTpetra(mv));
261  return;
262  }
263 #endif
264 
267  }
268 
270  {
271 
272 #ifdef HAVE_XPETRA_TPETRA
273  if (mv.getMap()->lib() == Xpetra::UseTpetra) {
274  MultiVecTraitsTpetra::MvAddMv(alpha, toTpetra(A), beta, toTpetra(B), toTpetra(mv));
275  return;
276  }
277 
278 #endif
279 
282  }
283 
284  static void MvScale ( Xpetra::MultiVector<Scalar,LO,GO,Node>& mv, Scalar alpha )
285  {
286 
287 #ifdef HAVE_XPETRA_TPETRA
288  if (mv.getMap()->lib() == Xpetra::UseTpetra) {
289  MultiVecTraitsTpetra::MvScale(toTpetra(mv), alpha);
290  return;
291  }
292 #endif
293 
296  }
297 
298  static void MvScale ( Xpetra::MultiVector<Scalar,LO,GO,Node>& mv, const std::vector<Scalar>& alphas )
299  {
300 
301 #ifdef HAVE_XPETRA_TPETRA
302  if (mv.getMap()->lib() == Xpetra::UseTpetra) {
303  MultiVecTraitsTpetra::MvScale(toTpetra(mv), alphas);
304  return;
305  }
306 #endif
307 
310  }
311 
313  {
314 
315 #ifdef HAVE_BELOS_XPETRA_TIMERS
316  Teuchos::TimeMonitor lcltimer(*mvTransMvTimer_);
317 #endif
318 
319 #ifdef HAVE_XPETRA_TPETRA
320  if (A.getMap()->lib() == Xpetra::UseTpetra) {
321  MultiVecTraitsTpetra::MvTransMv(alpha, toTpetra(A), toTpetra(B), C);
322  return;
323  }
324 #endif
325 
328  }
329 
330  static void MvDot( const Xpetra::MultiVector<Scalar,LO,GO,Node>& A, const Xpetra::MultiVector<Scalar,LO,GO,Node>& B, std::vector<Scalar> &dots)
331  {
332 
333 #ifdef HAVE_XPETRA_TPETRA
334  if (A.getMap()->lib() == Xpetra::UseTpetra) {
335  MultiVecTraitsTpetra::MvDot(toTpetra(A), toTpetra(B), dots);
336  return;
337  }
338 #endif
339 
342  }
343 
344  static void MvNorm(const Xpetra::MultiVector<Scalar,LO,GO,Node>& mv, std::vector<typename Teuchos::ScalarTraits<Scalar>::magnitudeType> &normvec, NormType type=TwoNorm)
345  {
346 
347 #ifdef HAVE_XPETRA_TPETRA
348  if (mv.getMap()->lib() == Xpetra::UseTpetra) {
349  MultiVecTraitsTpetra::MvNorm(toTpetra(mv), normvec, type);
350  return;
351  }
352 #endif
353 
356  }
357 
358  static void SetBlock( const Xpetra::MultiVector<Scalar,LO,GO,Node>& A, const std::vector<int>& index, Xpetra::MultiVector<Scalar,LO,GO,Node>& mv )
359  {
360 
361 #ifdef HAVE_XPETRA_TPETRA
362  if (mv.getMap()->lib() == Xpetra::UseTpetra) {
363  MultiVecTraitsTpetra::SetBlock(toTpetra(A), index, toTpetra(mv));
364  return;
365  }
366 #endif
367 
370  }
371 
372  static void
374  const Teuchos::Range1D& index,
376  {
377 
378 #ifdef HAVE_XPETRA_TPETRA
379  if (mv.getMap()->lib() == Xpetra::UseTpetra) {
380  MultiVecTraitsTpetra::SetBlock(toTpetra(A), index, toTpetra(mv));
381  return;
382  }
383 #endif
384 
387  }
388 
389  static void
392  {
393 
394 #ifdef HAVE_XPETRA_TPETRA
395  if (mv.getMap()->lib() == Xpetra::UseTpetra) {
396  MultiVecTraitsTpetra::Assign(toTpetra(A), toTpetra(mv));
397  return;
398  }
399 #endif
400 
403  }
404 
406  {
407 
408 #ifdef HAVE_XPETRA_TPETRA
409  if (mv.getMap()->lib() == Xpetra::UseTpetra) {
410  MultiVecTraitsTpetra::MvRandom(toTpetra(mv));
411  return;
412  }
413 #endif
414 
417  }
418 
420  {
421 
422 #ifdef HAVE_XPETRA_TPETRA
423  if (mv.getMap()->lib() == Xpetra::UseTpetra) {
424  MultiVecTraitsTpetra::MvInit(toTpetra(mv), alpha);
425  return;
426  }
427 #endif
428 
431  }
432 
433  static void MvPrint( const Xpetra::MultiVector<Scalar,LO,GO,Node>& mv, std::ostream& os )
434  {
435 
436 #ifdef HAVE_XPETRA_TPETRA
437  if (mv.getMap()->lib() == Xpetra::UseTpetra) {
438  MultiVecTraitsTpetra::MvPrint(toTpetra(mv), os);
439  return;
440  }
441 #endif
442 
445  }
446 
447  };
448 
449 #ifdef HAVE_XPETRA_EPETRA
450 #ifndef EPETRA_NO_32BIT_GLOBAL_INDICES
451  template<>
452  class MultiVecTraits<double, Xpetra::MultiVector<double,int,int,Xpetra::EpetraNode> > {
453  private:
454  typedef double Scalar;
455  typedef int LO;
456  typedef int GO;
457  typedef Xpetra::EpetraNode Node;
458 
459 #ifdef HAVE_XPETRA_TPETRA // TODO check whether Tpetra is instantiated on all template parameters!
460 #if ((defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_OPENMP) && defined(HAVE_TPETRA_INST_INT_INT))) || \
461  (!defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_SERIAL) && defined(HAVE_TPETRA_INST_INT_INT))))
462  typedef Xpetra::TpetraMultiVector<Scalar,LO,GO,Node> TpetraMultiVector;
463  typedef MultiVecTraits<Scalar, Tpetra::MultiVector<Scalar,LO,GO,Node> > MultiVecTraitsTpetra;
464 #endif
465 #endif
466 
467 #ifdef HAVE_XPETRA_EPETRA
469  typedef MultiVecTraits <Scalar, Epetra_MultiVector> MultiVecTraitsEpetra;
470 #endif
471 
472  public:
473 
474 #ifdef HAVE_BELOS_XPETRA_TIMERS
475  static RCP<Teuchos::Time> mvTimesMatAddMvTimer_, mvTransMvTimer_;
476 #endif
477 
478  static RCP<Xpetra::MultiVector<Scalar,LO,GO,Node> > Clone( const Xpetra::MultiVector<Scalar,LO,GO,Node>& mv, const int numvecs )
479  {
480 
481 #ifdef HAVE_XPETRA_TPETRA
482  if (mv.getMap()->lib() == Xpetra::UseTpetra) {
483 #if ((defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_OPENMP) && defined(HAVE_TPETRA_INST_INT_INT))) || \
484  (!defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_SERIAL) && defined(HAVE_TPETRA_INST_INT_INT))))
485  return rcp(new TpetraMultiVector(MultiVecTraitsTpetra::Clone(toTpetra(mv), numvecs)));
486 #endif
487  }
488 #endif
489 
490 #ifdef HAVE_XPETRA_EPETRA
491  if (mv.getMap()->lib() == Xpetra::UseEpetra)
492  return rcp(new EpetraMultiVector(MultiVecTraitsEpetra::Clone(toEpetra(mv), numvecs)));
493 #endif
494 
496  }
497 
498  static RCP<Xpetra::MultiVector<Scalar,LO,GO,Node> > CloneCopy( const Xpetra::MultiVector<Scalar,LO,GO,Node>& mv )
499  {
500 
501 #ifdef HAVE_XPETRA_TPETRA
502  if (mv.getMap()->lib() == Xpetra::UseTpetra) {
503 #if ((defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_OPENMP) && defined(HAVE_TPETRA_INST_INT_INT))) || \
504  (!defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_SERIAL) && defined(HAVE_TPETRA_INST_INT_INT))))
505  return rcp(new TpetraMultiVector(MultiVecTraitsTpetra::CloneCopy(toTpetra(mv))));
506 #endif
507  }
508 #endif
509 
510 #ifdef HAVE_XPETRA_EPETRA
511  if (mv.getMap()->lib() == Xpetra::UseEpetra)
512  return rcp(new EpetraMultiVector(MultiVecTraitsEpetra::CloneCopy(toEpetra(mv))));
513 #endif
514 
516  }
517 
518  static RCP<Xpetra::MultiVector<Scalar,LO,GO,Node> > CloneCopy( const Xpetra::MultiVector<Scalar,LO,GO,Node>& mv, const std::vector<int>& index )
519  {
520 
521 #ifdef HAVE_XPETRA_TPETRA
522  if (mv.getMap()->lib() == Xpetra::UseTpetra) {
523 #if ((defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_OPENMP) && defined(HAVE_TPETRA_INST_INT_INT))) || \
524  (!defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_SERIAL) && defined(HAVE_TPETRA_INST_INT_INT))))
525  return rcp(new TpetraMultiVector(MultiVecTraitsTpetra::CloneCopy(toTpetra(mv), index)));
526 #endif
527  }
528 #endif
529 
530 #ifdef HAVE_XPETRA_EPETRA
531  if (mv.getMap()->lib() == Xpetra::UseEpetra)
532  return rcp(new EpetraMultiVector(MultiVecTraitsEpetra::CloneCopy(toEpetra(mv), index)));
533 #endif
534 
536  }
537 
538  static RCP<Xpetra::MultiVector<Scalar,LO,GO,Node> >
539  CloneCopy (const Xpetra::MultiVector<Scalar,LO,GO,Node>& mv,
540  const Teuchos::Range1D& index)
541  {
542 
543 #ifdef HAVE_XPETRA_TPETRA
544  if (mv.getMap()->lib() == Xpetra::UseTpetra) {
545 #if ((defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_OPENMP) && defined(HAVE_TPETRA_INST_INT_INT))) || \
546  (!defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_SERIAL) && defined(HAVE_TPETRA_INST_INT_INT))))
547  return rcp(new TpetraMultiVector(MultiVecTraitsTpetra::CloneCopy(toTpetra(mv), index)));
548 #endif
549  }
550 #endif
551 
552 #ifdef HAVE_XPETRA_EPETRA
553  if (mv.getMap()->lib() == Xpetra::UseEpetra)
554  return rcp(new EpetraMultiVector(MultiVecTraitsEpetra::CloneCopy(toEpetra(mv), index)));
555 #endif
556 
558  }
559 
560  static RCP<Xpetra::MultiVector<Scalar,LO,GO,Node> > CloneViewNonConst( Xpetra::MultiVector<Scalar,LO,GO,Node>& mv, const std::vector<int>& index )
561  {
562 
563 #ifdef HAVE_XPETRA_TPETRA
564  if (mv.getMap()->lib() == Xpetra::UseTpetra) {
565 #if ((defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_OPENMP) && defined(HAVE_TPETRA_INST_INT_INT))) || \
566  (!defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_SERIAL) && defined(HAVE_TPETRA_INST_INT_INT))))
567  return rcp(new TpetraMultiVector(MultiVecTraitsTpetra::CloneViewNonConst(toTpetra(mv), index)));
568 #endif
569  }
570 #endif
571 
572 #ifdef HAVE_XPETRA_EPETRA
573  if (mv.getMap()->lib() == Xpetra::UseEpetra)
574  return rcp(new EpetraMultiVector(MultiVecTraitsEpetra::CloneViewNonConst(toEpetra(mv), index)));
575 #endif
576 
578  }
579 
580  static RCP<Xpetra::MultiVector<Scalar,LO,GO,Node> >
581  CloneViewNonConst(Xpetra::MultiVector<Scalar,LO,GO,Node>& mv,
582  const Teuchos::Range1D& index)
583  {
584 
585 #ifdef HAVE_MUELUA_TPETRA
586  if (mv.getMap()->lib() == Xpetra::UseTpetra) {
587 #if ((defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_OPENMP) && defined(HAVE_TPETRA_INST_INT_INT))) || \
588  (!defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_SERIAL) && defined(HAVE_TPETRA_INST_INT_INT))))
589  return rcp(new TpetraMultiVector(MultiVecTraitsTpetra::CloneViewNonConst(toTpetra(mv), index)));
590 #endif
591  }
592 #endif
593 
594 #ifdef HAVE_XPETRA_EPETRA
595  if (mv.getMap()->lib() == Xpetra::UseEpetra)
596  return rcp(new EpetraMultiVector(MultiVecTraitsEpetra::CloneViewNonConst(toEpetra(mv), index)));
597 #endif
598 
600  }
601 
602  static RCP<const Xpetra::MultiVector<Scalar,LO,GO,Node> > CloneView(const Xpetra::MultiVector<Scalar,LO,GO,Node>& mv, const std::vector<int>& index )
603  {
604 
605 #ifdef HAVE_XPETRA_TPETRA
606  if (mv.getMap()->lib() == Xpetra::UseTpetra) {
607 #if ((defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_OPENMP) && defined(HAVE_TPETRA_INST_INT_INT))) || \
608  (!defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_SERIAL) && defined(HAVE_TPETRA_INST_INT_INT))))
609  //TODO: double check if the const_cast is safe here.
610  RCP<const Tpetra::MultiVector<Scalar,LO,GO,Node> > r = MultiVecTraitsTpetra::CloneView(toTpetra(mv), index);
611  return rcp(new TpetraMultiVector(Teuchos::rcp_const_cast<Tpetra::MultiVector<Scalar,LO,GO,Node> >(r)));
612 #endif
613  }
614 #endif
615 
616 #ifdef HAVE_XPETRA_EPETRA
617  if (mv.getMap()->lib() == Xpetra::UseEpetra) {
618  //TODO: double check if the const_cast is safe here.
619  RCP<const Epetra_MultiVector > r = MultiVecTraitsEpetra::CloneView(toEpetra(mv), index);
620  return rcp(new EpetraMultiVector(Teuchos::rcp_const_cast<Epetra_MultiVector>(r)));
621  }
622 #endif
623 
625  }
626 
627  static RCP<const Xpetra::MultiVector<Scalar,LO,GO,Node> >
628  CloneView (const Xpetra::MultiVector<Scalar,LO,GO,Node>& mv,
629  const Teuchos::Range1D& index)
630  {
631 
632 #ifdef HAVE_XPETRA_TPETRA
633  if (mv.getMap()->lib() == Xpetra::UseTpetra) {
634 #if ((defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_OPENMP) && defined(HAVE_TPETRA_INST_INT_INT))) || \
635  (!defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_SERIAL) && defined(HAVE_TPETRA_INST_INT_INT))))
636  //TODO: double check if the const_cast is safe here.
637  RCP<const Tpetra::MultiVector<Scalar,LO,GO,Node> > r = MultiVecTraitsTpetra::CloneView(toTpetra(mv), index);
638  return rcp(new TpetraMultiVector(Teuchos::rcp_const_cast<Tpetra::MultiVector<Scalar,LO,GO,Node> >(r)));
639 #endif
640  }
641 #endif
642 
643 #ifdef HAVE_XPETRA_EPETRA
644  if (mv.getMap()->lib() == Xpetra::UseEpetra) {
645  //TODO: double check if the const_cast is safe here.
646  RCP<const Epetra_MultiVector > r = MultiVecTraitsEpetra::CloneView(toEpetra(mv), index);
647  return rcp(new EpetraMultiVector(Teuchos::rcp_const_cast<Epetra_MultiVector>(r)));
648  }
649 #endif
650 
652  }
653 
654  static ptrdiff_t GetGlobalLength( const Xpetra::MultiVector<Scalar,LO,GO,Node>& mv )
655  {
656 
657 #ifdef HAVE_XPETRA_TPETRA
658  if (mv.getMap()->lib() == Xpetra::UseTpetra) {
659 #if ((defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_OPENMP) && defined(HAVE_TPETRA_INST_INT_INT))) || \
660  (!defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_SERIAL) && defined(HAVE_TPETRA_INST_INT_INT))))
661  return MultiVecTraitsTpetra::GetGlobalLength(toTpetra(mv));
662 #endif
663  }
664 #endif
665 
666 #ifdef HAVE_XPETRA_EPETRA
667  if (mv.getMap()->lib() == Xpetra::UseEpetra)
668  return MultiVecTraitsEpetra::GetGlobalLength(toEpetra(mv));
669 #endif
670 
672  }
673 
674  static int GetNumberVecs( const Xpetra::MultiVector<Scalar,LO,GO,Node>& mv )
675  {
676 
677 #ifdef HAVE_XPETRA_TPETRA
678  if (mv.getMap()->lib() == Xpetra::UseTpetra) {
679 #if ((defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_OPENMP) && defined(HAVE_TPETRA_INST_INT_INT))) || \
680  (!defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_SERIAL) && defined(HAVE_TPETRA_INST_INT_INT))))
681  return MultiVecTraitsTpetra::GetNumberVecs(toTpetra(mv));
682 #endif
683  }
684 #endif
685 
686 #ifdef HAVE_XPETRA_EPETRA
687  if (mv.getMap()->lib() == Xpetra::UseEpetra)
688  return MultiVecTraitsEpetra::GetNumberVecs(toEpetra(mv));
689 #endif
690 
692  }
693 
694  static bool HasConstantStride( const Xpetra::MultiVector<Scalar,LO,GO,Node>& mv )
695  {
696 
697 #ifdef HAVE_XPETRA_TPETRA
698  if (mv.getMap()->lib() == Xpetra::UseTpetra) {
699 #if ((defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_OPENMP) && defined(HAVE_TPETRA_INST_INT_INT))) || \
700  (!defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_SERIAL) && defined(HAVE_TPETRA_INST_INT_INT))))
701  return MultiVecTraitsTpetra::HasConstantStride(toTpetra(mv));
702 #endif
703  }
704 #endif
705 
706 #ifdef HAVE_XPETRA_EPETRA
707  if (mv.getMap()->lib() == Xpetra::UseEpetra)
708  return MultiVecTraitsEpetra::HasConstantStride(toEpetra(mv));
709 #endif
710 
712  }
713 
714  static void MvTimesMatAddMv( Scalar alpha, const Xpetra::MultiVector<Scalar,LO,GO,Node>& A,
716  Scalar beta, Xpetra::MultiVector<Scalar,LO,GO,Node>& mv )
717  {
718 
719 #ifdef HAVE_BELOS_XPETRA_TIMERS
720  Teuchos::TimeMonitor lcltimer(*mvTimesMatAddMvTimer_);
721 #endif
722 
723 #ifdef HAVE_XPETRA_TPETRA
724  if (mv.getMap()->lib() == Xpetra::UseTpetra) {
725 #if ((defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_OPENMP) && defined(HAVE_TPETRA_INST_INT_INT))) || \
726  (!defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_SERIAL) && defined(HAVE_TPETRA_INST_INT_INT))))
727  MultiVecTraitsTpetra::MvTimesMatAddMv(alpha, toTpetra(A), B, beta, toTpetra(mv));
728  return;
729 #endif
730  }
731 #endif
732 
733 #ifdef HAVE_XPETRA_EPETRA
734  if (mv.getMap()->lib() == Xpetra::UseEpetra) {
735  MultiVecTraitsEpetra::MvTimesMatAddMv(alpha, toEpetra(A), B, beta, toEpetra(mv));
736  return;
737  }
738 #endif
739 
741  }
742 
743  static void MvAddMv( Scalar alpha, const Xpetra::MultiVector<Scalar,LO,GO,Node>& A, Scalar beta, const Xpetra::MultiVector<Scalar,LO,GO,Node>& B, Xpetra::MultiVector<Scalar,LO,GO,Node>& mv )
744  {
745 
746 #ifdef HAVE_XPETRA_TPETRA
747  if (mv.getMap()->lib() == Xpetra::UseTpetra) {
748 #if ((defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_OPENMP) && defined(HAVE_TPETRA_INST_INT_INT))) || \
749  (!defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_SERIAL) && defined(HAVE_TPETRA_INST_INT_INT))))
750  MultiVecTraitsTpetra::MvAddMv(alpha, toTpetra(A), beta, toTpetra(B), toTpetra(mv));
751  return;
752 #endif
753  }
754 #endif
755 
756 #ifdef HAVE_XPETRA_EPETRA
757  if (mv.getMap()->lib() == Xpetra::UseEpetra) {
758  MultiVecTraitsEpetra::MvAddMv(alpha, toEpetra(A), beta, toEpetra(B), toEpetra(mv));
759  return;
760  }
761 #endif
762 
764  }
765 
766  static void MvScale ( Xpetra::MultiVector<Scalar,LO,GO,Node>& mv, Scalar alpha )
767  {
768 
769 #ifdef HAVE_XPETRA_TPETRA
770  if (mv.getMap()->lib() == Xpetra::UseTpetra) {
771 #if ((defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_OPENMP) && defined(HAVE_TPETRA_INST_INT_INT))) || \
772  (!defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_SERIAL) && defined(HAVE_TPETRA_INST_INT_INT))))
773  MultiVecTraitsTpetra::MvScale(toTpetra(mv), alpha);
774  return;
775 #endif
776  }
777 #endif
778 
779 #ifdef HAVE_XPETRA_EPETRA
780  if (mv.getMap()->lib() == Xpetra::UseEpetra) {
781  MultiVecTraitsEpetra::MvScale(toEpetra(mv), alpha);
782  return;
783  }
784 #endif
785 
787  }
788 
789  static void MvScale ( Xpetra::MultiVector<Scalar,LO,GO,Node>& mv, const std::vector<Scalar>& alphas )
790  {
791 
792 #ifdef HAVE_XPETRA_TPETRA
793  if (mv.getMap()->lib() == Xpetra::UseTpetra) {
794 #if ((defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_OPENMP) && defined(HAVE_TPETRA_INST_INT_INT))) || \
795  (!defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_SERIAL) && defined(HAVE_TPETRA_INST_INT_INT))))
796  MultiVecTraitsTpetra::MvScale(toTpetra(mv), alphas);
797  return;
798 #endif
799  }
800 #endif
801 
802 #ifdef HAVE_XPETRA_EPETRA
803  if (mv.getMap()->lib() == Xpetra::UseEpetra) {
804  MultiVecTraitsEpetra::MvScale(toEpetra(mv), alphas);
805  return;
806  }
807 #endif
808 
810  }
811 
813  {
814 
815 #ifdef HAVE_BELOS_XPETRA_TIMERS
816  Teuchos::TimeMonitor lcltimer(*mvTransMvTimer_);
817 #endif
818 
819 #ifdef HAVE_XPETRA_TPETRA
820  if (A.getMap()->lib() == Xpetra::UseTpetra) {
821 #if ((defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_OPENMP) && defined(HAVE_TPETRA_INST_INT_INT))) || \
822  (!defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_SERIAL) && defined(HAVE_TPETRA_INST_INT_INT))))
823  MultiVecTraitsTpetra::MvTransMv(alpha, toTpetra(A), toTpetra(B), C);
824  return;
825 #endif
826  }
827 #endif
828 
829 #ifdef HAVE_XPETRA_EPETRA
830  if (A.getMap()->lib() == Xpetra::UseEpetra) {
831  MultiVecTraitsEpetra::MvTransMv(alpha, toEpetra(A), toEpetra(B), C);
832  return;
833  }
834 #endif
835 
837  }
838 
839  static void MvDot( const Xpetra::MultiVector<Scalar,LO,GO,Node>& A, const Xpetra::MultiVector<Scalar,LO,GO,Node>& B, std::vector<Scalar> &dots)
840  {
841 
842 #ifdef HAVE_XPETRA_TPETRA
843  if (A.getMap()->lib() == Xpetra::UseTpetra) {
844 #if ((defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_OPENMP) && defined(HAVE_TPETRA_INST_INT_INT))) || \
845  (!defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_SERIAL) && defined(HAVE_TPETRA_INST_INT_INT))))
846  MultiVecTraitsTpetra::MvDot(toTpetra(A), toTpetra(B), dots);
847  return;
848 #endif
849  }
850 #endif
851 
852 #ifdef HAVE_XPETRA_EPETRA
853  if (A.getMap()->lib() == Xpetra::UseEpetra) {
854  MultiVecTraitsEpetra::MvDot(toEpetra(A), toEpetra(B), dots);
855  return;
856  }
857 #endif
858 
860  }
861 
862  static void MvNorm(const Xpetra::MultiVector<Scalar,LO,GO,Node>& mv, std::vector<Teuchos::ScalarTraits<Scalar>::magnitudeType> &normvec, NormType type=TwoNorm)
863  {
864 
865 #ifdef HAVE_XPETRA_TPETRA
866  if (mv.getMap()->lib() == Xpetra::UseTpetra) {
867 #if ((defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_OPENMP) && defined(HAVE_TPETRA_INST_INT_INT))) || \
868  (!defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_SERIAL) && defined(HAVE_TPETRA_INST_INT_INT))))
869  MultiVecTraitsTpetra::MvNorm(toTpetra(mv), normvec, type);
870  return;
871 #endif
872  }
873 #endif
874 
875 #ifdef HAVE_XPETRA_EPETRA
876  if (mv.getMap()->lib() == Xpetra::UseEpetra) {
877  MultiVecTraitsEpetra::MvNorm(toEpetra(mv), normvec, type);
878  return;
879  }
880 #endif
881 
883  }
884 
885  static void SetBlock( const Xpetra::MultiVector<Scalar,LO,GO,Node>& A, const std::vector<int>& index, Xpetra::MultiVector<Scalar,LO,GO,Node>& mv )
886  {
887 
888 #ifdef HAVE_XPETRA_TPETRA
889  if (mv.getMap()->lib() == Xpetra::UseTpetra) {
890 #if ((defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_OPENMP) && defined(HAVE_TPETRA_INST_INT_INT))) || \
891  (!defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_SERIAL) && defined(HAVE_TPETRA_INST_INT_INT))))
892  MultiVecTraitsTpetra::SetBlock(toTpetra(A), index, toTpetra(mv));
893  return;
894 #endif
895  }
896 #endif
897 
898 #ifdef HAVE_XPETRA_EPETRA
899  if (mv.getMap()->lib() == Xpetra::UseEpetra) {
900  MultiVecTraitsEpetra::SetBlock(toEpetra(A), index, toEpetra(mv));
901  return;
902  }
903 #endif
904 
906  }
907 
908  static void
909  SetBlock (const Xpetra::MultiVector<Scalar,LO,GO,Node>& A,
910  const Teuchos::Range1D& index,
912  {
913 
914 #ifdef HAVE_XPETRA_TPETRA
915  if (mv.getMap()->lib() == Xpetra::UseTpetra) {
916 #if ((defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_OPENMP) && defined(HAVE_TPETRA_INST_INT_INT))) || \
917  (!defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_SERIAL) && defined(HAVE_TPETRA_INST_INT_INT))))
918  MultiVecTraitsTpetra::SetBlock(toTpetra(A), index, toTpetra(mv));
919  return;
920 #endif
921  }
922 #endif
923 
924 #ifdef HAVE_XPETRA_EPETRA
925  if (mv.getMap()->lib() == Xpetra::UseEpetra) {
926  MultiVecTraitsEpetra::SetBlock(toEpetra(A), index, toEpetra(mv));
927  return;
928  }
929 #endif
930 
932  }
933 
934  static void
937  {
938 
939 #ifdef HAVE_XPETRA_TPETRA
940  if (mv.getMap()->lib() == Xpetra::UseTpetra) {
941 #if ((defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_OPENMP) && defined(HAVE_TPETRA_INST_INT_INT))) || \
942  (!defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_SERIAL) && defined(HAVE_TPETRA_INST_INT_INT))))
943  MultiVecTraitsTpetra::Assign(toTpetra(A), toTpetra(mv));
944  return;
945 #endif
946  }
947 #endif
948 
949 #ifdef HAVE_XPETRA_EPETRA
950  if (mv.getMap()->lib() == Xpetra::UseEpetra) {
951  MultiVecTraitsEpetra::Assign(toEpetra(A), toEpetra(mv));
952  return;
953  }
954 #endif
955 
957  }
958 
959  static void MvRandom( Xpetra::MultiVector<Scalar,LO,GO,Node>& mv )
960  {
961 
962 #ifdef HAVE_XPETRA_TPETRA
963  if (mv.getMap()->lib() == Xpetra::UseTpetra) {
964 #if ((defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_OPENMP) && defined(HAVE_TPETRA_INST_INT_INT))) || \
965  (!defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_SERIAL) && defined(HAVE_TPETRA_INST_INT_INT))))
966  MultiVecTraitsTpetra::MvRandom(toTpetra(mv));
967  return;
968 #endif
969  }
970 #endif
971 
972 #ifdef HAVE_XPETRA_EPETRA
973  if (mv.getMap()->lib() == Xpetra::UseEpetra) {
974  MultiVecTraitsEpetra::MvRandom(toEpetra(mv));
975  return;
976  }
977 #endif
978 
980  }
981 
982  static void MvInit( Xpetra::MultiVector<Scalar,LO,GO,Node>& mv, Scalar alpha = Teuchos::ScalarTraits<Scalar>::zero() )
983  {
984 
985 #ifdef HAVE_XPETRA_TPETRA
986  if (mv.getMap()->lib() == Xpetra::UseTpetra) {
987 #if ((defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_OPENMP) && defined(HAVE_TPETRA_INST_INT_INT))) || \
988  (!defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_SERIAL) && defined(HAVE_TPETRA_INST_INT_INT))))
989  MultiVecTraitsTpetra::MvInit(toTpetra(mv), alpha);
990  return;
991 #endif
992  }
993 #endif
994 
995 #ifdef HAVE_XPETRA_EPETRA
996  if (mv.getMap()->lib() == Xpetra::UseEpetra) {
997  MultiVecTraitsEpetra::MvInit(toEpetra(mv), alpha);
998  return;
999  }
1000 #endif
1001 
1003  }
1004 
1005  static void MvPrint( const Xpetra::MultiVector<Scalar,LO,GO,Node>& mv, std::ostream& os )
1006  {
1007 
1008 #ifdef HAVE_XPETRA_TPETRA
1009  if (mv.getMap()->lib() == Xpetra::UseTpetra) {
1010 #if ((defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_OPENMP) && defined(HAVE_TPETRA_INST_INT_INT))) || \
1011  (!defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_SERIAL) && defined(HAVE_TPETRA_INST_INT_INT))))
1012  MultiVecTraitsTpetra::MvPrint(toTpetra(mv), os);
1013  return;
1014 #endif
1015  }
1016 #endif
1017 
1018 #ifdef HAVE_XPETRA_EPETRA
1019  if (mv.getMap()->lib() == Xpetra::UseEpetra) {
1020  MultiVecTraitsEpetra::MvPrint(toEpetra(mv), os);
1021  return;
1022  }
1023 #endif
1024 
1026  }
1027  };
1028 #endif // #ifndef EPETRA_NO_32BIT_GLOBAL_INDICES
1029 #endif // HAVE_XPETRA_EPETRA
1030 
1031 
1032 #ifdef HAVE_XPETRA_EPETRA
1033 #ifndef EPETRA_NO_64BIT_GLOBAL_INDICES
1034  template<>
1035  class MultiVecTraits<double, Xpetra::MultiVector<double,int,long long,Xpetra::EpetraNode> > {
1036  private:
1037  typedef double Scalar;
1038  typedef int LO;
1039  typedef long long GO;
1040  typedef Xpetra::EpetraNode Node;
1041 
1042 #ifdef HAVE_XPETRA_TPETRA // TODO check whether Tpetra is instantiated on all template parameters!
1043 #if ((defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_OPENMP) && defined(HAVE_TPETRA_INST_INT_LONG_LONG))) || \
1044  (!defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_SERIAL) && defined(HAVE_TPETRA_INST_INT_LONG_LONG))))
1045  typedef Xpetra::TpetraMultiVector<Scalar,LO,GO,Node> TpetraMultiVector;
1046  typedef MultiVecTraits<Scalar, Tpetra::MultiVector<Scalar,LO,GO,Node> > MultiVecTraitsTpetra;
1047 #endif
1048 #endif
1049 
1050 #ifdef HAVE_XPETRA_EPETRA
1052  typedef MultiVecTraits <Scalar, Epetra_MultiVector> MultiVecTraitsEpetra;
1053 #endif
1054 
1055  public:
1056 
1057 #ifdef HAVE_BELOS_XPETRA_TIMERS
1058  static RCP<Teuchos::Time> mvTimesMatAddMvTimer_, mvTransMvTimer_;
1059 #endif
1060 
1061  static RCP<Xpetra::MultiVector<Scalar,LO,GO,Node> > Clone( const Xpetra::MultiVector<Scalar,LO,GO,Node>& mv, const int numvecs )
1062  {
1063 
1064 #ifdef HAVE_XPETRA_TPETRA
1065  if (mv.getMap()->lib() == Xpetra::UseTpetra) {
1066 #if ((defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_OPENMP) && defined(HAVE_TPETRA_INST_INT_LONG_LONG))) || \
1067  (!defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_SERIAL) && defined(HAVE_TPETRA_INST_INT_LONG_LONG))))
1068  return rcp(new TpetraMultiVector(MultiVecTraitsTpetra::Clone(toTpetra(mv), numvecs)));
1069 #endif
1070  }
1071 #endif
1072 
1073 #ifdef HAVE_XPETRA_EPETRA
1074  if (mv.getMap()->lib() == Xpetra::UseEpetra)
1075  return rcp(new EpetraMultiVector(MultiVecTraitsEpetra::Clone(toEpetra(mv), numvecs)));
1076 #endif
1077 
1079  }
1080 
1081  static RCP<Xpetra::MultiVector<Scalar,LO,GO,Node> > CloneCopy( const Xpetra::MultiVector<Scalar,LO,GO,Node>& mv )
1082  {
1083 
1084 #ifdef HAVE_XPETRA_TPETRA
1085  if (mv.getMap()->lib() == Xpetra::UseTpetra) {
1086 #if ((defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_OPENMP) && defined(HAVE_TPETRA_INST_INT_LONG_LONG))) || \
1087  (!defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_SERIAL) && defined(HAVE_TPETRA_INST_INT_LONG_LONG))))
1088  return rcp(new TpetraMultiVector(MultiVecTraitsTpetra::CloneCopy(toTpetra(mv))));
1089 #endif
1090  }
1091 #endif
1092 
1093 #ifdef HAVE_XPETRA_EPETRA
1094  if (mv.getMap()->lib() == Xpetra::UseEpetra)
1095  return rcp(new EpetraMultiVector(MultiVecTraitsEpetra::CloneCopy(toEpetra(mv))));
1096 #endif
1097 
1099  }
1100 
1101  static RCP<Xpetra::MultiVector<Scalar,LO,GO,Node> > CloneCopy( const Xpetra::MultiVector<Scalar,LO,GO,Node>& mv, const std::vector<int>& index )
1102  {
1103 
1104 #ifdef HAVE_XPETRA_TPETRA
1105  if (mv.getMap()->lib() == Xpetra::UseTpetra) {
1106 #if ((defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_OPENMP) && defined(HAVE_TPETRA_INST_INT_LONG_LONG))) || \
1107  (!defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_SERIAL) && defined(HAVE_TPETRA_INST_INT_LONG_LONG))))
1108  return rcp(new TpetraMultiVector(MultiVecTraitsTpetra::CloneCopy(toTpetra(mv), index)));
1109 #endif
1110  }
1111 #endif
1112 
1113 #ifdef HAVE_XPETRA_EPETRA
1114  if (mv.getMap()->lib() == Xpetra::UseEpetra)
1115  return rcp(new EpetraMultiVector(MultiVecTraitsEpetra::CloneCopy(toEpetra(mv), index)));
1116 #endif
1117 
1119  }
1120 
1121  static RCP<Xpetra::MultiVector<Scalar,LO,GO,Node> >
1122  CloneCopy (const Xpetra::MultiVector<Scalar,LO,GO,Node>& mv,
1123  const Teuchos::Range1D& index)
1124  {
1125 
1126 #ifdef HAVE_XPETRA_TPETRA
1127  if (mv.getMap()->lib() == Xpetra::UseTpetra) {
1128 #if ((defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_OPENMP) && defined(HAVE_TPETRA_INST_INT_LONG_LONG))) || \
1129  (!defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_SERIAL) && defined(HAVE_TPETRA_INST_INT_LONG_LONG))))
1130  return rcp(new TpetraMultiVector(MultiVecTraitsTpetra::CloneCopy(toTpetra(mv), index)));
1131 #endif
1132  }
1133 #endif
1134 
1135 #ifdef HAVE_XPETRA_EPETRA
1136  if (mv.getMap()->lib() == Xpetra::UseEpetra)
1137  return rcp(new EpetraMultiVector(MultiVecTraitsEpetra::CloneCopy(toEpetra(mv), index)));
1138 #endif
1139 
1141  }
1142 
1143  static RCP<Xpetra::MultiVector<Scalar,LO,GO,Node> > CloneViewNonConst( Xpetra::MultiVector<Scalar,LO,GO,Node>& mv, const std::vector<int>& index )
1144  {
1145 
1146 #ifdef HAVE_XPETRA_TPETRA
1147  if (mv.getMap()->lib() == Xpetra::UseTpetra) {
1148 #if ((defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_OPENMP) && defined(HAVE_TPETRA_INST_INT_LONG_LONG))) || \
1149  (!defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_SERIAL) && defined(HAVE_TPETRA_INST_INT_LONG_LONG))))
1150  return rcp(new TpetraMultiVector(MultiVecTraitsTpetra::CloneViewNonConst(toTpetra(mv), index)));
1151 #endif
1152  }
1153 #endif
1154 
1155 #ifdef HAVE_XPETRA_EPETRA
1156  if (mv.getMap()->lib() == Xpetra::UseEpetra)
1157  return rcp(new EpetraMultiVector(MultiVecTraitsEpetra::CloneViewNonConst(toEpetra(mv), index)));
1158 #endif
1159 
1161  }
1162 
1163  static RCP<Xpetra::MultiVector<Scalar,LO,GO,Node> >
1164  CloneViewNonConst(Xpetra::MultiVector<Scalar,LO,GO,Node>& mv,
1165  const Teuchos::Range1D& index)
1166  {
1167 
1168 #ifdef HAVE_MUELUA_TPETRA
1169  if (mv.getMap()->lib() == Xpetra::UseTpetra) {
1170 #if ((defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_OPENMP) && defined(HAVE_TPETRA_INST_INT_LONG_LONG))) || \
1171  (!defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_SERIAL) && defined(HAVE_TPETRA_INST_INT_LONG_LONG))))
1172  return rcp(new TpetraMultiVector(MultiVecTraitsTpetra::CloneViewNonConst(toTpetra(mv), index)));
1173 #endif
1174  }
1175 #endif
1176 
1177 #ifdef HAVE_XPETRA_EPETRA
1178  if (mv.getMap()->lib() == Xpetra::UseEpetra)
1179  return rcp(new EpetraMultiVector(MultiVecTraitsEpetra::CloneViewNonConst(toEpetra(mv), index)));
1180 #endif
1181 
1183  }
1184 
1185  static RCP<const Xpetra::MultiVector<Scalar,LO,GO,Node> > CloneView(const Xpetra::MultiVector<Scalar,LO,GO,Node>& mv, const std::vector<int>& index )
1186  {
1187 
1188 #ifdef HAVE_XPETRA_TPETRA
1189  if (mv.getMap()->lib() == Xpetra::UseTpetra) {
1190 #if ((defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_OPENMP) && defined(HAVE_TPETRA_INST_INT_LONG_LONG))) || \
1191  (!defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_SERIAL) && defined(HAVE_TPETRA_INST_INT_LONG_LONG))))
1192  //TODO: double check if the const_cast is safe here.
1193  RCP<const Tpetra::MultiVector<Scalar,LO,GO,Node> > r = MultiVecTraitsTpetra::CloneView(toTpetra(mv), index);
1194  return rcp(new TpetraMultiVector(Teuchos::rcp_const_cast<Tpetra::MultiVector<Scalar,LO,GO,Node> >(r)));
1195 #endif
1196  }
1197 #endif
1198 
1199 #ifdef HAVE_XPETRA_EPETRA
1200  if (mv.getMap()->lib() == Xpetra::UseEpetra) {
1201  //TODO: double check if the const_cast is safe here.
1202  RCP<const Epetra_MultiVector > r = MultiVecTraitsEpetra::CloneView(toEpetra(mv), index);
1203  return rcp(new EpetraMultiVector(Teuchos::rcp_const_cast<Epetra_MultiVector>(r)));
1204  }
1205 #endif
1206 
1208  }
1209 
1210  static RCP<const Xpetra::MultiVector<Scalar,LO,GO,Node> >
1211  CloneView (const Xpetra::MultiVector<Scalar,LO,GO,Node>& mv,
1212  const Teuchos::Range1D& index)
1213  {
1214 
1215 #ifdef HAVE_XPETRA_TPETRA
1216  if (mv.getMap()->lib() == Xpetra::UseTpetra) {
1217 #if ((defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_OPENMP) && defined(HAVE_TPETRA_INST_INT_LONG_LONG))) || \
1218  (!defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_SERIAL) && defined(HAVE_TPETRA_INST_INT_LONG_LONG))))
1219  //TODO: double check if the const_cast is safe here.
1220  RCP<const Tpetra::MultiVector<Scalar,LO,GO,Node> > r = MultiVecTraitsTpetra::CloneView(toTpetra(mv), index);
1221  return rcp(new TpetraMultiVector(Teuchos::rcp_const_cast<Tpetra::MultiVector<Scalar,LO,GO,Node> >(r)));
1222 #endif
1223  }
1224 #endif
1225 
1226 #ifdef HAVE_XPETRA_EPETRA
1227  if (mv.getMap()->lib() == Xpetra::UseEpetra) {
1228  //TODO: double check if the const_cast is safe here.
1229  RCP<const Epetra_MultiVector > r = MultiVecTraitsEpetra::CloneView(toEpetra(mv), index);
1230  return rcp(new EpetraMultiVector(Teuchos::rcp_const_cast<Epetra_MultiVector>(r)));
1231  }
1232 #endif
1233 
1235  }
1236 
1237  static ptrdiff_t GetGlobalLength( const Xpetra::MultiVector<Scalar,LO,GO,Node>& mv )
1238  {
1239 
1240 #ifdef HAVE_XPETRA_TPETRA
1241  if (mv.getMap()->lib() == Xpetra::UseTpetra) {
1242 #if ((defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_OPENMP) && defined(HAVE_TPETRA_INST_INT_LONG_LONG))) || \
1243  (!defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_SERIAL) && defined(HAVE_TPETRA_INST_INT_LONG_LONG))))
1244  return MultiVecTraitsTpetra::GetGlobalLength(toTpetra(mv));
1245 #endif
1246  }
1247 #endif
1248 
1249 #ifdef HAVE_XPETRA_EPETRA
1250  if (mv.getMap()->lib() == Xpetra::UseEpetra)
1251  return MultiVecTraitsEpetra::GetGlobalLength(toEpetra(mv));
1252 #endif
1253 
1255  }
1256 
1257  static int GetNumberVecs( const Xpetra::MultiVector<Scalar,LO,GO,Node>& mv )
1258  {
1259 
1260 #ifdef HAVE_XPETRA_TPETRA
1261  if (mv.getMap()->lib() == Xpetra::UseTpetra) {
1262 #if ((defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_OPENMP) && defined(HAVE_TPETRA_INST_INT_LONG_LONG))) || \
1263  (!defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_SERIAL) && defined(HAVE_TPETRA_INST_INT_LONG_LONG))))
1264  return MultiVecTraitsTpetra::GetNumberVecs(toTpetra(mv));
1265 #endif
1266  }
1267 #endif
1268 
1269 #ifdef HAVE_XPETRA_EPETRA
1270  if (mv.getMap()->lib() == Xpetra::UseEpetra)
1271  return MultiVecTraitsEpetra::GetNumberVecs(toEpetra(mv));
1272 #endif
1273 
1275  }
1276 
1277  static bool HasConstantStride( const Xpetra::MultiVector<Scalar,LO,GO,Node>& mv )
1278  {
1279 
1280 #ifdef HAVE_XPETRA_TPETRA
1281  if (mv.getMap()->lib() == Xpetra::UseTpetra) {
1282 #if ((defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_OPENMP) && defined(HAVE_TPETRA_INST_INT_LONG_LONG))) || \
1283  (!defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_SERIAL) && defined(HAVE_TPETRA_INST_INT_LONG_LONG))))
1284  return MultiVecTraitsTpetra::HasConstantStride(toTpetra(mv));
1285 #endif
1286  }
1287 #endif
1288 
1289 #ifdef HAVE_XPETRA_EPETRA
1290  if (mv.getMap()->lib() == Xpetra::UseEpetra)
1291  return MultiVecTraitsEpetra::HasConstantStride(toEpetra(mv));
1292 #endif
1293 
1295  }
1296 
1297  static void MvTimesMatAddMv( Scalar alpha, const Xpetra::MultiVector<Scalar,LO,GO,Node>& A,
1299  Scalar beta, Xpetra::MultiVector<Scalar,LO,GO,Node>& mv )
1300  {
1301 
1302 #ifdef HAVE_BELOS_XPETRA_TIMERS
1303  Teuchos::TimeMonitor lcltimer(*mvTimesMatAddMvTimer_);
1304 #endif
1305 
1306 #ifdef HAVE_XPETRA_TPETRA
1307  if (mv.getMap()->lib() == Xpetra::UseTpetra) {
1308 #if ((defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_OPENMP) && defined(HAVE_TPETRA_INST_INT_LONG_LONG))) || \
1309  (!defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_SERIAL) && defined(HAVE_TPETRA_INST_INT_LONG_LONG))))
1310  MultiVecTraitsTpetra::MvTimesMatAddMv(alpha, toTpetra(A), B, beta, toTpetra(mv));
1311  return;
1312 #endif
1313  }
1314 #endif
1315 
1316 #ifdef HAVE_XPETRA_EPETRA
1317  if (mv.getMap()->lib() == Xpetra::UseEpetra) {
1318  MultiVecTraitsEpetra::MvTimesMatAddMv(alpha, toEpetra(A), B, beta, toEpetra(mv));
1319  return;
1320  }
1321 #endif
1322 
1324  }
1325 
1326  static void MvAddMv( Scalar alpha, const Xpetra::MultiVector<Scalar,LO,GO,Node>& A, Scalar beta, const Xpetra::MultiVector<Scalar,LO,GO,Node>& B, Xpetra::MultiVector<Scalar,LO,GO,Node>& mv )
1327  {
1328 
1329 #ifdef HAVE_XPETRA_TPETRA
1330  if (mv.getMap()->lib() == Xpetra::UseTpetra) {
1331 #if ((defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_OPENMP) && defined(HAVE_TPETRA_INST_INT_LONG_LONG))) || \
1332  (!defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_SERIAL) && defined(HAVE_TPETRA_INST_INT_LONG_LONG))))
1333  MultiVecTraitsTpetra::MvAddMv(alpha, toTpetra(A), beta, toTpetra(B), toTpetra(mv));
1334  return;
1335 #endif
1336  }
1337 #endif
1338 
1339 #ifdef HAVE_XPETRA_EPETRA
1340  if (mv.getMap()->lib() == Xpetra::UseEpetra) {
1341  MultiVecTraitsEpetra::MvAddMv(alpha, toEpetra(A), beta, toEpetra(B), toEpetra(mv));
1342  return;
1343  }
1344 #endif
1345 
1347  }
1348 
1349  static void MvScale ( Xpetra::MultiVector<Scalar,LO,GO,Node>& mv, Scalar alpha )
1350  {
1351 
1352 #ifdef HAVE_XPETRA_TPETRA
1353  if (mv.getMap()->lib() == Xpetra::UseTpetra) {
1354 #if ((defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_OPENMP) && defined(HAVE_TPETRA_INST_INT_LONG_LONG))) || \
1355  (!defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_SERIAL) && defined(HAVE_TPETRA_INST_INT_LONG_LONG))))
1356  MultiVecTraitsTpetra::MvScale(toTpetra(mv), alpha);
1357  return;
1358 #endif
1359  }
1360 #endif
1361 
1362 #ifdef HAVE_XPETRA_EPETRA
1363  if (mv.getMap()->lib() == Xpetra::UseEpetra) {
1364  MultiVecTraitsEpetra::MvScale(toEpetra(mv), alpha);
1365  return;
1366  }
1367 #endif
1368 
1370  }
1371 
1372  static void MvScale ( Xpetra::MultiVector<Scalar,LO,GO,Node>& mv, const std::vector<Scalar>& alphas )
1373  {
1374 
1375 #ifdef HAVE_XPETRA_TPETRA
1376  if (mv.getMap()->lib() == Xpetra::UseTpetra) {
1377 #if ((defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_OPENMP) && defined(HAVE_TPETRA_INST_INT_LONG_LONG))) || \
1378  (!defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_SERIAL) && defined(HAVE_TPETRA_INST_INT_LONG_LONG))))
1379  MultiVecTraitsTpetra::MvScale(toTpetra(mv), alphas);
1380  return;
1381 #endif
1382  }
1383 #endif
1384 
1385 #ifdef HAVE_XPETRA_EPETRA
1386  if (mv.getMap()->lib() == Xpetra::UseEpetra) {
1387  MultiVecTraitsEpetra::MvScale(toEpetra(mv), alphas);
1388  return;
1389  }
1390 #endif
1391 
1393  }
1394 
1396  {
1397 
1398 #ifdef HAVE_BELOS_XPETRA_TIMERS
1399  Teuchos::TimeMonitor lcltimer(*mvTransMvTimer_);
1400 #endif
1401 
1402 #ifdef HAVE_XPETRA_TPETRA
1403  if (A.getMap()->lib() == Xpetra::UseTpetra) {
1404 #if ((defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_OPENMP) && defined(HAVE_TPETRA_INST_INT_LONG_LONG))) || \
1405  (!defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_SERIAL) && defined(HAVE_TPETRA_INST_INT_LONG_LONG))))
1406  MultiVecTraitsTpetra::MvTransMv(alpha, toTpetra(A), toTpetra(B), C);
1407  return;
1408 #endif
1409  }
1410 #endif
1411 
1412 #ifdef HAVE_XPETRA_EPETRA
1413  if (A.getMap()->lib() == Xpetra::UseEpetra) {
1414  MultiVecTraitsEpetra::MvTransMv(alpha, toEpetra(A), toEpetra(B), C);
1415  return;
1416  }
1417 #endif
1418 
1420  }
1421 
1422  static void MvDot( const Xpetra::MultiVector<Scalar,LO,GO,Node>& A, const Xpetra::MultiVector<Scalar,LO,GO,Node>& B, std::vector<Scalar> &dots)
1423  {
1424 
1425 #ifdef HAVE_XPETRA_TPETRA
1426  if (A.getMap()->lib() == Xpetra::UseTpetra) {
1427 #if ((defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_OPENMP) && defined(HAVE_TPETRA_INST_INT_LONG_LONG))) || \
1428  (!defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_SERIAL) && defined(HAVE_TPETRA_INST_INT_LONG_LONG))))
1429  MultiVecTraitsTpetra::MvDot(toTpetra(A), toTpetra(B), dots);
1430  return;
1431 #endif
1432  }
1433 #endif
1434 
1435 #ifdef HAVE_XPETRA_EPETRA
1436  if (A.getMap()->lib() == Xpetra::UseEpetra) {
1437  MultiVecTraitsEpetra::MvDot(toEpetra(A), toEpetra(B), dots);
1438  return;
1439  }
1440 #endif
1441 
1443  }
1444 
1445  static void MvNorm(const Xpetra::MultiVector<Scalar,LO,GO,Node>& mv, std::vector<Teuchos::ScalarTraits<Scalar>::magnitudeType> &normvec, NormType type=TwoNorm)
1446  {
1447 
1448 #ifdef HAVE_XPETRA_TPETRA
1449  if (mv.getMap()->lib() == Xpetra::UseTpetra) {
1450 #if ((defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_OPENMP) && defined(HAVE_TPETRA_INST_INT_LONG_LONG))) || \
1451  (!defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_SERIAL) && defined(HAVE_TPETRA_INST_INT_LONG_LONG))))
1452  MultiVecTraitsTpetra::MvNorm(toTpetra(mv), normvec, type);
1453  return;
1454 #endif
1455  }
1456 #endif
1457 
1458 #ifdef HAVE_XPETRA_EPETRA
1459  if (mv.getMap()->lib() == Xpetra::UseEpetra) {
1460  MultiVecTraitsEpetra::MvNorm(toEpetra(mv), normvec, type);
1461  return;
1462  }
1463 #endif
1464 
1466  }
1467 
1468  static void SetBlock( const Xpetra::MultiVector<Scalar,LO,GO,Node>& A, const std::vector<int>& index, Xpetra::MultiVector<Scalar,LO,GO,Node>& mv )
1469  {
1470 
1471 #ifdef HAVE_XPETRA_TPETRA
1472  if (mv.getMap()->lib() == Xpetra::UseTpetra) {
1473 #if ((defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_OPENMP) && defined(HAVE_TPETRA_INST_INT_LONG_LONG))) || \
1474  (!defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_SERIAL) && defined(HAVE_TPETRA_INST_INT_LONG_LONG))))
1475  MultiVecTraitsTpetra::SetBlock(toTpetra(A), index, toTpetra(mv));
1476  return;
1477 #endif
1478  }
1479 #endif
1480 
1481 #ifdef HAVE_XPETRA_EPETRA
1482  if (mv.getMap()->lib() == Xpetra::UseEpetra) {
1483  MultiVecTraitsEpetra::SetBlock(toEpetra(A), index, toEpetra(mv));
1484  return;
1485  }
1486 #endif
1487 
1489  }
1490 
1491  static void
1492  SetBlock (const Xpetra::MultiVector<Scalar,LO,GO,Node>& A,
1493  const Teuchos::Range1D& index,
1495  {
1496 
1497 #ifdef HAVE_XPETRA_TPETRA
1498  if (mv.getMap()->lib() == Xpetra::UseTpetra) {
1499 #if ((defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_OPENMP) && defined(HAVE_TPETRA_INST_INT_LONG_LONG))) || \
1500  (!defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_SERIAL) && defined(HAVE_TPETRA_INST_INT_LONG_LONG))))
1501  MultiVecTraitsTpetra::SetBlock(toTpetra(A), index, toTpetra(mv));
1502  return;
1503 #endif
1504  }
1505 #endif
1506 
1507 #ifdef HAVE_XPETRA_EPETRA
1508  if (mv.getMap()->lib() == Xpetra::UseEpetra) {
1509  MultiVecTraitsEpetra::SetBlock(toEpetra(A), index, toEpetra(mv));
1510  return;
1511  }
1512 #endif
1513 
1515  }
1516 
1517  static void
1518  Assign (const Xpetra::MultiVector<Scalar,LO,GO,Node>& A,
1520  {
1521 
1522 #ifdef HAVE_XPETRA_TPETRA
1523  if (mv.getMap()->lib() == Xpetra::UseTpetra) {
1524 #if ((defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_OPENMP) && defined(HAVE_TPETRA_INST_INT_LONG_LONG))) || \
1525  (!defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_SERIAL) && defined(HAVE_TPETRA_INST_INT_LONG_LONG))))
1526  MultiVecTraitsTpetra::Assign(toTpetra(A), toTpetra(mv));
1527  return;
1528 #endif
1529  }
1530 #endif
1531 
1532 #ifdef HAVE_XPETRA_EPETRA
1533  if (mv.getMap()->lib() == Xpetra::UseEpetra) {
1534  MultiVecTraitsEpetra::Assign(toEpetra(A), toEpetra(mv));
1535  return;
1536  }
1537 #endif
1538 
1540  }
1541 
1542  static void MvRandom( Xpetra::MultiVector<Scalar,LO,GO,Node>& mv )
1543  {
1544 
1545 #ifdef HAVE_XPETRA_TPETRA
1546  if (mv.getMap()->lib() == Xpetra::UseTpetra) {
1547 #if ((defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_OPENMP) && defined(HAVE_TPETRA_INST_INT_LONG_LONG))) || \
1548  (!defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_SERIAL) && defined(HAVE_TPETRA_INST_INT_LONG_LONG))))
1549  MultiVecTraitsTpetra::MvRandom(toTpetra(mv));
1550  return;
1551 #endif
1552  }
1553 #endif
1554 
1555 #ifdef HAVE_XPETRA_EPETRA
1556  if (mv.getMap()->lib() == Xpetra::UseEpetra) {
1557  MultiVecTraitsEpetra::MvRandom(toEpetra(mv));
1558  return;
1559  }
1560 #endif
1561 
1563  }
1564 
1565  static void MvInit( Xpetra::MultiVector<Scalar,LO,GO,Node>& mv, Scalar alpha = Teuchos::ScalarTraits<Scalar>::zero() )
1566  {
1567 
1568 #ifdef HAVE_XPETRA_TPETRA
1569  if (mv.getMap()->lib() == Xpetra::UseTpetra) {
1570 #if ((defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_OPENMP) && defined(HAVE_TPETRA_INST_INT_LONG_LONG))) || \
1571  (!defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_SERIAL) && defined(HAVE_TPETRA_INST_INT_LONG_LONG))))
1572  MultiVecTraitsTpetra::MvInit(toTpetra(mv), alpha);
1573  return;
1574 #endif
1575  }
1576 #endif
1577 
1578 #ifdef HAVE_XPETRA_EPETRA
1579  if (mv.getMap()->lib() == Xpetra::UseEpetra) {
1580  MultiVecTraitsEpetra::MvInit(toEpetra(mv), alpha);
1581  return;
1582  }
1583 #endif
1584 
1586  }
1587 
1588  static void MvPrint( const Xpetra::MultiVector<Scalar,LO,GO,Node>& mv, std::ostream& os )
1589  {
1590 
1591 #ifdef HAVE_XPETRA_TPETRA
1592  if (mv.getMap()->lib() == Xpetra::UseTpetra) {
1593 #if ((defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_OPENMP) && defined(HAVE_TPETRA_INST_INT_LONG_LONG))) || \
1594  (!defined(EPETRA_HAVE_OMP) && (defined(HAVE_TPETRA_INST_SERIAL) && defined(HAVE_TPETRA_INST_INT_LONG_LONG))))
1595  MultiVecTraitsTpetra::MvPrint(toTpetra(mv), os);
1596  return;
1597 #endif
1598  }
1599 #endif
1600 
1601 #ifdef HAVE_XPETRA_EPETRA
1602  if (mv.getMap()->lib() == Xpetra::UseEpetra) {
1603  MultiVecTraitsEpetra::MvPrint(toEpetra(mv), os);
1604  return;
1605  }
1606 #endif
1607 
1609  }
1610  };
1611 #endif // #ifndef EPETRA_NO_64BIT_GLOBAL_INDICES
1612 #endif // HAVE_XPETRA_EPETRA
1613 
1614 
1615 } // end of Belos namespace
1616 
1617 #endif
static bool HasConstantStride(const Xpetra::MultiVector< Scalar, LO, GO, Node > &mv)
static RCP< Xpetra::MultiVector< Scalar, LO, GO, Node > > CloneCopy(const Xpetra::MultiVector< Scalar, LO, GO, Node > &mv)
static RCP< Xpetra::MultiVector< Scalar, LO, GO, Node > > CloneViewNonConst(Xpetra::MultiVector< Scalar, LO, GO, Node > &mv, const std::vector< int > &index)
static void MvInit(Xpetra::MultiVector< Scalar, LO, GO, Node > &mv, Scalar alpha=Teuchos::ScalarTraits< Scalar >::zero())
GlobalOrdinal GO
static void MvTransMv(Scalar alpha, const Xpetra::MultiVector< Scalar, LO, GO, Node > &A, const Xpetra::MultiVector< Scalar, LO, GO, Node > &B, Teuchos::SerialDenseMatrix< int, Scalar > &C)
static RCP< const Xpetra::MultiVector< Scalar, LO, GO, Node > > CloneView(const Xpetra::MultiVector< Scalar, LO, GO, Node > &mv, const Teuchos::Range1D &index)
static void MvPrint(const Xpetra::MultiVector< Scalar, LO, GO, Node > &mv, std::ostream &os)
EpetraMultiVectorT< int, typename Xpetra::Map< int, int >::node_type > EpetraMultiVector
LocalOrdinal LO
const Epetra_CrsGraph & toEpetra(const RCP< const CrsGraph< int, GlobalOrdinal, Node > > &graph)
#define XPETRA_FACTORY_ERROR_IF_EPETRA(lib)
static RCP< Xpetra::MultiVector< Scalar, LO, GO, Node > > CloneCopy(const Xpetra::MultiVector< Scalar, LO, GO, Node > &mv, const std::vector< int > &index)
static void SetBlock(const Xpetra::MultiVector< Scalar, LO, GO, Node > &A, const std::vector< int > &index, Xpetra::MultiVector< Scalar, LO, GO, Node > &mv)
static RCP< Xpetra::MultiVector< Scalar, LO, GO, Node > > CloneViewNonConst(Xpetra::MultiVector< Scalar, LO, GO, Node > &mv, const Teuchos::Range1D &index)
static void MvScale(Xpetra::MultiVector< Scalar, LO, GO, Node > &mv, Scalar alpha)
TEUCHOS_DEPRECATED RCP< T > rcp(T *p, Dealloc_T dealloc, bool owns_mem)
static void MvDot(const Xpetra::MultiVector< Scalar, LO, GO, Node > &A, const Xpetra::MultiVector< Scalar, LO, GO, Node > &B, std::vector< Scalar > &dots)
virtual Teuchos::RCP< const Map< LocalOrdinal, GlobalOrdinal, Node > > getMap() const =0
static int GetNumberVecs(const Xpetra::MultiVector< Scalar, LO, GO, Node > &mv)
#define XPETRA_FACTORY_END
static void SetBlock(const Xpetra::MultiVector< Scalar, LO, GO, Node > &A, const Teuchos::Range1D &index, Xpetra::MultiVector< Scalar, LO, GO, Node > &mv)
RCP< const Tpetra::CrsGraph< LocalOrdinal, GlobalOrdinal, Node > > toTpetra(const RCP< const CrsGraph< LocalOrdinal, GlobalOrdinal, Node > > &graph)
static void MvScale(Xpetra::MultiVector< Scalar, LO, GO, Node > &mv, const std::vector< Scalar > &alphas)
static ptrdiff_t GetGlobalLength(const Xpetra::MultiVector< Scalar, LO, GO, Node > &mv)
static RCP< const Xpetra::MultiVector< Scalar, LO, GO, Node > > CloneView(const Xpetra::MultiVector< Scalar, LO, GO, Node > &mv, const std::vector< int > &index)
static RCP< Xpetra::MultiVector< Scalar, LO, GO, Node > > Clone(const Xpetra::MultiVector< Scalar, LO, GO, Node > &mv, const int numvecs)
static void MvAddMv(Scalar alpha, const Xpetra::MultiVector< Scalar, LO, GO, Node > &A, Scalar beta, const Xpetra::MultiVector< Scalar, LO, GO, Node > &B, Xpetra::MultiVector< Scalar, LO, GO, Node > &mv)
static void MvTimesMatAddMv(Scalar alpha, const Xpetra::MultiVector< Scalar, LO, GO, Node > &A, const Teuchos::SerialDenseMatrix< int, Scalar > &B, Scalar beta, Xpetra::MultiVector< Scalar, LO, GO, Node > &mv)
static void MvNorm(const Xpetra::MultiVector< Scalar, LO, GO, Node > &mv, std::vector< typename Teuchos::ScalarTraits< Scalar >::magnitudeType > &normvec, NormType type=TwoNorm)
static RCP< Xpetra::MultiVector< Scalar, LO, GO, Node > > CloneCopy(const Xpetra::MultiVector< Scalar, LO, GO, Node > &mv, const Teuchos::Range1D &index)
static void Assign(const Xpetra::MultiVector< Scalar, LO, GO, Node > &A, Xpetra::MultiVector< Scalar, LO, GO, Node > &mv)