82 #ifndef AMESOS2_FACTORY_HPP
83 #define AMESOS2_FACTORY_HPP
85 #include "Amesos2_config.h"
87 #include "Amesos2_Solver.hpp"
90 #include "Teuchos_ScalarTraits.hpp"
92 #include "Amesos2_MatrixTraits.hpp"
95 #ifdef HAVE_AMESOS2_BASKER
96 #include "Amesos2_Basker.hpp"
99 #ifdef HAVE_AMESOS2_SHYLU_NODEBASKER
100 #include "Amesos2_ShyLUBasker.hpp"
103 #if defined(HAVE_AMESOS2_KLU2)
104 #include "Amesos2_KLU2.hpp"
107 #ifdef HAVE_AMESOS2_SUPERLUDIST // Distributed-memory SuperLU
108 #include "Amesos2_Superludist.hpp"
111 #ifdef HAVE_AMESOS2_SUPERLUMT // Multi-threaded SuperLU
112 #include "Amesos2_Superlumt.hpp"
115 #ifdef HAVE_AMESOS2_UMFPACK // Umfpack
116 #include "Amesos2_Umfpack.hpp"
119 #ifdef HAVE_AMESOS2_SHYLU_NODETACHO // Tacho
120 #include "Amesos2_Tacho.hpp"
123 #ifdef HAVE_AMESOS2_SUPERLU // Sequential SuperLU
124 #include "Amesos2_Superlu.hpp"
127 #ifdef HAVE_AMESOS2_PARDISO_MKL // MKL version of Pardiso
128 #include "Amesos2_PardisoMKL.hpp"
131 #ifdef HAVE_AMESOS2_LAPACK
132 #include "Amesos2_Lapack.hpp"
135 #if defined (HAVE_AMESOS2_CHOLMOD) && defined (HAVE_AMESOS2_EXPERIMENTAL)
136 #include "Amesos2_Cholmod.hpp"
139 #if defined (HAVE_AMESOS2_CUSOLVER) && defined (HAVE_AMESOS2_CUSPARSE)
140 #include "Amesos2_cuSOLVER.hpp"
143 #ifdef HAVE_AMESOS2_MUMPS
144 #include "Amesos2_MUMPS.hpp"
147 #ifdef HAVE_AMESOS2_STRUMPACK
148 #include "Amesos2_STRUMPACK.hpp"
154 template <
class,
class>
class Solver;
159 std::string tolower(
const std::string& s);
176 template <
class Matrix,
178 Solver<Matrix,Vector>*
179 create(
const Matrix* A, Vector* X,
const Vector* B);
196 template <
class Matrix,
198 Teuchos::RCP<Solver<Matrix,Vector> >
199 create(Teuchos::RCP<const Matrix> A,
200 Teuchos::RCP<Vector> X,
201 Teuchos::RCP<const Vector> B);
221 template <
class Matrix,
223 Solver<Matrix,Vector>*
224 create(
const char* solverName,
const Matrix* A, Vector* X,
const Vector* B);
243 template <
class Matrix,
245 Teuchos::RCP<Solver<Matrix,Vector> >
246 create(
const char* solverName,
247 const Teuchos::RCP<const Matrix> A,
248 const Teuchos::RCP<Vector> X,
249 const Teuchos::RCP<const Vector> B);
268 template <
class Matrix,
270 Solver<Matrix,Vector>*
271 create(
const std::string& solverName,
const Matrix* A, Vector* X,
const Vector* B);
290 template <
class Matrix,
292 Teuchos::RCP<Solver<Matrix,Vector> >
293 create(
const std::string& solverName,
294 const Teuchos::RCP<const Matrix> A,
295 const Teuchos::RCP<Vector> X,
296 const Teuchos::RCP<const Vector> B);
317 template <
class Matrix,
319 Solver<Matrix,Vector>*
320 create(
const std::string& solverName,
const Matrix* A);
341 template <
class Matrix,
343 Teuchos::RCP<Solver<Matrix,Vector> >
344 create(
const std::string& solverName,
345 const Teuchos::RCP<const Matrix> A);
352 template <
template <
class,
class>
class ConcreteSolver,
355 struct create_solver_with_supported_type {
356 static Teuchos::RCP<Solver<Matrix,Vector> > apply(Teuchos::RCP<const Matrix> A,
357 Teuchos::RCP<Vector> X,
358 Teuchos::RCP<const Vector> B )
362 typename MatrixTraits<Matrix>::scalar_t,
363 typename MultiVecAdapter<Vector>::scalar_t
365 > same_scalar_assertion;
366 (void)same_scalar_assertion;
369 return rcp(
new ConcreteSolver<Matrix,Vector>(A, X, B) );
381 template <
template <
class,
class>
class ConcreteSolver,
384 struct throw_no_scalar_support_exception {
385 static Teuchos::RCP<Solver<Matrix,Vector> > apply(Teuchos::RCP<const Matrix> A,
386 Teuchos::RCP<Vector> X,
387 Teuchos::RCP<const Vector> B )
390 typedef typename MatrixTraits<Matrix>::scalar_t scalar_t;
391 TEUCHOS_TEST_FOR_EXCEPTION(
true,
392 std::invalid_argument,
393 "The requested Amesos2 "
395 " solver interface does not support the " <<
396 Teuchos::ScalarTraits<scalar_t>::name() <<
401 template <
template <
class,
class>
class ConcreteSolver,
404 struct throw_no_matrix_support_exception {
405 static Teuchos::RCP<Solver<Matrix,Vector> > apply(Teuchos::RCP<const Matrix> A,
406 Teuchos::RCP<Vector> X,
407 Teuchos::RCP<const Vector> B )
409 TEUCHOS_TEST_FOR_EXCEPTION(
true,
410 std::invalid_argument,
411 "This solver does not support the kokkos adapter." );
424 template <
template <
class,
class>
class ConcreteSolver,
427 struct handle_solver_scalar_type_support {
428 static Teuchos::RCP<Solver<Matrix,Vector> > apply(Teuchos::RCP<const Matrix> A,
429 Teuchos::RCP<Vector> X,
430 Teuchos::RCP<const Vector> B )
432 return std::conditional_t<
433 solver_supports_scalar<ConcreteSolver, typename MatrixTraits<Matrix>::scalar_t>::value,
434 create_solver_with_supported_type<ConcreteSolver,Matrix,Vector>,
435 throw_no_scalar_support_exception<ConcreteSolver,Matrix,Vector> >::apply(A, X, B);
448 template <
template <
class,
class>
class ConcreteSolver,
451 struct handle_solver_matrix_and_type_support {
452 static Teuchos::RCP<Solver<Matrix,Vector> > apply(Teuchos::RCP<const Matrix> A,
453 Teuchos::RCP<Vector> X,
454 Teuchos::RCP<const Vector> B )
456 return std::conditional_t<
457 solver_supports_matrix<ConcreteSolver, Matrix>::value,
458 handle_solver_scalar_type_support<ConcreteSolver,Matrix,Vector>,
459 throw_no_matrix_support_exception<ConcreteSolver,Matrix,Vector> >::apply(A, X, B);
474 bool query(
const char* solverName);
484 bool query(
const std::string& solverName);
491 template <
class Matrix,
493 Solver<Matrix,Vector>*
494 create(Matrix* A, Vector* X, Vector* B)
496 std::string solver =
"Klu2";
498 return( create(solver, rcp(A,
false), rcp(X,
false), rcp(B,
false)).getRawPtr() );
502 template <
class Matrix,
504 Teuchos::RCP<Solver<Matrix,Vector> >
505 create(Teuchos::RCP<const Matrix> A,
506 Teuchos::RCP<Vector> X,
507 Teuchos::RCP<const Vector> B)
509 std::string solver =
"Klu2";
510 return( create(solver, A, X, B) );
514 template <
class Matrix,
516 Solver<Matrix,Vector>*
517 create(
const char* solverName,
const Matrix* A, Vector* X,
const Vector* B)
519 std::string solver = solverName;
521 return( create(solver, rcp(A,
false), rcp(X,
false), rcp(B,
false)).getRawPtr() );
525 template <
class Matrix,
527 Teuchos::RCP<Solver<Matrix,Vector> >
528 create(
const char* solverName,
529 const Teuchos::RCP<const Matrix> A,
530 const Teuchos::RCP<Vector> X,
531 const Teuchos::RCP<const Vector> B)
533 std::string solver = solverName;
534 return( create(solver, A, X, B) );
538 template <
class Matrix,
540 Solver<Matrix,Vector>*
541 create(
const std::string& solverName,
const Matrix* A){
542 return( create(solverName, rcp(A,
false),
543 Teuchos::RCP<Vector>(),
544 Teuchos::RCP<const Vector>()).getRawPtr() );
548 template <
class Matrix,
550 Teuchos::RCP<Solver<Matrix,Vector> >
551 create(
const std::string& solverName,
const Teuchos::RCP<const Matrix> A){
552 return( create(solverName, A, Teuchos::RCP<Vector>(), Teuchos::RCP<const Vector>()) );
556 template <
class Matrix,
558 Teuchos::RCP<Solver<Matrix,Vector> >
559 create(
const std::string& solverName,
const Matrix* A, Vector* X,
const Vector* B)
562 return( create(solverName, rcp(A,
false), rcp(X,
false), rcp(B,
false)) );
566 template <
class Matrix,
568 Teuchos::RCP<Solver<Matrix,Vector> >
569 create(
const std::string& solver_name,
570 const Teuchos::RCP<const Matrix> A,
571 const Teuchos::RCP<Vector> X,
572 const Teuchos::RCP<const Vector> B)
574 std::string solverName = tolower(solver_name);
579 #ifdef HAVE_AMESOS2_SHYLU_NODEBASKER
580 if((solverName ==
"ShyLUBasker") || (solverName ==
"shylubasker") || (solverName ==
"amesos2_shylubasker"))
582 return handle_solver_matrix_and_type_support<ShyLUBasker, Matrix,Vector>::apply(A,X,B);
586 #ifdef HAVE_AMESOS2_BASKER
587 if((solverName ==
"Basker") || (solverName ==
"basker") || (solverName ==
"amesos2_basker"))
589 return handle_solver_matrix_and_type_support<Basker, Matrix,Vector>::apply(A,X,B);
594 #ifdef HAVE_AMESOS2_KLU2
595 if((solverName ==
"amesos2_klu2") || (solverName ==
"klu2") ||
596 (solverName ==
"amesos2_klu") || (solverName ==
"klu")){
597 return handle_solver_matrix_and_type_support<KLU2,Matrix,Vector>::apply(A, X, B);
601 #ifdef HAVE_AMESOS2_SUPERLUDIST
602 if((solverName ==
"amesos2_superludist") ||
603 (solverName ==
"superludist") ||
604 (solverName ==
"amesos2_superlu_dist") ||
605 (solverName ==
"superlu_dist")){
606 return handle_solver_matrix_and_type_support<Superludist,Matrix,Vector>::apply(A, X, B);
610 #ifdef HAVE_AMESOS2_SUPERLUMT
611 if((solverName ==
"amesos2_superlumt") ||
612 (solverName ==
"superlumt") ||
613 (solverName ==
"amesos2_superlu_mt") ||
614 (solverName ==
"superlu_mt")){
615 return handle_solver_matrix_and_type_support<Superlumt,Matrix,Vector>::apply(A, X, B);
619 #ifdef HAVE_AMESOS2_UMFPACK
620 if((solverName ==
"amesos2_umfpack") ||
621 (solverName ==
"umfpack")){
622 return handle_solver_matrix_and_type_support<Umfpack,Matrix,Vector>::apply(A, X, B);
626 #ifdef HAVE_AMESOS2_SHYLU_NODETACHO
627 if((solverName ==
"amesos2_tacho") ||
628 (solverName ==
"tacho")){
629 return handle_solver_matrix_and_type_support<TachoSolver,Matrix,Vector>::apply(A, X, B);
634 #ifdef HAVE_AMESOS2_SUPERLU
635 if((solverName ==
"amesos2_superlu") ||
636 (solverName ==
"superlu")){
637 return handle_solver_matrix_and_type_support<Superlu,Matrix,Vector>::apply(A, X, B);
641 #ifdef HAVE_AMESOS2_PARDISO_MKL
642 if((solverName ==
"amesos2_pardiso_mkl") ||
643 (solverName ==
"pardiso_mkl") ||
644 (solverName ==
"amesos2_pardisomkl") ||
645 (solverName ==
"pardisomkl")){
646 return handle_solver_matrix_and_type_support<PardisoMKL,Matrix,Vector>::apply(A, X, B);
650 #ifdef HAVE_AMESOS2_LAPACK
651 if((solverName ==
"amesos2_lapack") ||
652 (solverName ==
"lapack")){
653 return handle_solver_matrix_and_type_support<Lapack,Matrix,Vector>::apply(A, X, B);
658 #ifdef HAVE_AMESOS2_MUMPS
659 if((solverName ==
"MUMPS") || (solverName ==
"mumps") ||
660 (solverName ==
"amesos2_MUMPS") || (solverName ==
"amesos2_mumps"))
662 return handle_solver_matrix_and_type_support<MUMPS,Matrix,Vector>::apply(A,X,B);
666 #ifdef HAVE_AMESOS2_STRUMPACK
667 if((solverName ==
"STRUMPACK") || (solverName ==
"strumpack") ||
668 (solverName ==
"amesos2_STRUMPACK") || (solverName ==
"amesos2_strumpack"))
670 return handle_solver_matrix_and_type_support<STRUMPACK,Matrix,Vector>::apply(A,X,B);
674 #if defined (HAVE_AMESOS2_CHOLMOD) && defined (HAVE_AMESOS2_EXPERIMENTAL)
675 if(solverName ==
"amesos2_cholmod" || solverName ==
"cholmod")
676 return handle_solver_matrix_and_type_support<Cholmod,Matrix,Vector>::apply(A, X, B);
679 #if defined (HAVE_AMESOS2_CUSOLVER) && defined (HAVE_AMESOS2_CUSPARSE)
680 if(solverName ==
"amesos2_cusolver" || solverName ==
"cusolver")
681 return handle_solver_matrix_and_type_support<cuSOLVER,Matrix,Vector>::apply(A, X, B);
688 std::string err_msg = solver_name +
" is not enabled or is not supported";
689 TEUCHOS_TEST_FOR_EXCEPTION(
true, std::invalid_argument, err_msg);
695 #endif // AMESOS2_FACTORY_HPP
A templated adapter/wrapper class for Trilinos Multivector type classes. Provides the functions neces...
Simple compile-time assertion class.
Provides access to interesting solver traits.